src/mess/machine/msx_slot.c
| r2822 | r2823 | |
| 29 | 29 | |
| 30 | 30 | extern MSX msx1; |
| 31 | 31 | |
| 32 | | static void msx_cpu_setbank (int page, UINT8 *mem) |
| 32 | static void msx_cpu_setbank (running_machine *machine, int page, UINT8 *mem) |
| 33 | 33 | { |
| 34 | 34 | switch (page) { |
| 35 | 35 | case 1: |
| r2822 | r2823 | |
| 40 | 40 | case 4: |
| 41 | 41 | memory_set_bankptr (4, mem); |
| 42 | 42 | memory_set_bankptr (5, mem + 0x1ff8); |
| 43 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x7ff8, 0x7fff, 0, 0, SMH_BANK5); |
| 43 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x7ff8, 0x7fff, 0, 0, SMH_BANK5); |
| 44 | 44 | break; |
| 45 | 45 | case 5: |
| 46 | 46 | memory_set_bankptr (6, mem); |
| 47 | 47 | memory_set_bankptr (7, mem + 0x1800); |
| 48 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x9800, 0x9fff, 0, 0, SMH_BANK7); |
| 48 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x9800, 0x9fff, 0, 0, SMH_BANK7); |
| 49 | 49 | break; |
| 50 | 50 | case 6: |
| 51 | 51 | memory_set_bankptr (8, mem); |
| 52 | 52 | memory_set_bankptr (9, mem + 0x1800); |
| 53 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0xb800, 0xbfff, 0, 0, SMH_BANK9); |
| 53 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0xb800, 0xbfff, 0, 0, SMH_BANK9); |
| 54 | 54 | break; |
| 55 | 55 | case 7: |
| 56 | 56 | memory_set_bankptr (10, mem); |
| r2822 | r2823 | |
| 76 | 76 | |
| 77 | 77 | MSX_SLOT_MAP(empty) |
| 78 | 78 | { |
| 79 | | msx_cpu_setbank (page * 2 + 1, msx1.empty); |
| 80 | | msx_cpu_setbank (page * 2 + 2, msx1.empty); |
| 79 | running_machine *machine = Machine; |
| 80 | msx_cpu_setbank (machine, page * 2 + 1, msx1.empty); |
| 81 | msx_cpu_setbank (machine, page * 2 + 2, msx1.empty); |
| 81 | 82 | } |
| 82 | 83 | |
| 83 | 84 | MSX_SLOT_INIT(rom) |
| r2822 | r2823 | |
| 97 | 98 | |
| 98 | 99 | MSX_SLOT_MAP(rom) |
| 99 | 100 | { |
| 101 | running_machine *machine = Machine; |
| 100 | 102 | UINT8 *mem = state->mem + (page - state->start_page) * 0x4000; |
| 101 | 103 | |
| 102 | | msx_cpu_setbank (page * 2 + 1, mem); |
| 103 | | msx_cpu_setbank (page * 2 + 2, mem + 0x2000); |
| 104 | msx_cpu_setbank (machine, page * 2 + 1, mem); |
| 105 | msx_cpu_setbank (machine, page * 2 + 2, mem + 0x2000); |
| 104 | 106 | } |
| 105 | 107 | |
| 106 | 108 | MSX_SLOT_INIT(ram) |
| r2822 | r2823 | |
| 116 | 118 | |
| 117 | 119 | MSX_SLOT_MAP(ram) |
| 118 | 120 | { |
| 121 | running_machine *machine = Machine; |
| 119 | 122 | UINT8 *mem = state->mem + (page - state->start_page) * 0x4000; |
| 120 | 123 | |
| 121 | 124 | msx1.ram_pages[page] = mem; |
| 122 | | msx_cpu_setbank (page * 2 + 1, mem); |
| 123 | | msx_cpu_setbank (page * 2 + 2, mem + 0x2000); |
| 125 | msx_cpu_setbank (machine, page * 2 + 1, mem); |
| 126 | msx_cpu_setbank (machine, page * 2 + 2, mem + 0x2000); |
| 124 | 127 | } |
| 125 | 128 | |
| 126 | 129 | MSX_SLOT_RESET(ram) |
| r2822 | r2823 | |
| 179 | 182 | |
| 180 | 183 | MSX_SLOT_MAP(rammm) |
| 181 | 184 | { |
| 185 | running_machine *machine = Machine; |
| 182 | 186 | UINT8 *mem = state->mem + |
| 183 | 187 | 0x4000 * (msx1.ram_mapper[page] & state->bank_mask); |
| 184 | 188 | |
| 185 | 189 | msx1.ram_pages[page] = mem; |
| 186 | | msx_cpu_setbank (page * 2 + 1, mem); |
| 187 | | msx_cpu_setbank (page * 2 + 2, mem + 0x2000); |
| 190 | msx_cpu_setbank (machine, page * 2 + 1, mem); |
| 191 | msx_cpu_setbank (machine, page * 2 + 2, mem + 0x2000); |
| 188 | 192 | } |
| 189 | 193 | |
| 190 | 194 | MSX_SLOT_INIT(msxdos2) |
| r2822 | r2823 | |
| 207 | 211 | |
| 208 | 212 | MSX_SLOT_MAP(msxdos2) |
| 209 | 213 | { |
| 214 | running_machine *machine = Machine; |
| 210 | 215 | if (page != 1) { |
| 211 | | msx_cpu_setbank (page * 2 + 1, msx1.empty); |
| 212 | | msx_cpu_setbank (page * 2 + 2, msx1.empty); |
| 216 | msx_cpu_setbank (machine, page * 2 + 1, msx1.empty); |
| 217 | msx_cpu_setbank (machine, page * 2 + 2, msx1.empty); |
| 213 | 218 | } else { |
| 214 | | msx_cpu_setbank (3, state->mem + state->banks[0] * 0x4000); |
| 215 | | msx_cpu_setbank (4, state->mem + state->banks[0] * 0x4000 + 0x2000); |
| 219 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x4000); |
| 220 | msx_cpu_setbank (machine, 4, state->mem + state->banks[0] * 0x4000 + 0x2000); |
| 216 | 221 | } |
| 217 | 222 | } |
| 218 | 223 | |
| r2822 | r2823 | |
| 255 | 260 | |
| 256 | 261 | MSX_SLOT_MAP(konami) |
| 257 | 262 | { |
| 263 | running_machine *machine = Machine; |
| 258 | 264 | switch (page) { |
| 259 | 265 | case 0: |
| 260 | | msx_cpu_setbank (1, state->mem); |
| 261 | | msx_cpu_setbank (2, state->mem + state->banks[1] * 0x2000); |
| 266 | msx_cpu_setbank (machine, 1, state->mem); |
| 267 | msx_cpu_setbank (machine, 2, state->mem + state->banks[1] * 0x2000); |
| 262 | 268 | break; |
| 263 | 269 | case 1: |
| 264 | | msx_cpu_setbank (3, state->mem); |
| 265 | | msx_cpu_setbank (4, state->mem + state->banks[1] * 0x2000); |
| 270 | msx_cpu_setbank (machine, 3, state->mem); |
| 271 | msx_cpu_setbank (machine, 4, state->mem + state->banks[1] * 0x2000); |
| 266 | 272 | break; |
| 267 | 273 | case 2: |
| 268 | | msx_cpu_setbank (5, state->mem + state->banks[2] * 0x2000); |
| 269 | | msx_cpu_setbank (6, state->mem + state->banks[3] * 0x2000); |
| 274 | msx_cpu_setbank (machine, 5, state->mem + state->banks[2] * 0x2000); |
| 275 | msx_cpu_setbank (machine, 6, state->mem + state->banks[3] * 0x2000); |
| 270 | 276 | break; |
| 271 | 277 | case 3: |
| 272 | | msx_cpu_setbank (7, state->mem + state->banks[2] * 0x2000); |
| 273 | | msx_cpu_setbank (8, state->mem + state->banks[3] * 0x2000); |
| 278 | msx_cpu_setbank (machine, 7, state->mem + state->banks[2] * 0x2000); |
| 279 | msx_cpu_setbank (machine, 8, state->mem + state->banks[3] * 0x2000); |
| 274 | 280 | } |
| 275 | 281 | } |
| 276 | 282 | |
| r2822 | r2823 | |
| 348 | 354 | |
| 349 | 355 | MSX_SLOT_MAP(konami_scc) |
| 350 | 356 | { |
| 357 | running_machine *machine = Machine; |
| 351 | 358 | switch (page) { |
| 352 | 359 | case 0: |
| 353 | | msx_cpu_setbank (1, state->mem + state->banks[2] * 0x2000); |
| 354 | | msx_cpu_setbank (2, state->mem + state->banks[3] * 0x2000); |
| 360 | msx_cpu_setbank (machine, 1, state->mem + state->banks[2] * 0x2000); |
| 361 | msx_cpu_setbank (machine, 2, state->mem + state->banks[3] * 0x2000); |
| 355 | 362 | break; |
| 356 | 363 | case 1: |
| 357 | | msx_cpu_setbank (3, state->mem + state->banks[0] * 0x2000); |
| 358 | | msx_cpu_setbank (4, state->mem + state->banks[1] * 0x2000); |
| 364 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x2000); |
| 365 | msx_cpu_setbank (machine, 4, state->mem + state->banks[1] * 0x2000); |
| 359 | 366 | break; |
| 360 | 367 | case 2: |
| 361 | | msx_cpu_setbank (5, state->mem + state->banks[2] * 0x2000); |
| 362 | | msx_cpu_setbank (6, state->mem + state->banks[3] * 0x2000); |
| 363 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x9800, 0x9fff, 0, 0, |
| 368 | msx_cpu_setbank (machine, 5, state->mem + state->banks[2] * 0x2000); |
| 369 | msx_cpu_setbank (machine, 6, state->mem + state->banks[3] * 0x2000); |
| 370 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x9800, 0x9fff, 0, 0, |
| 364 | 371 | state->cart.scc.active ? konami_scc_bank5 : SMH_BANK7); |
| 365 | 372 | break; |
| 366 | 373 | case 3: |
| 367 | | msx_cpu_setbank (7, state->mem + state->banks[0] * 0x2000); |
| 368 | | msx_cpu_setbank (8, state->mem + state->banks[1] * 0x2000); |
| 374 | msx_cpu_setbank (machine, 7, state->mem + state->banks[0] * 0x2000); |
| 375 | msx_cpu_setbank (machine, 8, state->mem + state->banks[1] * 0x2000); |
| 369 | 376 | } |
| 370 | 377 | } |
| 371 | 378 | |
| r2822 | r2823 | |
| 459 | 466 | |
| 460 | 467 | MSX_SLOT_MAP(ascii8) |
| 461 | 468 | { |
| 469 | running_machine *machine = Machine; |
| 462 | 470 | switch (page) { |
| 463 | 471 | case 0: |
| 464 | | msx_cpu_setbank (1, msx1.empty); |
| 465 | | msx_cpu_setbank (2, msx1.empty); |
| 472 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 473 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 466 | 474 | break; |
| 467 | 475 | case 1: |
| 468 | | msx_cpu_setbank (3, state->mem + state->banks[0] * 0x2000); |
| 469 | | msx_cpu_setbank (4, state->mem + state->banks[1] * 0x2000); |
| 476 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x2000); |
| 477 | msx_cpu_setbank (machine, 4, state->mem + state->banks[1] * 0x2000); |
| 470 | 478 | break; |
| 471 | 479 | case 2: |
| 472 | | msx_cpu_setbank (5, state->mem + state->banks[2] * 0x2000); |
| 473 | | msx_cpu_setbank (6, state->mem + state->banks[3] * 0x2000); |
| 480 | msx_cpu_setbank (machine, 5, state->mem + state->banks[2] * 0x2000); |
| 481 | msx_cpu_setbank (machine, 6, state->mem + state->banks[3] * 0x2000); |
| 474 | 482 | break; |
| 475 | 483 | case 3: |
| 476 | | msx_cpu_setbank (7, msx1.empty); |
| 477 | | msx_cpu_setbank (8, msx1.empty); |
| 484 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 485 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 478 | 486 | } |
| 479 | 487 | } |
| 480 | 488 | |
| r2822 | r2823 | |
| 526 | 534 | |
| 527 | 535 | MSX_SLOT_MAP(ascii16) |
| 528 | 536 | { |
| 537 | running_machine *machine = Machine; |
| 529 | 538 | UINT8 *mem; |
| 530 | 539 | |
| 531 | 540 | switch (page) { |
| 532 | 541 | case 0: |
| 533 | | msx_cpu_setbank (1, msx1.empty); |
| 534 | | msx_cpu_setbank (2, msx1.empty); |
| 542 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 543 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 535 | 544 | break; |
| 536 | 545 | case 1: |
| 537 | 546 | mem = state->mem + state->banks[0] * 0x4000; |
| 538 | | msx_cpu_setbank (3, mem); |
| 539 | | msx_cpu_setbank (4, mem + 0x2000); |
| 547 | msx_cpu_setbank (machine, 3, mem); |
| 548 | msx_cpu_setbank (machine, 4, mem + 0x2000); |
| 540 | 549 | break; |
| 541 | 550 | case 2: |
| 542 | 551 | mem = state->mem + state->banks[1] * 0x4000; |
| 543 | | msx_cpu_setbank (5, mem); |
| 544 | | msx_cpu_setbank (6, mem + 0x2000); |
| 552 | msx_cpu_setbank (machine, 5, mem); |
| 553 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 545 | 554 | break; |
| 546 | 555 | case 3: |
| 547 | | msx_cpu_setbank (7, msx1.empty); |
| 548 | | msx_cpu_setbank (8, msx1.empty); |
| 556 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 557 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 549 | 558 | } |
| 550 | 559 | } |
| 551 | 560 | |
| r2822 | r2823 | |
| 617 | 626 | |
| 618 | 627 | MSX_SLOT_MAP(ascii8_sram) |
| 619 | 628 | { |
| 629 | running_machine *machine = Machine; |
| 620 | 630 | switch (page) { |
| 621 | 631 | case 0: |
| 622 | | msx_cpu_setbank (1, msx1.empty); |
| 623 | | msx_cpu_setbank (2, msx1.empty); |
| 632 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 633 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 624 | 634 | break; |
| 625 | 635 | case 1: |
| 626 | | msx_cpu_setbank (3, ascii8_sram_bank_select (state, 0)); |
| 627 | | msx_cpu_setbank (4, ascii8_sram_bank_select (state, 1)); |
| 636 | msx_cpu_setbank (machine, 3, ascii8_sram_bank_select (state, 0)); |
| 637 | msx_cpu_setbank (machine, 4, ascii8_sram_bank_select (state, 1)); |
| 628 | 638 | break; |
| 629 | 639 | case 2: |
| 630 | | msx_cpu_setbank (5, ascii8_sram_bank_select (state, 2)); |
| 631 | | msx_cpu_setbank (6, ascii8_sram_bank_select (state, 3)); |
| 640 | msx_cpu_setbank (machine, 5, ascii8_sram_bank_select (state, 2)); |
| 641 | msx_cpu_setbank (machine, 6, ascii8_sram_bank_select (state, 3)); |
| 632 | 642 | break; |
| 633 | 643 | case 3: |
| 634 | | msx_cpu_setbank (7, msx1.empty); |
| 635 | | msx_cpu_setbank (8, msx1.empty); |
| 644 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 645 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 636 | 646 | } |
| 637 | 647 | } |
| 638 | 648 | |
| r2822 | r2823 | |
| 768 | 778 | |
| 769 | 779 | MSX_SLOT_MAP(ascii16_sram) |
| 770 | 780 | { |
| 781 | running_machine *machine = Machine; |
| 771 | 782 | UINT8 *mem; |
| 772 | 783 | |
| 773 | 784 | switch (page) { |
| 774 | 785 | case 0: |
| 775 | | msx_cpu_setbank (1, msx1.empty); |
| 776 | | msx_cpu_setbank (2, msx1.empty); |
| 786 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 787 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 777 | 788 | break; |
| 778 | 789 | case 1: |
| 779 | 790 | mem = ascii16_sram_bank_select (state, 0); |
| 780 | | msx_cpu_setbank (3, mem); |
| 781 | | msx_cpu_setbank (4, mem + 0x2000); |
| 791 | msx_cpu_setbank (machine, 3, mem); |
| 792 | msx_cpu_setbank (machine, 4, mem + 0x2000); |
| 782 | 793 | break; |
| 783 | 794 | case 2: |
| 784 | 795 | mem = ascii16_sram_bank_select (state, 1); |
| 785 | | msx_cpu_setbank (5, mem); |
| 786 | | msx_cpu_setbank (6, mem + 0x2000); |
| 796 | msx_cpu_setbank (machine, 5, mem); |
| 797 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 787 | 798 | break; |
| 788 | 799 | case 3: |
| 789 | | msx_cpu_setbank (7, msx1.empty); |
| 790 | | msx_cpu_setbank (8, msx1.empty); |
| 800 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 801 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 791 | 802 | } |
| 792 | 803 | } |
| 793 | 804 | |
| r2822 | r2823 | |
| 903 | 914 | |
| 904 | 915 | MSX_SLOT_MAP(rtype) |
| 905 | 916 | { |
| 917 | running_machine *machine = Machine; |
| 906 | 918 | UINT8 *mem; |
| 907 | 919 | |
| 908 | 920 | switch (page) { |
| 909 | 921 | case 0: |
| 910 | | msx_cpu_setbank (1, msx1.empty); |
| 911 | | msx_cpu_setbank (2, msx1.empty); |
| 922 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 923 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 912 | 924 | break; |
| 913 | 925 | case 1: |
| 914 | 926 | mem = state->mem + 15 * 0x4000; |
| 915 | | msx_cpu_setbank (3, mem); |
| 916 | | msx_cpu_setbank (4, mem + 0x2000); |
| 927 | msx_cpu_setbank (machine, 3, mem); |
| 928 | msx_cpu_setbank (machine, 4, mem + 0x2000); |
| 917 | 929 | break; |
| 918 | 930 | case 2: |
| 919 | 931 | mem = state->mem + state->banks[0] * 0x4000; |
| 920 | | msx_cpu_setbank (5, mem); |
| 921 | | msx_cpu_setbank (6, mem + 0x2000); |
| 932 | msx_cpu_setbank (machine, 5, mem); |
| 933 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 922 | 934 | break; |
| 923 | 935 | case 3: |
| 924 | | msx_cpu_setbank (7, msx1.empty); |
| 925 | | msx_cpu_setbank (8, msx1.empty); |
| 936 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 937 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 926 | 938 | } |
| 927 | 939 | } |
| 928 | 940 | |
| r2822 | r2823 | |
| 978 | 990 | |
| 979 | 991 | MSX_SLOT_MAP(gmaster2) |
| 980 | 992 | { |
| 993 | running_machine *machine = Machine; |
| 981 | 994 | switch (page) { |
| 982 | 995 | case 0: |
| 983 | 996 | case 1: |
| 984 | | msx_cpu_setbank (1 + page * 2, state->mem); /* bank 0 is hardwired */ |
| 997 | msx_cpu_setbank (machine, 1 + page * 2, state->mem); /* bank 0 is hardwired */ |
| 985 | 998 | if (state->banks[1] > 15) { |
| 986 | | msx_cpu_setbank (2 + page * 2, state->cart.sram.mem + |
| 999 | msx_cpu_setbank (machine, 2 + page * 2, state->cart.sram.mem + |
| 987 | 1000 | (state->banks[1] - 16) * 0x2000); |
| 988 | 1001 | } |
| 989 | 1002 | else { |
| 990 | | msx_cpu_setbank (2 + page * 2, state->mem + state->banks[1] * 0x2000); |
| 1003 | msx_cpu_setbank (machine, 2 + page * 2, state->mem + state->banks[1] * 0x2000); |
| 991 | 1004 | } |
| 992 | 1005 | break; |
| 993 | 1006 | case 2: |
| 994 | 1007 | case 3: |
| 995 | 1008 | if (state->banks[2] > 15) { |
| 996 | | msx_cpu_setbank (5 + page * 2, state->cart.sram.mem + |
| 1009 | msx_cpu_setbank (machine, 5 + page * 2, state->cart.sram.mem + |
| 997 | 1010 | (state->banks[2] - 16) * 0x2000); |
| 998 | 1011 | } |
| 999 | 1012 | else { |
| 1000 | | msx_cpu_setbank (5 + page * 2, state->mem + state->banks[2] * 0x2000); |
| 1013 | msx_cpu_setbank (machine, 5 + page * 2, state->mem + state->banks[2] * 0x2000); |
| 1001 | 1014 | } |
| 1002 | 1015 | if (state->banks[3] > 15) { |
| 1003 | | msx_cpu_setbank (6 + page * 2, state->cart.sram.mem + |
| 1016 | msx_cpu_setbank (machine, 6 + page * 2, state->cart.sram.mem + |
| 1004 | 1017 | (state->banks[3] - 16) * 0x2000); |
| 1005 | 1018 | } |
| 1006 | 1019 | else { |
| 1007 | | msx_cpu_setbank (6 + page * 2, state->mem + state->banks[3] * 0x2000); |
| 1020 | msx_cpu_setbank (machine, 6 + page * 2, state->mem + state->banks[3] * 0x2000); |
| 1008 | 1021 | } |
| 1009 | 1022 | break; |
| 1010 | 1023 | } |
| r2822 | r2823 | |
| 1130 | 1143 | |
| 1131 | 1144 | MSX_SLOT_RESET(diskrom) |
| 1132 | 1145 | { |
| 1133 | | wd17xx_reset (); |
| 1146 | wd17xx_reset (machine); |
| 1134 | 1147 | } |
| 1135 | 1148 | |
| 1136 | | static READ8_HANDLER (msx_diskrom_page1_r) |
| 1149 | static READ8_HANDLER (msx_diskrom_page1_r) |
| 1137 | 1150 | { |
| 1138 | 1151 | switch (offset) { |
| 1139 | 1152 | case 0: return wd17xx_status_r (machine, 0); |
| r2822 | r2823 | |
| 1146 | 1159 | } |
| 1147 | 1160 | } |
| 1148 | 1161 | |
| 1149 | | static READ8_HANDLER (msx_diskrom_page2_r) |
| 1162 | static READ8_HANDLER (msx_diskrom_page2_r) |
| 1150 | 1163 | { |
| 1151 | 1164 | if (offset >= 0x7f8) { |
| 1152 | 1165 | switch (offset) { |
| r2822 | r2823 | |
| 1171 | 1184 | |
| 1172 | 1185 | MSX_SLOT_MAP(diskrom) |
| 1173 | 1186 | { |
| 1187 | running_machine *machine = Machine; |
| 1174 | 1188 | switch (page) { |
| 1175 | 1189 | case 0: |
| 1176 | | msx_cpu_setbank (1, msx1.empty); |
| 1177 | | msx_cpu_setbank (2, msx1.empty); |
| 1190 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1191 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1178 | 1192 | break; |
| 1179 | 1193 | case 1: |
| 1180 | | msx_cpu_setbank (3, state->mem); |
| 1181 | | msx_cpu_setbank (4, state->mem + 0x2000); |
| 1182 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x7ff8, 0x7fff, 0, 0, msx_diskrom_page1_r); |
| 1194 | msx_cpu_setbank (machine, 3, state->mem); |
| 1195 | msx_cpu_setbank (machine, 4, state->mem + 0x2000); |
| 1196 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x7ff8, 0x7fff, 0, 0, msx_diskrom_page1_r); |
| 1183 | 1197 | break; |
| 1184 | 1198 | case 2: |
| 1185 | | msx_cpu_setbank (5, msx1.empty); |
| 1186 | | msx_cpu_setbank (6, msx1.empty); |
| 1187 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0xb800, 0xbfff, 0, 0, msx_diskrom_page2_r); |
| 1199 | msx_cpu_setbank (machine, 5, msx1.empty); |
| 1200 | msx_cpu_setbank (machine, 6, msx1.empty); |
| 1201 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0xb800, 0xbfff, 0, 0, msx_diskrom_page2_r); |
| 1188 | 1202 | break; |
| 1189 | 1203 | case 3: |
| 1190 | | msx_cpu_setbank (7, msx1.empty); |
| 1191 | | msx_cpu_setbank (8, msx1.empty); |
| 1204 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1205 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1192 | 1206 | break; |
| 1193 | 1207 | } |
| 1194 | 1208 | } |
| r2822 | r2823 | |
| 1243 | 1257 | |
| 1244 | 1258 | MSX_SLOT_RESET(diskrom2) |
| 1245 | 1259 | { |
| 1246 | | wd17xx_reset (); |
| 1260 | wd17xx_reset (machine); |
| 1247 | 1261 | } |
| 1248 | 1262 | |
| 1249 | 1263 | static READ8_HANDLER (msx_diskrom2_page1_r) |
| r2822 | r2823 | |
| 1284 | 1298 | |
| 1285 | 1299 | MSX_SLOT_MAP(diskrom2) |
| 1286 | 1300 | { |
| 1301 | running_machine *machine = Machine; |
| 1287 | 1302 | switch (page) { |
| 1288 | 1303 | case 0: |
| 1289 | | msx_cpu_setbank (1, msx1.empty); |
| 1290 | | msx_cpu_setbank (2, msx1.empty); |
| 1304 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1305 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1291 | 1306 | break; |
| 1292 | 1307 | case 1: |
| 1293 | | msx_cpu_setbank (3, state->mem); |
| 1294 | | msx_cpu_setbank (4, state->mem + 0x2000); |
| 1295 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x7fb8, 0x7fbc, 0, 0, msx_diskrom2_page1_r); |
| 1308 | msx_cpu_setbank (machine, 3, state->mem); |
| 1309 | msx_cpu_setbank (machine, 4, state->mem + 0x2000); |
| 1310 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x7fb8, 0x7fbc, 0, 0, msx_diskrom2_page1_r); |
| 1296 | 1311 | break; |
| 1297 | 1312 | case 2: |
| 1298 | | msx_cpu_setbank (5, msx1.empty); |
| 1299 | | msx_cpu_setbank (6, msx1.empty); |
| 1300 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0xb800, 0xbfbc, 0, 0, msx_diskrom2_page2_r); |
| 1313 | msx_cpu_setbank (machine, 5, msx1.empty); |
| 1314 | msx_cpu_setbank (machine, 6, msx1.empty); |
| 1315 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0xb800, 0xbfbc, 0, 0, msx_diskrom2_page2_r); |
| 1301 | 1316 | break; |
| 1302 | 1317 | case 3: |
| 1303 | | msx_cpu_setbank (7, msx1.empty); |
| 1304 | | msx_cpu_setbank (8, msx1.empty); |
| 1318 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1319 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1305 | 1320 | } |
| 1306 | 1321 | } |
| 1307 | 1322 | |
| r2822 | r2823 | |
| 1357 | 1372 | |
| 1358 | 1373 | MSX_SLOT_MAP(synthesizer) |
| 1359 | 1374 | { |
| 1375 | running_machine *machine = Machine; |
| 1360 | 1376 | switch (page) { |
| 1361 | 1377 | case 0: |
| 1362 | | msx_cpu_setbank (1, msx1.empty); |
| 1363 | | msx_cpu_setbank (2, msx1.empty); |
| 1378 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1379 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1364 | 1380 | break; |
| 1365 | 1381 | case 1: |
| 1366 | | msx_cpu_setbank (3, state->mem); |
| 1367 | | msx_cpu_setbank (4, state->mem + 0x2000); |
| 1382 | msx_cpu_setbank (machine, 3, state->mem); |
| 1383 | msx_cpu_setbank (machine, 4, state->mem + 0x2000); |
| 1368 | 1384 | break; |
| 1369 | 1385 | case 2: |
| 1370 | | msx_cpu_setbank (5, state->mem + 0x4000); |
| 1371 | | msx_cpu_setbank (6, state->mem + 0x6000); |
| 1386 | msx_cpu_setbank (machine, 5, state->mem + 0x4000); |
| 1387 | msx_cpu_setbank (machine, 6, state->mem + 0x6000); |
| 1372 | 1388 | break; |
| 1373 | 1389 | case 3: |
| 1374 | | msx_cpu_setbank (7, msx1.empty); |
| 1375 | | msx_cpu_setbank (8, msx1.empty); |
| 1390 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1391 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1376 | 1392 | } |
| 1377 | 1393 | } |
| 1378 | 1394 | |
| r2822 | r2823 | |
| 1408 | 1424 | |
| 1409 | 1425 | MSX_SLOT_MAP(majutsushi) |
| 1410 | 1426 | { |
| 1427 | running_machine *machine = Machine; |
| 1411 | 1428 | switch (page) { |
| 1412 | 1429 | case 0: |
| 1413 | | msx_cpu_setbank (1, state->mem + state->banks[0] * 0x2000); |
| 1414 | | msx_cpu_setbank (2, state->mem + state->banks[1] * 0x2000); |
| 1430 | msx_cpu_setbank (machine, 1, state->mem + state->banks[0] * 0x2000); |
| 1431 | msx_cpu_setbank (machine, 2, state->mem + state->banks[1] * 0x2000); |
| 1415 | 1432 | break; |
| 1416 | 1433 | case 1: |
| 1417 | | msx_cpu_setbank (3, state->mem + state->banks[0] * 0x2000); |
| 1418 | | msx_cpu_setbank (4, state->mem + state->banks[1] * 0x2000); |
| 1434 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x2000); |
| 1435 | msx_cpu_setbank (machine, 4, state->mem + state->banks[1] * 0x2000); |
| 1419 | 1436 | break; |
| 1420 | 1437 | case 2: |
| 1421 | | msx_cpu_setbank (5, state->mem + state->banks[2] * 0x2000); |
| 1422 | | msx_cpu_setbank (6, state->mem + state->banks[3] * 0x2000); |
| 1438 | msx_cpu_setbank (machine, 5, state->mem + state->banks[2] * 0x2000); |
| 1439 | msx_cpu_setbank (machine, 6, state->mem + state->banks[3] * 0x2000); |
| 1423 | 1440 | break; |
| 1424 | 1441 | case 3: |
| 1425 | | msx_cpu_setbank (5, state->mem + state->banks[2] * 0x2000); |
| 1426 | | msx_cpu_setbank (8, state->mem + state->banks[3] * 0x2000); |
| 1442 | msx_cpu_setbank (machine, 7, state->mem + state->banks[2] * 0x2000); |
| 1443 | msx_cpu_setbank (machine, 8, state->mem + state->banks[3] * 0x2000); |
| 1427 | 1444 | break; |
| 1428 | 1445 | } |
| 1429 | 1446 | } |
| r2822 | r2823 | |
| 1512 | 1529 | |
| 1513 | 1530 | MSX_SLOT_MAP(fmpac) |
| 1514 | 1531 | { |
| 1532 | running_machine *machine = Machine; |
| 1515 | 1533 | if (page == 1) { |
| 1516 | 1534 | if (state->cart.fmpac.sram_active) { |
| 1517 | | msx_cpu_setbank (3, state->cart.fmpac.mem); |
| 1518 | | msx_cpu_setbank (4, state->cart.fmpac.mem + 0x2000); |
| 1535 | msx_cpu_setbank (machine, 3, state->cart.fmpac.mem); |
| 1536 | msx_cpu_setbank (machine, 4, state->cart.fmpac.mem + 0x2000); |
| 1519 | 1537 | } |
| 1520 | 1538 | else { |
| 1521 | | msx_cpu_setbank (3, state->mem + state->banks[0] * 0x4000); |
| 1522 | | msx_cpu_setbank (4, state->mem + state->banks[0] * 0x4000 + 0x2000); |
| 1539 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x4000); |
| 1540 | msx_cpu_setbank (machine, 4, state->mem + state->banks[0] * 0x4000 + 0x2000); |
| 1523 | 1541 | } |
| 1524 | 1542 | } |
| 1525 | 1543 | else { |
| 1526 | | msx_cpu_setbank (page * 2 + 1, msx1.empty); |
| 1527 | | msx_cpu_setbank (page * 2 + 2, msx1.empty); |
| 1544 | msx_cpu_setbank (machine, page * 2 + 1, msx1.empty); |
| 1545 | msx_cpu_setbank (machine, page * 2 + 2, msx1.empty); |
| 1528 | 1546 | } |
| 1529 | 1547 | } |
| 1530 | 1548 | |
| r2822 | r2823 | |
| 1667 | 1685 | |
| 1668 | 1686 | MSX_SLOT_MAP(superloadrunner) |
| 1669 | 1687 | { |
| 1688 | running_machine *machine = Machine; |
| 1670 | 1689 | if (page == 2) { |
| 1671 | 1690 | UINT8 *mem = state->mem + |
| 1672 | 1691 | (msx1.superloadrunner_bank & state->bank_mask) * 0x4000; |
| 1673 | 1692 | |
| 1674 | | msx_cpu_setbank (5, mem); |
| 1675 | | msx_cpu_setbank (6, mem + 0x2000); |
| 1693 | msx_cpu_setbank (machine, 5, mem); |
| 1694 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 1676 | 1695 | } |
| 1677 | 1696 | else { |
| 1678 | | msx_cpu_setbank (page * 2 + 1, msx1.empty); |
| 1679 | | msx_cpu_setbank (page * 2 + 2, msx1.empty); |
| 1697 | msx_cpu_setbank (machine, page * 2 + 1, msx1.empty); |
| 1698 | msx_cpu_setbank (machine, page * 2 + 2, msx1.empty); |
| 1680 | 1699 | } |
| 1681 | 1700 | } |
| 1682 | 1701 | |
| r2822 | r2823 | |
| 1700 | 1719 | |
| 1701 | 1720 | MSX_SLOT_MAP(crossblaim) |
| 1702 | 1721 | { |
| 1722 | running_machine *machine = Machine; |
| 1703 | 1723 | UINT8 *mem; |
| 1704 | 1724 | |
| 1705 | 1725 | /* This might look odd, but it's what happens on the real cartridge */ |
| r2822 | r2823 | |
| 1708 | 1728 | case 0: |
| 1709 | 1729 | if (state->banks[0] < 2){ |
| 1710 | 1730 | mem = state->mem + state->banks[0] * 0x4000; |
| 1711 | | msx_cpu_setbank (1, mem); |
| 1712 | | msx_cpu_setbank (2, mem + 0x2000); |
| 1731 | msx_cpu_setbank (machine, 1, mem); |
| 1732 | msx_cpu_setbank (machine, 2, mem + 0x2000); |
| 1713 | 1733 | } else { |
| 1714 | | msx_cpu_setbank (1, msx1.empty); |
| 1715 | | msx_cpu_setbank (2, msx1.empty); |
| 1734 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1735 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1716 | 1736 | } |
| 1717 | 1737 | break; |
| 1718 | 1738 | case 1: |
| 1719 | | msx_cpu_setbank (3, state->mem); |
| 1720 | | msx_cpu_setbank (4, state->mem + 0x2000); |
| 1739 | msx_cpu_setbank (machine, 3, state->mem); |
| 1740 | msx_cpu_setbank (machine, 4, state->mem + 0x2000); |
| 1721 | 1741 | break; |
| 1722 | 1742 | case 2: |
| 1723 | 1743 | mem = state->mem + state->banks[0] * 0x4000; |
| 1724 | | msx_cpu_setbank (5, mem); |
| 1725 | | msx_cpu_setbank (6, mem + 0x2000); |
| 1744 | msx_cpu_setbank (machine, 5, mem); |
| 1745 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 1726 | 1746 | break; |
| 1727 | 1747 | case 3: |
| 1728 | 1748 | if (state->banks[0] < 2){ |
| 1729 | 1749 | mem = state->mem + state->banks[0] * 0x4000; |
| 1730 | | msx_cpu_setbank (7, mem); |
| 1731 | | msx_cpu_setbank (8, mem + 0x2000); |
| 1750 | msx_cpu_setbank (machine, 7, mem); |
| 1751 | msx_cpu_setbank (machine, 8, mem + 0x2000); |
| 1732 | 1752 | } else { |
| 1733 | | msx_cpu_setbank (7, msx1.empty); |
| 1734 | | msx_cpu_setbank (8, msx1.empty); |
| 1753 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1754 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1735 | 1755 | } |
| 1736 | 1756 | } |
| 1737 | 1757 | } |
| r2822 | r2823 | |
| 1786 | 1806 | |
| 1787 | 1807 | MSX_SLOT_MAP(korean80in1) |
| 1788 | 1808 | { |
| 1809 | running_machine *machine = Machine; |
| 1789 | 1810 | switch (page) { |
| 1790 | 1811 | case 0: |
| 1791 | | msx_cpu_setbank (1, msx1.empty); |
| 1792 | | msx_cpu_setbank (2, msx1.empty); |
| 1812 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1813 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1793 | 1814 | break; |
| 1794 | 1815 | case 1: |
| 1795 | | msx_cpu_setbank (3, state->mem + state->banks[0] * 0x2000); |
| 1796 | | msx_cpu_setbank (4, state->mem + state->banks[1] * 0x2000); |
| 1816 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x2000); |
| 1817 | msx_cpu_setbank (machine, 4, state->mem + state->banks[1] * 0x2000); |
| 1797 | 1818 | break; |
| 1798 | 1819 | case 2: |
| 1799 | | msx_cpu_setbank (5, state->mem + state->banks[2] * 0x2000); |
| 1800 | | msx_cpu_setbank (6, state->mem + state->banks[3] * 0x2000); |
| 1820 | msx_cpu_setbank (machine, 5, state->mem + state->banks[2] * 0x2000); |
| 1821 | msx_cpu_setbank (machine, 6, state->mem + state->banks[3] * 0x2000); |
| 1801 | 1822 | break; |
| 1802 | 1823 | case 3: |
| 1803 | | msx_cpu_setbank (7, msx1.empty); |
| 1804 | | msx_cpu_setbank (8, msx1.empty); |
| 1824 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1825 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1805 | 1826 | } |
| 1806 | 1827 | } |
| 1807 | 1828 | |
| r2822 | r2823 | |
| 1850 | 1871 | |
| 1851 | 1872 | MSX_SLOT_MAP(korean90in1) |
| 1852 | 1873 | { |
| 1874 | running_machine *machine = Machine; |
| 1853 | 1875 | UINT8 *mem; |
| 1854 | 1876 | UINT8 mask = (msx1.korean90in1_bank & 0xc0) == 0x80 ? 0x3e : 0x3f; |
| 1855 | 1877 | mem = state->mem + |
| r2822 | r2823 | |
| 1857 | 1879 | |
| 1858 | 1880 | switch (page) { |
| 1859 | 1881 | case 0: |
| 1860 | | msx_cpu_setbank (1, msx1.empty); |
| 1861 | | msx_cpu_setbank (2, msx1.empty); |
| 1882 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1883 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1862 | 1884 | break; |
| 1863 | 1885 | case 1: |
| 1864 | | msx_cpu_setbank (3, mem); |
| 1865 | | msx_cpu_setbank (4, mem + 0x2000); |
| 1886 | msx_cpu_setbank (machine, 3, mem); |
| 1887 | msx_cpu_setbank (machine, 4, mem + 0x2000); |
| 1866 | 1888 | break; |
| 1867 | 1889 | case 2: |
| 1868 | 1890 | switch (msx1.korean90in1_bank & 0xc0) { |
| 1869 | 1891 | case 0x80: /* 32 kb mode */ |
| 1870 | 1892 | mem += 0x4000; |
| 1871 | 1893 | default: /* ie. 0x00 and 0x40: same memory as page 1 */ |
| 1872 | | msx_cpu_setbank (5, mem); |
| 1873 | | msx_cpu_setbank (6, mem + 0x2000); |
| 1894 | msx_cpu_setbank (machine, 5, mem); |
| 1895 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 1874 | 1896 | break; |
| 1875 | 1897 | case 0xc0: /* same memory as page 1, but swap lower/upper 8kb */ |
| 1876 | | msx_cpu_setbank (5, mem + 0x2000); |
| 1877 | | msx_cpu_setbank (6, mem); |
| 1898 | msx_cpu_setbank (machine, 5, mem + 0x2000); |
| 1899 | msx_cpu_setbank (machine, 6, mem); |
| 1878 | 1900 | break; |
| 1879 | 1901 | } |
| 1880 | 1902 | break; |
| 1881 | 1903 | case 3: |
| 1882 | | msx_cpu_setbank (7, msx1.empty); |
| 1883 | | msx_cpu_setbank (8, msx1.empty); |
| 1904 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1905 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1884 | 1906 | } |
| 1885 | 1907 | } |
| 1886 | 1908 | |
| r2822 | r2823 | |
| 1915 | 1937 | |
| 1916 | 1938 | MSX_SLOT_MAP(korean126in1) |
| 1917 | 1939 | { |
| 1940 | running_machine *machine = Machine; |
| 1918 | 1941 | UINT8 *mem; |
| 1919 | 1942 | |
| 1920 | 1943 | switch (page) { |
| 1921 | 1944 | case 0: |
| 1922 | | msx_cpu_setbank (1, msx1.empty); |
| 1923 | | msx_cpu_setbank (2, msx1.empty); |
| 1945 | msx_cpu_setbank (machine, 1, msx1.empty); |
| 1946 | msx_cpu_setbank (machine, 2, msx1.empty); |
| 1924 | 1947 | break; |
| 1925 | 1948 | case 1: |
| 1926 | 1949 | mem = state->mem + state->banks[0] * 0x4000; |
| 1927 | | msx_cpu_setbank (3, mem); |
| 1928 | | msx_cpu_setbank (4, mem + 0x2000); |
| 1950 | msx_cpu_setbank (machine, 3, mem); |
| 1951 | msx_cpu_setbank (machine, 4, mem + 0x2000); |
| 1929 | 1952 | break; |
| 1930 | 1953 | case 2: |
| 1931 | 1954 | mem = state->mem + state->banks[1] * 0x4000; |
| 1932 | | msx_cpu_setbank (5, mem); |
| 1933 | | msx_cpu_setbank (6, mem + 0x2000); |
| 1955 | msx_cpu_setbank (machine, 5, mem); |
| 1956 | msx_cpu_setbank (machine, 6, mem + 0x2000); |
| 1934 | 1957 | break; |
| 1935 | 1958 | case 3: |
| 1936 | | msx_cpu_setbank (7, msx1.empty); |
| 1937 | | msx_cpu_setbank (8, msx1.empty); |
| 1959 | msx_cpu_setbank (machine, 7, msx1.empty); |
| 1960 | msx_cpu_setbank (machine, 8, msx1.empty); |
| 1938 | 1961 | } |
| 1939 | 1962 | } |
| 1940 | 1963 | |
| r2822 | r2823 | |
| 2037 | 2060 | |
| 2038 | 2061 | MSX_SLOT_MAP(soundcartridge) |
| 2039 | 2062 | { |
| 2063 | running_machine *machine = Machine; |
| 2040 | 2064 | switch (page) { |
| 2041 | 2065 | case 0: |
| 2042 | | msx_cpu_setbank (1, state->mem + state->banks[2] * 0x2000); |
| 2043 | | msx_cpu_setbank (2, state->mem + state->banks[3] * 0x2000); |
| 2066 | msx_cpu_setbank (machine, 1, state->mem + state->banks[2] * 0x2000); |
| 2067 | msx_cpu_setbank (machine, 2, state->mem + state->banks[3] * 0x2000); |
| 2044 | 2068 | break; |
| 2045 | 2069 | case 1: |
| 2046 | | msx_cpu_setbank (3, state->mem + state->banks[0] * 0x2000); |
| 2047 | | msx_cpu_setbank (4, state->mem + state->banks[1] * 0x2000); |
| 2070 | msx_cpu_setbank (machine, 3, state->mem + state->banks[0] * 0x2000); |
| 2071 | msx_cpu_setbank (machine, 4, state->mem + state->banks[1] * 0x2000); |
| 2048 | 2072 | break; |
| 2049 | 2073 | case 2: |
| 2050 | | msx_cpu_setbank (5, state->mem + state->banks[2] * 0x2000); |
| 2051 | | msx_cpu_setbank (6, state->mem + state->banks[3] * 0x2000); |
| 2052 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x9800, 0x9fff, 0, 0, |
| 2074 | msx_cpu_setbank (machine, 5, state->mem + state->banks[2] * 0x2000); |
| 2075 | msx_cpu_setbank (machine, 6, state->mem + state->banks[3] * 0x2000); |
| 2076 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x9800, 0x9fff, 0, 0, |
| 2053 | 2077 | state->cart.sccp.scc_active ? soundcartridge_scc : SMH_BANK7); |
| 2054 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0xb800, 0xbfff, 0, 0, |
| 2078 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0xb800, 0xbfff, 0, 0, |
| 2055 | 2079 | state->cart.sccp.sccp_active ? soundcartridge_sccp : SMH_BANK9); |
| 2056 | 2080 | break; |
| 2057 | 2081 | case 3: |
| 2058 | | msx_cpu_setbank (7, state->mem + state->banks[0] * 0x2000); |
| 2059 | | msx_cpu_setbank (8, state->mem + state->banks[1] * 0x2000); |
| 2082 | msx_cpu_setbank (machine, 7, state->mem + state->banks[0] * 0x2000); |
| 2083 | msx_cpu_setbank (machine, 8, state->mem + state->banks[1] * 0x2000); |
| 2060 | 2084 | break; |
| 2061 | 2085 | } |
| 2062 | 2086 | } |
src/mess/machine/thomson.c
| r2822 | r2823 | |
| 651 | 651 | |
| 652 | 652 | |
| 653 | 653 | |
| 654 | | static void to7_io_reset( void ) |
| 654 | static void to7_io_reset( running_machine *machine ) |
| 655 | 655 | { |
| 656 | 656 | LOG (( "to7_io_reset called\n" )); |
| 657 | 657 | thom_centronics_reset(); |
| r2822 | r2823 | |
| 835 | 835 | This is similar Atari & Amiga mouses. |
| 836 | 836 | Returns: 0 0 0 0 0 0 YB XB YA XA |
| 837 | 837 | */ |
| 838 | | static UINT8 to7_get_mouse_signal( void ) |
| 838 | static UINT8 to7_get_mouse_signal( running_machine *machine ) |
| 839 | 839 | { |
| 840 | 840 | UINT8 xa, xb, ya, yb; |
| 841 | | UINT16 dx = input_port_read(Machine, "mouse_x"); /* x axis */ |
| 842 | | UINT16 dy = input_port_read(Machine, "mouse_y"); /* y axis */ |
| 841 | UINT16 dx = input_port_read(machine, "mouse_x"); /* x axis */ |
| 842 | UINT16 dy = input_port_read(machine, "mouse_y"); /* y axis */ |
| 843 | 843 | xa = ((dx + 1) & 3) <= 1; |
| 844 | 844 | xb = (dx & 3) <= 1; |
| 845 | 845 | ya = ((dy + 1) & 3) <= 1; |
| r2822 | r2823 | |
| 862 | 862 | if ( input_port_read(machine, "config") & 1 ) |
| 863 | 863 | { |
| 864 | 864 | /* mouse */ |
| 865 | | data = to7_get_mouse_signal() & 0x0c; /* XB, YB */ |
| 865 | data = to7_get_mouse_signal(machine) & 0x0c; /* XB, YB */ |
| 866 | 866 | data |= input_port_read(machine, "mouse_button") & 3; /* buttons */ |
| 867 | 867 | } |
| 868 | 868 | else |
| r2822 | r2823 | |
| 903 | 903 | if ( input_port_read(machine, "config") & 1 ) |
| 904 | 904 | { |
| 905 | 905 | /* mouse */ |
| 906 | | UINT8 mouse = to7_get_mouse_signal(); |
| 906 | UINT8 mouse = to7_get_mouse_signal(machine); |
| 907 | 907 | data = 0; |
| 908 | 908 | if ( mouse & 1 ) |
| 909 | 909 | data |= 0x04; /* XA */ |
| r2822 | r2823 | |
| 957 | 957 | if ( input_port_read(machine, "config") & 1 ) |
| 958 | 958 | { |
| 959 | 959 | /* mouse */ |
| 960 | | UINT8 mouse = to7_get_mouse_signal(); |
| 960 | UINT8 mouse = to7_get_mouse_signal(machine); |
| 961 | 961 | pia_set_input_ca1( THOM_PIA_GAME, (mouse & 1) ? 1 : 0 ); /* XA */ |
| 962 | 962 | pia_set_input_ca2( THOM_PIA_GAME, (mouse & 2) ? 1 : 0 ); /* YA */ |
| 963 | 963 | } |
| r2822 | r2823 | |
| 1271 | 1271 | mc6846_reset(); |
| 1272 | 1272 | to7_game_reset(); |
| 1273 | 1273 | to7_floppy_reset(machine); |
| 1274 | | to7_io_reset(); |
| 1274 | to7_io_reset(machine); |
| 1275 | 1275 | to7_modem_reset(); |
| 1276 | 1276 | to7_midi_reset(); |
| 1277 | 1277 | to7_rf57932_reset(); |
| r2822 | r2823 | |
| 1521 | 1521 | mc6846_reset(); |
| 1522 | 1522 | to7_game_reset(); |
| 1523 | 1523 | to7_floppy_reset(machine); |
| 1524 | | to7_io_reset(); |
| 1524 | to7_io_reset(machine); |
| 1525 | 1525 | to7_modem_reset(); |
| 1526 | 1526 | to7_midi_reset(); |
| 1527 | 1527 | to7_rf57932_reset(); |
| r2822 | r2823 | |
| 1882 | 1882 | pia_set_port_a_z_mask( THOM_PIA_SYS, 0x5f ); |
| 1883 | 1883 | to7_game_reset(); |
| 1884 | 1884 | to7_floppy_reset(machine); |
| 1885 | | to7_io_reset(); |
| 1885 | to7_io_reset(machine); |
| 1886 | 1886 | to7_modem_reset(); |
| 1887 | 1887 | to7_midi_reset(); |
| 1888 | 1888 | to7_rf57932_reset(); |
| r2822 | r2823 | |
| 2332 | 2332 | |
| 2333 | 2333 | |
| 2334 | 2334 | /* quick keyboard scan */ |
| 2335 | | static int to9_kbd_ktest ( void ) |
| 2335 | static int to9_kbd_ktest ( running_machine *machine ) |
| 2336 | 2336 | { |
| 2337 | 2337 | int line, bit; |
| 2338 | 2338 | UINT8 port; |
| r2822 | r2823 | |
| 2341 | 2341 | for ( line = 0; line < 10; line++ ) |
| 2342 | 2342 | { |
| 2343 | 2343 | sprintf(tag, "keyboard_%d", line); |
| 2344 | | port = input_port_read(Machine, tag); |
| 2344 | port = input_port_read(machine, tag); |
| 2345 | 2345 | |
| 2346 | 2346 | if ( line == 7 || line == 9 ) |
| 2347 | 2347 | port |= 1; /* shift & control */ |
| r2822 | r2823 | |
| 2357 | 2357 | |
| 2358 | 2358 | |
| 2359 | 2359 | |
| 2360 | | static void to9_kbd_update_irq ( void ) |
| 2360 | static void to9_kbd_update_irq ( running_machine *machine ) |
| 2361 | 2361 | { |
| 2362 | 2362 | if ( (to9_kbd_intr & 4) && (to9_kbd_status & ACIA_6850_RDRF) ) |
| 2363 | 2363 | to9_kbd_status |= ACIA_6850_irq; /* byte received interrupt */ |
| r2822 | r2823 | |
| 2368 | 2368 | if ( (to9_kbd_intr & 3) == 1 && (to9_kbd_status & ACIA_6850_TDRE) ) |
| 2369 | 2369 | to9_kbd_status |= ACIA_6850_irq; /* ready to transmit interrupt */ |
| 2370 | 2370 | |
| 2371 | | thom_irq_3( Machine, to9_kbd_status & ACIA_6850_irq ); |
| 2371 | thom_irq_3( machine, to9_kbd_status & ACIA_6850_irq ); |
| 2372 | 2372 | } |
| 2373 | 2373 | |
| 2374 | 2374 | |
| r2822 | r2823 | |
| 2407 | 2407 | to9_kbd_status &= ~(ACIA_6850_OVRN | ACIA_6850_RDRF); |
| 2408 | 2408 | to9_kbd_overrun = 0; |
| 2409 | 2409 | LOG_KBD(( "$%04x %f to9_kbd_r: read data $%02X\n", activecpu_get_previouspc(), attotime_to_double(timer_get_time()), to9_kbd_in )); |
| 2410 | | to9_kbd_update_irq(); |
| 2410 | to9_kbd_update_irq(machine); |
| 2411 | 2411 | return to9_kbd_in; |
| 2412 | 2412 | |
| 2413 | 2413 | default: |
| r2822 | r2823 | |
| 2451 | 2451 | data, to9_kbd_parity, to9_kbd_intr >> 2, |
| 2452 | 2452 | (to9_kbd_intr & 3) ? 1 : 0 )); |
| 2453 | 2453 | } |
| 2454 | | to9_kbd_update_irq(); |
| 2454 | to9_kbd_update_irq(machine); |
| 2455 | 2455 | break; |
| 2456 | 2456 | |
| 2457 | 2457 | case 1: /* output data */ |
| 2458 | 2458 | to9_kbd_status &= ~(ACIA_6850_irq | ACIA_6850_TDRE); |
| 2459 | | to9_kbd_update_irq(); |
| 2459 | to9_kbd_update_irq(machine); |
| 2460 | 2460 | /* TODO: 1 ms delay here ? */ |
| 2461 | 2461 | to9_kbd_status |= ACIA_6850_TDRE; /* data transmit ready again */ |
| 2462 | | to9_kbd_update_irq(); |
| 2462 | to9_kbd_update_irq(machine); |
| 2463 | 2463 | |
| 2464 | 2464 | switch ( data ) |
| 2465 | 2465 | { |
| r2822 | r2823 | |
| 2500 | 2500 | note: parity is not used as a checksum but to actually transmit a 9-th bit |
| 2501 | 2501 | of information! |
| 2502 | 2502 | */ |
| 2503 | | static void to9_kbd_send ( UINT8 data, int parity ) |
| 2503 | static void to9_kbd_send ( running_machine *machine, UINT8 data, int parity ) |
| 2504 | 2504 | { |
| 2505 | 2505 | if ( to9_kbd_status & ACIA_6850_RDRF ) |
| 2506 | 2506 | { |
| r2822 | r2823 | |
| 2519 | 2519 | to9_kbd_status |= ACIA_6850_PE; /* parity error */ |
| 2520 | 2520 | LOG_KBD(( "%f to9_kbd_send: data=$%02X, parity=%i, status=$%02X\n", attotime_to_double(timer_get_time()), data, parity, to9_kbd_status )); |
| 2521 | 2521 | } |
| 2522 | | to9_kbd_update_irq(); |
| 2522 | to9_kbd_update_irq(machine); |
| 2523 | 2523 | } |
| 2524 | 2524 | |
| 2525 | 2525 | |
| r2822 | r2823 | |
| 2661 | 2661 | { |
| 2662 | 2662 | |
| 2663 | 2663 | case 0: /* key */ |
| 2664 | | to9_kbd_send( to9_kbd_get_key(), 0 ); |
| 2664 | to9_kbd_send( machine, to9_kbd_get_key(), 0 ); |
| 2665 | 2665 | break; |
| 2666 | 2666 | |
| 2667 | 2667 | case 1: /* x axis */ |
| 2668 | 2668 | { |
| 2669 | 2669 | int newx = input_port_read(machine, "mouse_x"); |
| 2670 | 2670 | UINT8 data = ( (newx - to9_mouse_x) & 0xf ) - 8; |
| 2671 | | to9_kbd_send( data, 1 ); |
| 2671 | to9_kbd_send( machine, data, 1 ); |
| 2672 | 2672 | to9_mouse_x = newx; |
| 2673 | 2673 | break; |
| 2674 | 2674 | } |
| r2822 | r2823 | |
| 2677 | 2677 | { |
| 2678 | 2678 | int newy = input_port_read(machine, "mouse_y"); |
| 2679 | 2679 | UINT8 data = ( (newy - to9_mouse_y) & 0xf ) - 8; |
| 2680 | | to9_kbd_send( data, 1 ); |
| 2680 | to9_kbd_send( machine, data, 1 ); |
| 2681 | 2681 | to9_mouse_y = newy; |
| 2682 | 2682 | break; |
| 2683 | 2683 | } |
| r2822 | r2823 | |
| 2688 | 2688 | UINT8 data = 0; |
| 2689 | 2689 | if ( b & 1 ) data |= 1; |
| 2690 | 2690 | if ( b & 2 ) data |= 4; |
| 2691 | | to9_kbd_send( data, 1 ); |
| 2691 | to9_kbd_send( machine, data, 1 ); |
| 2692 | 2692 | break; |
| 2693 | 2693 | } |
| 2694 | 2694 | |
| r2822 | r2823 | |
| 2702 | 2702 | int key = to9_kbd_get_key(); |
| 2703 | 2703 | /* keyboard mode: send a byte only if a key is down */ |
| 2704 | 2704 | if ( key ) |
| 2705 | | to9_kbd_send( key, 0 ); |
| 2705 | to9_kbd_send( machine, key, 0 ); |
| 2706 | 2706 | timer_adjust_oneshot(to9_kbd_timer, TO9_KBD_POLL_PERIOD, 0); |
| 2707 | 2707 | } |
| 2708 | 2708 | } |
| 2709 | 2709 | |
| 2710 | 2710 | |
| 2711 | 2711 | |
| 2712 | | static void to9_kbd_reset ( void ) |
| 2712 | static void to9_kbd_reset ( running_machine *machine ) |
| 2713 | 2713 | { |
| 2714 | 2714 | LOG(( "to9_kbd_reset called\n" )); |
| 2715 | 2715 | to9_kbd_overrun = 0; /* no byte lost */ |
| r2822 | r2823 | |
| 2722 | 2722 | thom_set_caps_led( ! to9_kbd_caps ); |
| 2723 | 2723 | to9_kbd_key_count = 0; |
| 2724 | 2724 | to9_kbd_last_key = 0xff; |
| 2725 | | to9_kbd_update_irq(); |
| 2725 | to9_kbd_update_irq(machine); |
| 2726 | 2726 | timer_adjust_oneshot(to9_kbd_timer, TO9_KBD_POLL_PERIOD, 0); |
| 2727 | 2727 | } |
| 2728 | 2728 | |
| r2822 | r2823 | |
| 2754 | 2754 | |
| 2755 | 2755 | |
| 2756 | 2756 | |
| 2757 | | static void to9_update_centronics ( void ) |
| 2757 | static void to9_update_centronics ( running_machine *machine ) |
| 2758 | 2758 | { |
| 2759 | 2759 | UINT8 a = pia_get_output_a( THOM_PIA_SYS ); |
| 2760 | 2760 | UINT8 b = pia_get_output_b( THOM_PIA_SYS ); |
| r2822 | r2823 | |
| 2771 | 2771 | |
| 2772 | 2772 | static READ8_HANDLER ( to9_sys_porta_in ) |
| 2773 | 2773 | { |
| 2774 | | UINT8 ktest = to9_kbd_ktest(); |
| 2774 | UINT8 ktest = to9_kbd_ktest(machine); |
| 2775 | 2775 | |
| 2776 | 2776 | LOG_KBD(( "to9_sys_porta_in: ktest=%i\n", ktest )); |
| 2777 | 2777 | |
| r2822 | r2823 | |
| 2782 | 2782 | |
| 2783 | 2783 | static WRITE8_HANDLER ( to9_sys_porta_out ) |
| 2784 | 2784 | { |
| 2785 | | to9_update_centronics(); /* bits 1-7: printer */ |
| 2785 | to9_update_centronics(machine); /* bits 1-7: printer */ |
| 2786 | 2786 | } |
| 2787 | 2787 | |
| 2788 | 2788 | |
| 2789 | 2789 | |
| 2790 | 2790 | static WRITE8_HANDLER ( to9_sys_portb_out ) |
| 2791 | 2791 | { |
| 2792 | | to9_update_centronics(); /* bits 0-1: printer */ |
| 2792 | to9_update_centronics(machine); /* bits 0-1: printer */ |
| 2793 | 2793 | to9_update_ram_bank(machine); |
| 2794 | 2794 | |
| 2795 | 2795 | if ( data & 4 ) /* bit 2: video overlay (TODO) */ |
| r2822 | r2823 | |
| 2848 | 2848 | mc6846_reset(); |
| 2849 | 2849 | to7_game_reset(); |
| 2850 | 2850 | to9_floppy_reset(machine); |
| 2851 | | to9_kbd_reset(); |
| 2851 | to9_kbd_reset(machine); |
| 2852 | 2852 | thom_centronics_reset(); |
| 2853 | 2853 | to7_modem_reset(); |
| 2854 | 2854 | to7_midi_reset(); |
| r2822 | r2823 | |
| 2975 | 2975 | |
| 2976 | 2976 | |
| 2977 | 2977 | /* quick keyboard scan */ |
| 2978 | | static int to8_kbd_ktest ( void ) |
| 2978 | static int to8_kbd_ktest ( running_machine *machine ) |
| 2979 | 2979 | { |
| 2980 | 2980 | int line, bit; |
| 2981 | 2981 | UINT8 port; |
| 2982 | 2982 | char tag[12]; |
| 2983 | 2983 | |
| 2984 | | if ( input_port_read(Machine, "config") & 2 ) |
| 2984 | if ( input_port_read(machine, "config") & 2 ) |
| 2985 | 2985 | return 0; /* disabled */ |
| 2986 | 2986 | |
| 2987 | 2987 | for ( line = 0; line < 10; line++ ) |
| 2988 | 2988 | { |
| 2989 | 2989 | sprintf(tag, "keyboard_%d", line); |
| 2990 | | port = input_port_read(Machine, tag); |
| 2990 | port = input_port_read(machine, tag); |
| 2991 | 2991 | |
| 2992 | 2992 | if ( line == 7 || line == 9 ) |
| 2993 | 2993 | port |= 1; /* shift & control */ |
| r2822 | r2823 | |
| 3005 | 3005 | |
| 3006 | 3006 | |
| 3007 | 3007 | /* keyboard scan & return keycode (or -1) */ |
| 3008 | | static int to8_kbd_get_key( void ) |
| 3008 | static int to8_kbd_get_key( running_machine *machine ) |
| 3009 | 3009 | { |
| 3010 | | int control = (input_port_read(Machine, "keyboard_7") & 1) ? 0 : 0x100; |
| 3011 | | int shift = (input_port_read(Machine, "keyboard_9") & 1) ? 0 : 0x080; |
| 3010 | int control = (input_port_read(machine, "keyboard_7") & 1) ? 0 : 0x100; |
| 3011 | int shift = (input_port_read(machine, "keyboard_9") & 1) ? 0 : 0x080; |
| 3012 | 3012 | int key = -1, line, bit; |
| 3013 | 3013 | UINT8 port; |
| 3014 | 3014 | char tag[12]; |
| 3015 | 3015 | |
| 3016 | | if ( input_port_read(Machine, "config") & 2 ) |
| 3016 | if ( input_port_read(machine, "config") & 2 ) |
| 3017 | 3017 | return -1; /* disabled */ |
| 3018 | 3018 | |
| 3019 | 3019 | for ( line = 0; line < 10; line++ ) |
| 3020 | 3020 | { |
| 3021 | 3021 | sprintf(tag, "keyboard_%d", line); |
| 3022 | | port = input_port_read(Machine, tag); |
| 3022 | port = input_port_read(machine, tag); |
| 3023 | 3023 | |
| 3024 | 3024 | if ( line == 7 || line == 9 ) |
| 3025 | 3025 | port |= 1; /* shift & control */ |
| r2822 | r2823 | |
| 3078 | 3078 | */ |
| 3079 | 3079 | |
| 3080 | 3080 | /* keyboard automaton */ |
| 3081 | | static void to8_kbd_timer_func(void) |
| 3081 | static void to8_kbd_timer_func(running_machine *machine) |
| 3082 | 3082 | { |
| 3083 | 3083 | attotime d; |
| 3084 | 3084 | |
| r2822 | r2823 | |
| 3087 | 3087 | if( ! to8_kbd_step ) |
| 3088 | 3088 | { |
| 3089 | 3089 | /* key polling */ |
| 3090 | | int k = to8_kbd_get_key(); |
| 3090 | int k = to8_kbd_get_key(machine); |
| 3091 | 3091 | /* if not in transfer, send pulse from time to time |
| 3092 | 3092 | (helps avoiding CPU lock) |
| 3093 | 3093 | */ |
| 3094 | 3094 | if ( ! to8_kbd_ack ) |
| 3095 | | mc6846_set_input_cp1( 0 ); |
| 3096 | | mc6846_set_input_cp1( 1 ); |
| 3095 | mc6846_set_input_cp1( machine, 0 ); |
| 3096 | mc6846_set_input_cp1( machine, 1 ); |
| 3097 | 3097 | |
| 3098 | 3098 | if ( k == -1 ) |
| 3099 | 3099 | d = TO8_KBD_POLL_PERIOD; |
| r2822 | r2823 | |
| 3112 | 3112 | to8_kbd_last_key = 0xff; |
| 3113 | 3113 | to8_kbd_key_count = 0; |
| 3114 | 3114 | to8_kbd_step = 0; |
| 3115 | | mc6846_set_input_cp1( 1 ); |
| 3115 | mc6846_set_input_cp1( machine, 1 ); |
| 3116 | 3116 | d = TO8_KBD_POLL_PERIOD; |
| 3117 | 3117 | } |
| 3118 | 3118 | else if ( to8_kbd_step == 1 ) |
| 3119 | 3119 | { |
| 3120 | 3120 | /* schedule timeout waiting for ack to go down */ |
| 3121 | | mc6846_set_input_cp1( 0 ); |
| 3121 | mc6846_set_input_cp1( machine, 0 ); |
| 3122 | 3122 | to8_kbd_step = 255; |
| 3123 | 3123 | d = TO8_KBD_TIMEOUT; |
| 3124 | 3124 | } |
| 3125 | 3125 | else if ( to8_kbd_step == 117 ) |
| 3126 | 3126 | { |
| 3127 | 3127 | /* schedule timeout waiting for ack to go up */ |
| 3128 | | mc6846_set_input_cp1( 0 ); |
| 3128 | mc6846_set_input_cp1( machine, 0 ); |
| 3129 | 3129 | to8_kbd_step = 255; |
| 3130 | 3130 | d = TO8_KBD_TIMEOUT; |
| 3131 | 3131 | } |
| 3132 | 3132 | else if ( to8_kbd_step & 1 ) |
| 3133 | 3133 | { |
| 3134 | 3134 | /* send silence between bits */ |
| 3135 | | mc6846_set_input_cp1( 0 ); |
| 3135 | mc6846_set_input_cp1( machine, 0 ); |
| 3136 | 3136 | d = ATTOTIME_IN_USEC( 100 ); |
| 3137 | 3137 | to8_kbd_step++; |
| 3138 | 3138 | } |
| r2822 | r2823 | |
| 3141 | 3141 | /* send bit */ |
| 3142 | 3142 | int bpos = 8 - ( (to8_kbd_step - 100) / 2); |
| 3143 | 3143 | int bit = (to8_kbd_data >> bpos) & 1; |
| 3144 | | mc6846_set_input_cp1( 1 ); |
| 3144 | mc6846_set_input_cp1( machine, 1 ); |
| 3145 | 3145 | d = ATTOTIME_IN_USEC( bit ? 56 : 38 ); |
| 3146 | 3146 | to8_kbd_step++; |
| 3147 | 3147 | } |
| r2822 | r2823 | |
| 3152 | 3152 | |
| 3153 | 3153 | static TIMER_CALLBACK(to8_kbd_timer_cb) |
| 3154 | 3154 | { |
| 3155 | | to8_kbd_timer_func(); |
| 3155 | to8_kbd_timer_func(machine); |
| 3156 | 3156 | } |
| 3157 | 3157 | |
| 3158 | 3158 | |
| r2822 | r2823 | |
| 3229 | 3229 | |
| 3230 | 3230 | |
| 3231 | 3231 | |
| 3232 | | static void to8_kbd_reset ( void ) |
| 3232 | static void to8_kbd_reset ( running_machine *machine ) |
| 3233 | 3233 | { |
| 3234 | 3234 | to8_kbd_last_key = 0xff; |
| 3235 | 3235 | to8_kbd_key_count = 0; |
| r2822 | r2823 | |
| 3238 | 3238 | to8_kbd_ack = 1; |
| 3239 | 3239 | to8_kbd_caps = 1; |
| 3240 | 3240 | thom_set_caps_led( ! to8_kbd_caps ); |
| 3241 | | to8_kbd_timer_func(); |
| 3241 | to8_kbd_timer_func(machine); |
| 3242 | 3242 | } |
| 3243 | 3243 | |
| 3244 | 3244 | |
| r2822 | r2823 | |
| 3699 | 3699 | |
| 3700 | 3700 | static READ8_HANDLER ( to8_sys_porta_in ) |
| 3701 | 3701 | { |
| 3702 | | int ktest = to8_kbd_ktest (); |
| 3702 | int ktest = to8_kbd_ktest (machine); |
| 3703 | 3703 | |
| 3704 | 3704 | LOG_KBD(( "$%04x %f: to8_sys_porta_in ktest=%i\n", activecpu_get_previouspc(), attotime_to_double(timer_get_time()), ktest )); |
| 3705 | 3705 | |
| r2822 | r2823 | |
| 3710 | 3710 | |
| 3711 | 3711 | static WRITE8_HANDLER ( to8_sys_portb_out ) |
| 3712 | 3712 | { |
| 3713 | | to9_update_centronics(); /* bits 0-1: printer */ |
| 3713 | to9_update_centronics(machine); /* bits 0-1: printer */ |
| 3714 | 3714 | to8_update_ram_bank(machine); |
| 3715 | 3715 | |
| 3716 | 3716 | if ( data & 4 ) /* bit 2: video overlay (TODO) */ |
| r2822 | r2823 | |
| 3808 | 3808 | mc6846_reset(); |
| 3809 | 3809 | to7_game_reset(); |
| 3810 | 3810 | to8_floppy_reset(machine); |
| 3811 | | to8_kbd_reset(); |
| 3811 | to8_kbd_reset(machine); |
| 3812 | 3812 | thom_centronics_reset(); |
| 3813 | 3813 | to7_modem_reset(); |
| 3814 | 3814 | to7_midi_reset(); |
| r2822 | r2823 | |
| 3975 | 3975 | mc6846_reset(); |
| 3976 | 3976 | to7_game_reset(); |
| 3977 | 3977 | to8_floppy_reset(machine); |
| 3978 | | to9_kbd_reset(); |
| 3978 | to9_kbd_reset(machine); |
| 3979 | 3979 | thom_centronics_reset(); |
| 3980 | 3980 | to7_modem_reset(); |
| 3981 | 3981 | to7_midi_reset(); |
| r2822 | r2823 | |
| 4273 | 4273 | /* unlike the TO8, CB1 & CB2 are not connected to buttons */ |
| 4274 | 4274 | if ( input_port_read(machine, "config") & 1 ) |
| 4275 | 4275 | { |
| 4276 | | UINT8 mouse = to7_get_mouse_signal(); |
| 4276 | UINT8 mouse = to7_get_mouse_signal(machine); |
| 4277 | 4277 | pia_set_input_ca1( THOM_PIA_GAME, mouse & 1 ); /* XA */ |
| 4278 | 4278 | pia_set_input_ca2( THOM_PIA_GAME, mouse & 2 ); /* YA */ |
| 4279 | 4279 | } |
src/mess/machine/corvushd.c
| r2822 | r2823 | |
| 64 | 64 | // |
| 65 | 65 | |
| 66 | 66 | #include "driver.h" |
| 67 | | #include "deprecat.h" |
| 68 | 67 | #include "devices/harddriv.h" |
| 69 | 68 | #include "includes/corvushd.h" |
| 70 | 69 | #include <ctype.h> |
| r2822 | r2823 | |
| 544 | 543 | // Returns: |
| 545 | 544 | // status: Command status |
| 546 | 545 | // |
| 547 | | static UINT8 corvus_write_sector(UINT8 drv, UINT32 sector, UINT8 *buffer, int len) { |
| 546 | static UINT8 corvus_write_sector(running_machine *machine, UINT8 drv, UINT32 sector, UINT8 *buffer, int len) { |
| 548 | 547 | |
| 549 | 548 | corvus_hdc_t |
| 550 | 549 | *c = &corvus_hdc; |
| r2822 | r2823 | |
| 555 | 554 | |
| 556 | 555 | LOG(("corvus_write_sector: Write Drive: %d, physical sector: 0x%5.5x\n", drv, sector)); |
| 557 | 556 | |
| 558 | | if(drv >= device_count(Machine, IO_HARDDISK)) { |
| 557 | if(drv >= device_count(machine, IO_HARDDISK)) { |
| 559 | 558 | logerror("corvus_write_sector: Attempt to write to non-existant drive: %d\n", drv); |
| 560 | 559 | return STAT_FATAL_ERR | STAT_DRIVE_NOT_ONLINE; |
| 561 | 560 | } |
| r2822 | r2823 | |
| 610 | 609 | // Returns: |
| 611 | 610 | // status: Corvus status |
| 612 | 611 | // |
| 613 | | static UINT8 corvus_write_logical_sector(dadr_t *dadr, UINT8 *buffer, int len) { |
| 612 | static UINT8 corvus_write_logical_sector(running_machine *machine, dadr_t *dadr, UINT8 *buffer, int len) { |
| 614 | 613 | |
| 615 | 614 | corvus_hdc_t |
| 616 | 615 | *c = &corvus_hdc; |
| r2822 | r2823 | |
| 637 | 636 | // |
| 638 | 637 | sector += (c->tracks_per_cylinder * c->sectors_per_track * 2) + (SPARE_TRACKS * c->sectors_per_track); |
| 639 | 638 | |
| 640 | | status = corvus_write_sector(drv, sector, buffer, len); |
| 639 | status = corvus_write_sector(machine, drv, sector, buffer, len); |
| 641 | 640 | |
| 642 | 641 | if(status != STAT_SUCCESS) |
| 643 | 642 | c->xmit_bytes = 1; |
| r2822 | r2823 | |
| 660 | 659 | // Returns: |
| 661 | 660 | // status: Corvus status |
| 662 | 661 | // |
| 663 | | static UINT8 corvus_read_sector(UINT8 drv, UINT32 sector, UINT8 *buffer, int len) { |
| 662 | static UINT8 corvus_read_sector(running_machine *machine, UINT8 drv, UINT32 sector, UINT8 *buffer, int len) { |
| 664 | 663 | |
| 665 | 664 | corvus_hdc_t |
| 666 | 665 | *c = &corvus_hdc; |
| r2822 | r2823 | |
| 671 | 670 | |
| 672 | 671 | LOG(("corvus_read_sector: Read Drive: %d, physical sector: 0x%5.5x\n", drv, sector)); |
| 673 | 672 | |
| 674 | | if(drv >= device_count(Machine, IO_HARDDISK)) { |
| 673 | if(drv >= device_count(machine, IO_HARDDISK)) { |
| 675 | 674 | logerror("corvus_read_sector: Attempt to read from non-existant drive: %d\n", drv); |
| 676 | 675 | return STAT_FATAL_ERR | STAT_DRIVE_NOT_ONLINE; |
| 677 | 676 | } |
| r2822 | r2823 | |
| 715 | 714 | // Returns: |
| 716 | 715 | // status: Corvus status |
| 717 | 716 | // |
| 718 | | static UINT8 corvus_read_logical_sector(dadr_t *dadr, UINT8 *buffer, int len) { |
| 717 | static UINT8 corvus_read_logical_sector(running_machine *machine, dadr_t *dadr, UINT8 *buffer, int len) { |
| 719 | 718 | |
| 720 | 719 | corvus_hdc_t |
| 721 | 720 | *c = &corvus_hdc; |
| r2822 | r2823 | |
| 742 | 741 | // |
| 743 | 742 | sector += (c->tracks_per_cylinder * c->sectors_per_track * 2) + (SPARE_TRACKS * c->sectors_per_track); |
| 744 | 743 | |
| 745 | | status = corvus_read_sector(drv, sector, buffer, len); |
| 744 | status = corvus_read_sector(machine, drv, sector, buffer, len); |
| 746 | 745 | |
| 747 | 746 | if(status != STAT_SUCCESS) |
| 748 | 747 | c->xmit_bytes = 1; |
| r2822 | r2823 | |
| 766 | 765 | // Side-effects: |
| 767 | 766 | // Fills in the semaphore result code |
| 768 | 767 | // |
| 769 | | static UINT8 corvus_lock_semaphore(UINT8 *name) { |
| 768 | static UINT8 corvus_lock_semaphore(running_machine *machine, UINT8 *name) { |
| 770 | 769 | |
| 771 | 770 | corvus_hdc_t |
| 772 | 771 | *c = &corvus_hdc; |
| r2822 | r2823 | |
| 780 | 779 | // |
| 781 | 780 | // Read the semaphore table from the drive |
| 782 | 781 | // |
| 783 | | status = corvus_read_sector(0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 782 | status = corvus_read_sector(machine, 0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 784 | 783 | if(status != STAT_SUCCESS) { |
| 785 | 784 | logerror("corvus_lock_semaphore: Error reading semaphore table, status: 0x%2.2x\n", status); |
| 786 | 785 | c->buffer.semaphore_locking_response.result = SEM_DISK_ERROR; |
| r2822 | r2823 | |
| 814 | 813 | } else { |
| 815 | 814 | c->buffer.semaphore_locking_response.result = SEM_PRIOR_STATE_NOT_SET; // It wasn't there already |
| 816 | 815 | memcpy(&semaphore_table.semaphore_block.semaphore_entry[blank_offset], name, 8);// Stick it into the table |
| 817 | | status = corvus_write_sector(0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 816 | status = corvus_write_sector(machine, 0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 818 | 817 | if(status != STAT_SUCCESS) { |
| 819 | 818 | logerror("corvus_lock_semaphore: Error updating semaphore table, status: 0x%2.2x\n", status); |
| 820 | 819 | c->buffer.semaphore_locking_response.result = SEM_DISK_ERROR; |
| r2822 | r2823 | |
| 844 | 843 | // Side-effects: |
| 845 | 844 | // Fills in the semaphore result code |
| 846 | 845 | // |
| 847 | | static UINT8 corvus_unlock_semaphore(UINT8 *name) { |
| 846 | static UINT8 corvus_unlock_semaphore(running_machine *machine, UINT8 *name) { |
| 848 | 847 | |
| 849 | 848 | corvus_hdc_t |
| 850 | 849 | *c = &corvus_hdc; |
| r2822 | r2823 | |
| 857 | 856 | // |
| 858 | 857 | // Read the semaphore table from the drive |
| 859 | 858 | // |
| 860 | | status = corvus_read_sector(0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 859 | status = corvus_read_sector(machine, 0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 861 | 860 | if(status != STAT_SUCCESS) { |
| 862 | 861 | logerror("corvus_unlock_semaphore: Error reading semaphore table, status: 0x%2.2x\n", status); |
| 863 | 862 | c->buffer.semaphore_locking_response.result = SEM_DISK_ERROR; |
| r2822 | r2823 | |
| 887 | 886 | } else { |
| 888 | 887 | c->buffer.semaphore_locking_response.result = SEM_PRIOR_STATE_SET; // It was there |
| 889 | 888 | memcpy(&semaphore_table.semaphore_block.semaphore_entry[offset], " ", 8); // Clear it |
| 890 | | status = corvus_write_sector(0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 889 | status = corvus_write_sector(machine, 0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 891 | 890 | if(status != STAT_SUCCESS) { |
| 892 | 891 | logerror("corvus_unlock_semaphore: Error updating semaphore table, status: 0x%2.2x\n", status); |
| 893 | 892 | c->buffer.semaphore_locking_response.result = SEM_DISK_ERROR; |
| r2822 | r2823 | |
| 912 | 911 | // Disk status |
| 913 | 912 | // |
| 914 | 913 | // |
| 915 | | static UINT8 corvus_init_semaphore_table( void ) { |
| 914 | static UINT8 corvus_init_semaphore_table( running_machine *machine ) { |
| 916 | 915 | |
| 917 | 916 | semaphore_table_block_t |
| 918 | 917 | semaphore_table; |
| r2822 | r2823 | |
| 920 | 919 | |
| 921 | 920 | memset(semaphore_table.semaphore_block.semaphore_table, 0x20, 256); |
| 922 | 921 | |
| 923 | | status = corvus_write_sector(0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 922 | status = corvus_write_sector(machine, 0, 7, semaphore_table.semaphore_block.semaphore_table, 256); |
| 924 | 923 | if(status != STAT_SUCCESS) { |
| 925 | 924 | logerror("corvus_init_semaphore_table: Error updating semaphore table, status: 0x%2.2x\n", status); |
| 926 | 925 | return status; |
| r2822 | r2823 | |
| 942 | 941 | // Returns: |
| 943 | 942 | // Status of command |
| 944 | 943 | // |
| 945 | | static UINT8 corvus_get_drive_parameters(UINT8 drv) { |
| 944 | static UINT8 corvus_get_drive_parameters(running_machine *machine, UINT8 drv) { |
| 946 | 945 | |
| 947 | 946 | corvus_hdc_t |
| 948 | 947 | *c = &corvus_hdc; |
| r2822 | r2823 | |
| 967 | 966 | // |
| 968 | 967 | drv -= 1; // Internally, drives start at 0 |
| 969 | 968 | |
| 970 | | if(drv >= device_count(Machine, IO_HARDDISK)) { |
| 969 | if(drv >= device_count(machine, IO_HARDDISK)) { |
| 971 | 970 | logerror("corvus_get_drive_parameters: Attempt to retrieve parameters from non-existant drive: %d\n", drv); |
| 972 | 971 | c->xmit_bytes = 1; |
| 973 | 972 | return STAT_FATAL_ERR | STAT_DRIVE_NOT_ONLINE; |
| r2822 | r2823 | |
| 976 | 975 | // |
| 977 | 976 | // Read the Disk Parameter Block (Sector 1) from the drive |
| 978 | 977 | // |
| 979 | | status = corvus_read_sector(drv, 1, raw_disk_parameter_block.buffer, 512); |
| 978 | status = corvus_read_sector(machine, drv, 1, raw_disk_parameter_block.buffer, 512); |
| 980 | 979 | if(status != STAT_SUCCESS) { |
| 981 | 980 | logerror("corvus_get_drive_parameters: Error status returned reading Disk Parameter Block -- status: 0x%2.2x\n", status); |
| 982 | 981 | c->xmit_bytes = 1; |
| r2822 | r2823 | |
| 986 | 985 | // |
| 987 | 986 | // Read the Constellation Parameter Block (Sector 3) from the drive |
| 988 | 987 | // |
| 989 | | status = corvus_read_sector(drv, 3, raw_constellation_parameter_block.buffer, 512); |
| 988 | status = corvus_read_sector(machine, drv, 3, raw_constellation_parameter_block.buffer, 512); |
| 990 | 989 | if(status != STAT_SUCCESS) { |
| 991 | 990 | logerror("corvus_get_drive_parameters: Error status returned reading Constellation Parameter Block -- status: 0x%2.2x\n", status); |
| 992 | 991 | c->xmit_bytes = 1; |
| r2822 | r2823 | |
| 1050 | 1049 | // Returns: |
| 1051 | 1050 | // status: Status of read operation |
| 1052 | 1051 | // |
| 1053 | | static UINT8 corvus_read_boot_block(UINT8 block) { |
| 1052 | static UINT8 corvus_read_boot_block(running_machine *machine, UINT8 block) { |
| 1054 | 1053 | |
| 1055 | 1054 | corvus_hdc_t *c = &corvus_hdc; // Pick up global controller structure |
| 1056 | 1055 | |
| 1057 | 1056 | LOG(("corvus_read_boot_block: Reading boot block: %d\n", block)); |
| 1058 | 1057 | |
| 1059 | | return corvus_read_sector(0, 25 + block, c->buffer.read_512_response.data, 512); |
| 1058 | return corvus_read_sector(machine, 0, 25 + block, c->buffer.read_512_response.data, 512); |
| 1060 | 1059 | |
| 1061 | 1060 | } |
| 1062 | 1061 | |
| r2822 | r2823 | |
| 1074 | 1073 | // Returns: |
| 1075 | 1074 | // Status of command |
| 1076 | 1075 | // |
| 1077 | | static UINT8 corvus_read_firmware_block(UINT8 head, UINT8 sector) { |
| 1076 | static UINT8 corvus_read_firmware_block(running_machine *machine, UINT8 head, UINT8 sector) { |
| 1078 | 1077 | |
| 1079 | 1078 | corvus_hdc_t |
| 1080 | 1079 | *c = &corvus_hdc; // Pick up global controller structure |
| r2822 | r2823 | |
| 1086 | 1085 | LOG(("corvus_read_firmware_block: Reading firmware head: 0x%2.2x, sector: 0x%2.2x, relative_sector: 0x%2.2x\n", |
| 1087 | 1086 | head, sector, relative_sector)); |
| 1088 | 1087 | |
| 1089 | | status = corvus_read_sector(0, relative_sector, c->buffer.read_512_response.data, 512); // TODO: Which drive should Prep Mode talk to ??? |
| 1088 | status = corvus_read_sector(machine, 0, relative_sector, c->buffer.read_512_response.data, 512); // TODO: Which drive should Prep Mode talk to ??? |
| 1090 | 1089 | return status; |
| 1091 | 1090 | } |
| 1092 | 1091 | |
| r2822 | r2823 | |
| 1105 | 1104 | // Returns: |
| 1106 | 1105 | // Status of command |
| 1107 | 1106 | // |
| 1108 | | static UINT8 corvus_write_firmware_block(UINT8 head, UINT8 sector, UINT8 *buffer) { |
| 1107 | static UINT8 corvus_write_firmware_block(running_machine *machine, UINT8 head, UINT8 sector, UINT8 *buffer) { |
| 1109 | 1108 | |
| 1110 | 1109 | corvus_hdc_t |
| 1111 | 1110 | *c = &corvus_hdc; // Pick up global controller structure |
| r2822 | r2823 | |
| 1117 | 1116 | LOG(("corvus_write_firmware_block: Writing firmware head: 0x%2.2x, sector: 0x%2.2x, relative_sector: 0x%2.2x\n", |
| 1118 | 1117 | head, sector, relative_sector)); |
| 1119 | 1118 | |
| 1120 | | status = corvus_write_sector(0, relative_sector, buffer, 512); // TODO: Which drive should Prep Mode talk to ??? |
| 1119 | status = corvus_write_sector(machine, 0, relative_sector, buffer, 512); // TODO: Which drive should Prep Mode talk to ??? |
| 1121 | 1120 | return status; |
| 1122 | 1121 | } |
| 1123 | 1122 | |
| r2822 | r2823 | |
| 1134 | 1133 | // Returns: |
| 1135 | 1134 | // Status of command |
| 1136 | 1135 | // |
| 1137 | | static UINT8 corvus_format_drive(UINT8 *pattern, UINT16 len) { |
| 1136 | static UINT8 corvus_format_drive(running_machine *machine, UINT8 *pattern, UINT16 len) { |
| 1138 | 1137 | |
| 1139 | 1138 | corvus_hdc_t |
| 1140 | 1139 | *c = &corvus_hdc; |
| r2822 | r2823 | |
| 1158 | 1157 | LOG_BUFFER(pattern, 512); |
| 1159 | 1158 | |
| 1160 | 1159 | for(sector = 0; sector <= max_sector; sector++) { |
| 1161 | | status = corvus_write_sector(0, sector, pattern, 512); |
| 1160 | status = corvus_write_sector(machine, 0, sector, pattern, 512); |
| 1162 | 1161 | if(status != STAT_SUCCESS) { |
| 1163 | 1162 | logerror("corvus_format_drive: Error while formatting drive in corvus_write_sector--sector: 0x%5.5x, status: 0x%x2.2x\n", |
| 1164 | 1163 | sector, status); |
| r2822 | r2823 | |
| 1206 | 1205 | // Returns: |
| 1207 | 1206 | // Nothing |
| 1208 | 1207 | // |
| 1209 | | static void corvus_process_command_packet(UINT8 invalid_command_flag) { |
| 1208 | static void corvus_process_command_packet(running_machine *machine, UINT8 invalid_command_flag) { |
| 1210 | 1209 | |
| 1211 | 1210 | corvus_hdc_t *c = &corvus_hdc; |
| 1212 | 1211 | |
| r2822 | r2823 | |
| 1224 | 1223 | // |
| 1225 | 1224 | case READ_CHUNK_128: |
| 1226 | 1225 | c->buffer.read_128_response.status = |
| 1227 | | corvus_read_logical_sector(&c->buffer.read_sector_command.dadr, c->buffer.read_128_response.data, 128); |
| 1226 | corvus_read_logical_sector(machine, &c->buffer.read_sector_command.dadr, c->buffer.read_128_response.data, 128); |
| 1228 | 1227 | break; |
| 1229 | 1228 | case READ_SECTOR_256: |
| 1230 | 1229 | case READ_CHUNK_256: |
| 1231 | 1230 | c->buffer.read_256_reponse.status = |
| 1232 | | corvus_read_logical_sector(&c->buffer.read_sector_command.dadr, c->buffer.read_256_reponse.data, 256); |
| 1231 | corvus_read_logical_sector(machine, &c->buffer.read_sector_command.dadr, c->buffer.read_256_reponse.data, 256); |
| 1233 | 1232 | break; |
| 1234 | 1233 | case READ_CHUNK_512: |
| 1235 | 1234 | c->buffer.read_512_response.status = |
| 1236 | | corvus_read_logical_sector(&c->buffer.read_sector_command.dadr, c->buffer.read_512_response.data, 512); |
| 1235 | corvus_read_logical_sector(machine, &c->buffer.read_sector_command.dadr, c->buffer.read_512_response.data, 512); |
| 1237 | 1236 | break; |
| 1238 | 1237 | case WRITE_CHUNK_128: |
| 1239 | 1238 | c->buffer.single_byte_response.status = |
| 1240 | | corvus_write_logical_sector(&c->buffer.write_128_command.dadr, c->buffer.write_128_command.data, 128); |
| 1239 | corvus_write_logical_sector(machine, &c->buffer.write_128_command.dadr, c->buffer.write_128_command.data, 128); |
| 1241 | 1240 | break; |
| 1242 | 1241 | case WRITE_SECTOR_256: |
| 1243 | 1242 | case WRITE_CHUNK_256: |
| 1244 | 1243 | c->buffer.single_byte_response.status = |
| 1245 | | corvus_write_logical_sector(&c->buffer.write_256_command.dadr, c->buffer.write_256_command.data, 256); |
| 1244 | corvus_write_logical_sector(machine, &c->buffer.write_256_command.dadr, c->buffer.write_256_command.data, 256); |
| 1246 | 1245 | break; |
| 1247 | 1246 | case WRITE_CHUNK_512: |
| 1248 | 1247 | c->buffer.single_byte_response.status = |
| 1249 | | corvus_write_logical_sector(&c->buffer.write_512_command.dadr, c->buffer.write_512_command.data, 512); |
| 1248 | corvus_write_logical_sector(machine, &c->buffer.write_512_command.dadr, c->buffer.write_512_command.data, 512); |
| 1250 | 1249 | break; |
| 1251 | 1250 | // |
| 1252 | 1251 | // Semaphore commands |
| r2822 | r2823 | |
| 1257 | 1256 | // case SEMAPHORE_STATUS_CODE: |
| 1258 | 1257 | switch(c->buffer.command.modifier) { |
| 1259 | 1258 | case SEMAPHORE_LOCK_MOD: |
| 1260 | | c->buffer.semaphore_locking_response.status = corvus_lock_semaphore(c->buffer.lock_semaphore_command.name); |
| 1259 | c->buffer.semaphore_locking_response.status = corvus_lock_semaphore(machine, c->buffer.lock_semaphore_command.name); |
| 1261 | 1260 | break; |
| 1262 | 1261 | case SEMAPHORE_UNLOCK_MOD: |
| 1263 | 1262 | c->buffer.semaphore_locking_response.status = |
| 1264 | | corvus_unlock_semaphore(c->buffer.unlock_semaphore_command.name); |
| 1263 | corvus_unlock_semaphore(machine, c->buffer.unlock_semaphore_command.name); |
| 1265 | 1264 | break; |
| 1266 | 1265 | case SEMAPHORE_INIT_MOD: |
| 1267 | | c->buffer.single_byte_response.status = corvus_init_semaphore_table(); |
| 1266 | c->buffer.single_byte_response.status = corvus_init_semaphore_table(machine); |
| 1268 | 1267 | break; |
| 1269 | 1268 | case SEMAPHORE_STATUS_MOD: |
| 1270 | 1269 | c->buffer.semaphore_status_response.status = |
| 1271 | | corvus_read_sector(0, 7, c->buffer.semaphore_status_response.table, 256); |
| 1270 | corvus_read_sector(machine, 0, 7, c->buffer.semaphore_status_response.table, 256); |
| 1272 | 1271 | break; |
| 1273 | 1272 | default: |
| 1274 | 1273 | invalid_command_flag = TRUE; |
| r2822 | r2823 | |
| 1279 | 1278 | // |
| 1280 | 1279 | case BOOT: |
| 1281 | 1280 | c->buffer.read_512_response.status = |
| 1282 | | corvus_read_boot_block(c->buffer.old_boot_command.boot_block); |
| 1281 | corvus_read_boot_block(machine, c->buffer.old_boot_command.boot_block); |
| 1283 | 1282 | break; |
| 1284 | 1283 | case GET_DRIVE_PARAMETERS: |
| 1285 | 1284 | c->buffer.drive_param_response.status = |
| 1286 | | corvus_get_drive_parameters(c->buffer.get_drive_parameters_command.drive); |
| 1285 | corvus_get_drive_parameters(machine, c->buffer.get_drive_parameters_command.drive); |
| 1287 | 1286 | break; |
| 1288 | 1287 | case PREP_MODE_SELECT: |
| 1289 | 1288 | c->prep_mode = TRUE; |
| r2822 | r2823 | |
| 1307 | 1306 | break; |
| 1308 | 1307 | case PREP_READ_FIRMWARE: |
| 1309 | 1308 | c->buffer.drive_param_response.status = |
| 1310 | | corvus_read_firmware_block((c->buffer.read_firmware_command.encoded_h_s & 0xe0) >> 5, |
| 1309 | corvus_read_firmware_block(machine, (c->buffer.read_firmware_command.encoded_h_s & 0xe0) >> 5, |
| 1311 | 1310 | c->buffer.read_firmware_command.encoded_h_s & 0x1f); |
| 1312 | 1311 | break; |
| 1313 | 1312 | case PREP_WRITE_FIRMWARE: |
| 1314 | 1313 | c->buffer.drive_param_response.status = |
| 1315 | | corvus_write_firmware_block((c->buffer.write_firmware_command.encoded_h_s & 0xe0) >> 5, |
| 1314 | corvus_write_firmware_block(machine, (c->buffer.write_firmware_command.encoded_h_s & 0xe0) >> 5, |
| 1316 | 1315 | c->buffer.write_firmware_command.encoded_h_s & 0x1f, c->buffer.write_firmware_command.data); |
| 1317 | 1316 | break; |
| 1318 | 1317 | case PREP_FORMAT_DRIVE: |
| 1319 | 1318 | c->buffer.drive_param_response.status = |
| 1320 | | corvus_format_drive(c->buffer.format_drive_revbh_command.pattern, c->offset - 512); |
| 1319 | corvus_format_drive(machine, c->buffer.format_drive_revbh_command.pattern, c->offset - 512); |
| 1321 | 1320 | break; |
| 1322 | 1321 | default: |
| 1323 | 1322 | c->xmit_bytes = 1; |
| r2822 | r2823 | |
| 1409 | 1408 | logerror("corvus_hdc_callback: Exceeded four-second timeout for data from host, resetting communications\n"); |
| 1410 | 1409 | } else { // if(c->recv_bytes == 0) This was a variable-size command |
| 1411 | 1410 | LOG(("corvus_hdc_callback: Executing variable-length command via four-second timeout\n")); |
| 1412 | | corvus_process_command_packet(0); // Process the command |
| 1411 | corvus_process_command_packet(machine, 0); // Process the command |
| 1413 | 1412 | } |
| 1414 | 1413 | break; |
| 1415 | 1414 | default: |
| r2822 | r2823 | |
| 1694 | 1693 | // to the user with us Ready for more data and in Host-to-Controller mode. |
| 1695 | 1694 | // |
| 1696 | 1695 | if(c->offset == c->recv_bytes) { // We've received enough data to process |
| 1697 | | corvus_process_command_packet(invalid_command_flag); |
| 1696 | corvus_process_command_packet(machine, invalid_command_flag); |
| 1698 | 1697 | } else { |
| 1699 | 1698 | // |
| 1700 | 1699 | // Reset the four-second timer since we received some data |
src/mess/machine/nec765.c
| r2822 | r2823 | |
| 21 | 21 | ***************************************************************************/ |
| 22 | 22 | |
| 23 | 23 | #include "driver.h" |
| 24 | | #include "deprecat.h" |
| 25 | 24 | #include "machine/nec765.h" |
| 26 | 25 | |
| 27 | 26 | |
| r2822 | r2823 | |
| 121 | 120 | } NEC765; |
| 122 | 121 | |
| 123 | 122 | //static void nec765_setup_data_request(unsigned char Data); |
| 124 | | static void nec765_setup_command(void); |
| 123 | static void nec765_setup_command(running_machine *machine); |
| 125 | 124 | static TIMER_CALLBACK(nec765_continue_command); |
| 126 | | static int nec765_sector_count_complete(void); |
| 127 | | static void nec765_increment_sector(void); |
| 128 | | static void nec765_update_state(void); |
| 125 | static int nec765_sector_count_complete(running_machine *machine); |
| 126 | static void nec765_increment_sector(running_machine *machine); |
| 127 | static void nec765_update_state(running_machine *machine); |
| 129 | 128 | static void nec765_set_dma_drq(int state); |
| 130 | 129 | static void nec765_set_int(int state); |
| 131 | 130 | |
| r2822 | r2823 | |
| 144 | 143 | |
| 145 | 144 | |
| 146 | 145 | |
| 147 | | static const device_config *current_image(void) |
| 146 | static const device_config *current_image(running_machine *machine) |
| 148 | 147 | { |
| 149 | 148 | const device_config *image = NULL; |
| 150 | 149 | |
| 151 | 150 | if (!nec765_iface.get_image) |
| 152 | 151 | { |
| 153 | | if (fdc.drive < device_count(Machine, IO_FLOPPY)) |
| 152 | if (fdc.drive < device_count(machine, IO_FLOPPY)) |
| 154 | 153 | image = image_from_devtype_and_index(IO_FLOPPY, fdc.drive); |
| 155 | 154 | } |
| 156 | 155 | else |
| r2822 | r2823 | |
| 205 | 204 | fdc.FDC_main &= ~0x080; |
| 206 | 205 | } |
| 207 | 206 | |
| 208 | | static void nec765_seek_complete(void) |
| 207 | static void nec765_seek_complete(running_machine *machine) |
| 209 | 208 | { |
| 210 | 209 | /* tested on Amstrad CPC */ |
| 211 | 210 | |
| r2822 | r2823 | |
| 260 | 259 | This indicates it is always ready!!!!! |
| 261 | 260 | */ |
| 262 | 261 | |
| 263 | | const device_config *img = current_image(); |
| 262 | const device_config *img = current_image(machine); |
| 264 | 263 | |
| 265 | 264 | if (!img) |
| 266 | 265 | return; |
| r2822 | r2823 | |
| 315 | 314 | static TIMER_CALLBACK(nec765_seek_timer_callback) |
| 316 | 315 | { |
| 317 | 316 | /* seek complete */ |
| 318 | | nec765_seek_complete(); |
| 317 | nec765_seek_complete(machine); |
| 319 | 318 | |
| 320 | 319 | timer_reset(fdc.seek_timer, attotime_never); |
| 321 | 320 | } |
| r2822 | r2823 | |
| 435 | 434 | timer_adjust_periodic(fdc.seek_timer, attotime_zero, 0, double_to_attotime(fdc.srt_in_ms*abs(signed_tracks)*0.001)); |
| 436 | 435 | } |
| 437 | 436 | |
| 438 | | static void nec765_seek_setup(int is_recalibrate) |
| 437 | static void nec765_seek_setup(running_machine *machine, int is_recalibrate) |
| 439 | 438 | { |
| 440 | 439 | const device_config *img; |
| 441 | 440 | int signed_tracks; |
| r2822 | r2823 | |
| 450 | 449 | |
| 451 | 450 | nec765_setup_drive_and_side(); |
| 452 | 451 | |
| 453 | | img = current_image(); |
| 452 | img = current_image(machine); |
| 454 | 453 | |
| 455 | 454 | fdc.FDC_main |= (1<<fdc.drive); |
| 456 | 455 | |
| r2822 | r2823 | |
| 468 | 467 | ) |
| 469 | 468 | { |
| 470 | 469 | /* seek completed */ |
| 471 | | nec765_seek_complete(); |
| 470 | nec765_seek_complete(machine); |
| 472 | 471 | } |
| 473 | 472 | else |
| 474 | 473 | { |
| r2822 | r2823 | |
| 501 | 500 | } |
| 502 | 501 | else |
| 503 | 502 | { |
| 504 | | nec765_seek_complete(); |
| 503 | nec765_seek_complete(machine); |
| 505 | 504 | } |
| 506 | 505 | } |
| 507 | 506 | } |
| r2822 | r2823 | |
| 518 | 517 | /* if no tracks to seek, or drive is not ready, seek is complete */ |
| 519 | 518 | if ((signed_tracks==0) || (!floppy_drive_get_flag_state(img, FLOPPY_DRIVE_READY))) |
| 520 | 519 | { |
| 521 | | nec765_seek_complete(); |
| 520 | nec765_seek_complete(machine); |
| 522 | 521 | } |
| 523 | 522 | else |
| 524 | 523 | { |
| r2822 | r2823 | |
| 677 | 676 | |
| 678 | 677 | |
| 679 | 678 | |
| 680 | | void nec765_init(const nec765_interface *iface, NEC765_VERSION version, NEC765_RDY_PIN rdy_pin) |
| 679 | void nec765_init(running_machine *machine, const nec765_interface *iface, NEC765_VERSION version, NEC765_RDY_PIN rdy_pin) |
| 681 | 680 | { |
| 682 | 681 | int i; |
| 683 | 682 | |
| r2822 | r2823 | |
| 695 | 694 | |
| 696 | 695 | fdc.nec765_flags &= NEC765_FDD_READY; |
| 697 | 696 | |
| 698 | | nec765_reset(0); |
| 697 | nec765_reset(machine, 0); |
| 699 | 698 | |
| 700 | | for (i = 0; i < device_count(Machine, IO_FLOPPY); i++) |
| 699 | for (i = 0; i < device_count(machine, IO_FLOPPY); i++) |
| 701 | 700 | floppy_drive_set_ready_state_change_callback(image_from_devtype_and_index(IO_FLOPPY, i), nec765_set_ready_change_callback); |
| 702 | 701 | } |
| 703 | 702 | |
| 704 | 703 | |
| 705 | 704 | /* terminal count input */ |
| 706 | | void nec765_set_tc_state(int state) |
| 705 | void nec765_set_tc_state(running_machine *machine, int state) |
| 707 | 706 | { |
| 708 | 707 | int old_state; |
| 709 | 708 | |
| r2822 | r2823 | |
| 738 | 737 | #ifdef NO_END_OF_CYLINDER |
| 739 | 738 | timer_adjust_oneshot(fdc.command_timer, attotime_zero, 0); |
| 740 | 739 | #else |
| 741 | | nec765_update_state(); |
| 740 | nec765_update_state(machine); |
| 742 | 741 | #endif |
| 743 | 742 | } |
| 744 | 743 | } |
| r2822 | r2823 | |
| 802 | 801 | - if the index is seen twice while it is searching for a sector, then the sector cannot be found |
| 803 | 802 | */ |
| 804 | 803 | |
| 805 | | static void nec765_get_next_id(chrn_id *id) |
| 804 | static void nec765_get_next_id(running_machine *machine, chrn_id *id) |
| 806 | 805 | { |
| 807 | | const device_config *img = current_image(); |
| 806 | const device_config *img = current_image(machine); |
| 808 | 807 | |
| 809 | 808 | /* get next id from disc */ |
| 810 | 809 | floppy_drive_get_next_id(img, fdc.side,id); |
| r2822 | r2823 | |
| 819 | 818 | } |
| 820 | 819 | } |
| 821 | 820 | |
| 822 | | static int nec765_get_matching_sector(void) |
| 821 | static int nec765_get_matching_sector(running_machine *machine) |
| 823 | 822 | { |
| 824 | | const device_config *img = current_image(); |
| 823 | const device_config *img = current_image(machine); |
| 825 | 824 | chrn_id id; |
| 826 | 825 | |
| 827 | 826 | /* number of times we have seen index hole */ |
| r2822 | r2823 | |
| 830 | 829 | /* get sector id's */ |
| 831 | 830 | do |
| 832 | 831 | { |
| 833 | | nec765_get_next_id(&id); |
| 832 | nec765_get_next_id(machine, &id); |
| 834 | 833 | |
| 835 | 834 | /* tested on Amstrad CPC - All bytes must match, otherwise |
| 836 | 835 | a NO DATA error is reported */ |
| r2822 | r2823 | |
| 930 | 929 | nec765_setup_result_phase(7); |
| 931 | 930 | } |
| 932 | 931 | |
| 933 | | static void nec765_read_data(void) |
| 932 | static void nec765_read_data(running_machine *machine) |
| 934 | 933 | { |
| 935 | | const device_config *img = current_image(); |
| 934 | const device_config *img = current_image(machine); |
| 936 | 935 | |
| 937 | 936 | if (!(floppy_drive_get_flag_state(img, FLOPPY_DRIVE_READY))) |
| 938 | 937 | { |
| r2822 | r2823 | |
| 963 | 962 | do |
| 964 | 963 | { |
| 965 | 964 | /* get matching sector */ |
| 966 | | if (nec765_get_matching_sector()) |
| 965 | if (nec765_get_matching_sector(machine)) |
| 967 | 966 | { |
| 968 | 967 | |
| 969 | 968 | /* skip it? */ |
| r2822 | r2823 | |
| 972 | 971 | /* yes */ |
| 973 | 972 | |
| 974 | 973 | /* check that we haven't finished reading all sectors */ |
| 975 | | if (nec765_sector_count_complete()) |
| 974 | if (nec765_sector_count_complete(machine)) |
| 976 | 975 | { |
| 977 | 976 | /* read complete */ |
| 978 | 977 | nec765_read_complete(); |
| r2822 | r2823 | |
| 982 | 981 | /* read not finished */ |
| 983 | 982 | |
| 984 | 983 | /* increment sector count */ |
| 985 | | nec765_increment_sector(); |
| 984 | nec765_increment_sector(machine); |
| 986 | 985 | } |
| 987 | 986 | else |
| 988 | 987 | { |
| r2822 | r2823 | |
| 1012 | 1011 | } |
| 1013 | 1012 | |
| 1014 | 1013 | |
| 1015 | | static void nec765_format_track(void) |
| 1014 | static void nec765_format_track(running_machine *machine) |
| 1016 | 1015 | { |
| 1017 | | const device_config *img = current_image(); |
| 1016 | const device_config *img = current_image(machine); |
| 1018 | 1017 | |
| 1019 | 1018 | /* write protected? */ |
| 1020 | 1019 | if (floppy_drive_get_flag_state(img, FLOPPY_DRIVE_DISK_WRITE_PROTECTED)) |
| r2822 | r2823 | |
| 1038 | 1037 | nec765_setup_execution_phase_write(&fdc.format_data[0], 4); |
| 1039 | 1038 | } |
| 1040 | 1039 | |
| 1041 | | static void nec765_read_a_track(void) |
| 1040 | static void nec765_read_a_track(running_machine *machine) |
| 1042 | 1041 | { |
| 1043 | 1042 | int data_size; |
| 1044 | 1043 | |
| r2822 | r2823 | |
| 1047 | 1046 | /* get next id */ |
| 1048 | 1047 | chrn_id id; |
| 1049 | 1048 | |
| 1050 | | nec765_get_next_id(&id); |
| 1049 | nec765_get_next_id(machine, &id); |
| 1051 | 1050 | |
| 1052 | 1051 | /* TO BE CONFIRMED! */ |
| 1053 | 1052 | /* check id from disc */ |
| r2822 | r2823 | |
| 1070 | 1069 | |
| 1071 | 1070 | data_size = nec765_n_to_bytes(id.N); |
| 1072 | 1071 | |
| 1073 | | floppy_drive_read_sector_data(current_image(), fdc.side, fdc.sector_id,nec765_data_buffer,data_size); |
| 1072 | floppy_drive_read_sector_data(current_image(machine), fdc.side, fdc.sector_id,nec765_data_buffer,data_size); |
| 1074 | 1073 | |
| 1075 | 1074 | nec765_setup_execution_phase_read(nec765_data_buffer, data_size); |
| 1076 | 1075 | } |
| 1077 | 1076 | |
| 1078 | | static int nec765_just_read_last_sector_on_track(void) |
| 1077 | static int nec765_just_read_last_sector_on_track(running_machine *machine) |
| 1079 | 1078 | { |
| 1080 | | if (floppy_drive_get_flag_state(current_image(), FLOPPY_DRIVE_INDEX)) |
| 1079 | if (floppy_drive_get_flag_state(current_image(machine), FLOPPY_DRIVE_INDEX)) |
| 1081 | 1080 | return 1; |
| 1082 | 1081 | return 0; |
| 1083 | 1082 | } |
| r2822 | r2823 | |
| 1120 | 1119 | } |
| 1121 | 1120 | |
| 1122 | 1121 | |
| 1123 | | static void nec765_write_data(void) |
| 1122 | static void nec765_write_data(running_machine *machine) |
| 1124 | 1123 | { |
| 1125 | | if (!(floppy_drive_get_flag_state(current_image(), FLOPPY_DRIVE_READY))) |
| 1124 | if (!(floppy_drive_get_flag_state(current_image(machine), FLOPPY_DRIVE_READY))) |
| 1126 | 1125 | { |
| 1127 | 1126 | fdc.nec765_status[0] = 0x0c0 | (1<<4) | fdc.drive | (fdc.side<<2); |
| 1128 | 1127 | fdc.nec765_status[1] = 0x00; |
| r2822 | r2823 | |
| 1140 | 1139 | } |
| 1141 | 1140 | |
| 1142 | 1141 | /* write protected? */ |
| 1143 | | if (floppy_drive_get_flag_state(current_image(), FLOPPY_DRIVE_DISK_WRITE_PROTECTED)) |
| 1142 | if (floppy_drive_get_flag_state(current_image(machine), FLOPPY_DRIVE_DISK_WRITE_PROTECTED)) |
| 1144 | 1143 | { |
| 1145 | 1144 | fdc.nec765_status[1] |= NEC765_ST1_NOT_WRITEABLE; |
| 1146 | 1145 | |
| r2822 | r2823 | |
| 1148 | 1147 | return; |
| 1149 | 1148 | } |
| 1150 | 1149 | |
| 1151 | | if (nec765_get_matching_sector()) |
| 1150 | if (nec765_get_matching_sector(machine)) |
| 1152 | 1151 | { |
| 1153 | 1152 | int data_size; |
| 1154 | 1153 | |
| r2822 | r2823 | |
| 1164 | 1163 | |
| 1165 | 1164 | |
| 1166 | 1165 | /* return true if we have read all sectors, false if not */ |
| 1167 | | static int nec765_sector_count_complete(void) |
| 1166 | static int nec765_sector_count_complete(running_machine *machine) |
| 1168 | 1167 | { |
| 1169 | 1168 | /* this is not correct?? */ |
| 1170 | 1169 | #if 1 |
| r2822 | r2823 | |
| 1193 | 1192 | */ |
| 1194 | 1193 | |
| 1195 | 1194 | /* if just read last sector and on side 1 - finish */ |
| 1196 | | if ((nec765_just_read_last_sector_on_track()) && |
| 1195 | if ((nec765_just_read_last_sector_on_track(machine)) && |
| 1197 | 1196 | (fdc.side==1)) |
| 1198 | 1197 | { |
| 1199 | 1198 | return 1; |
| r2822 | r2823 | |
| 1300 | 1299 | return 0; |
| 1301 | 1300 | } |
| 1302 | 1301 | |
| 1303 | | static void nec765_increment_sector(void) |
| 1302 | static void nec765_increment_sector(running_machine *machine) |
| 1304 | 1303 | { |
| 1305 | 1304 | /* multi-track? */ |
| 1306 | 1305 | if (fdc.nec765_command_bytes[0] & 0x080) |
| 1307 | 1306 | { |
| 1308 | 1307 | /* reached EOT? */ |
| 1309 | 1308 | /* if (fdc.nec765_command_bytes[4]==fdc.nec765_command_bytes[6])*/ |
| 1310 | | if (nec765_just_read_last_sector_on_track()) |
| 1309 | if (nec765_just_read_last_sector_on_track(machine)) |
| 1311 | 1310 | { |
| 1312 | 1311 | /* yes */ |
| 1313 | 1312 | |
| r2822 | r2823 | |
| 1409 | 1408 | } |
| 1410 | 1409 | else |
| 1411 | 1410 | { |
| 1412 | | nec765_read_a_track(); |
| 1411 | nec765_read_a_track(machine); |
| 1413 | 1412 | } |
| 1414 | 1413 | } |
| 1415 | 1414 | break; |
| r2822 | r2823 | |
| 1417 | 1416 | /* format track */ |
| 1418 | 1417 | case 0x0d: |
| 1419 | 1418 | { |
| 1420 | | floppy_drive_format_sector(current_image(), fdc.side, fdc.sector_counter, |
| 1419 | floppy_drive_format_sector(current_image(machine), fdc.side, fdc.sector_counter, |
| 1421 | 1420 | fdc.format_data[0], fdc.format_data[1], |
| 1422 | 1421 | fdc.format_data[2], fdc.format_data[3], |
| 1423 | 1422 | fdc.nec765_command_bytes[5]); |
| r2822 | r2823 | |
| 1439 | 1438 | } |
| 1440 | 1439 | else |
| 1441 | 1440 | { |
| 1442 | | nec765_format_track(); |
| 1441 | nec765_format_track(machine); |
| 1443 | 1442 | } |
| 1444 | 1443 | } |
| 1445 | 1444 | break; |
| r2822 | r2823 | |
| 1458 | 1457 | } |
| 1459 | 1458 | |
| 1460 | 1459 | /* write data to disc */ |
| 1461 | | floppy_drive_write_sector_data(current_image(), fdc.side, fdc.sector_id,nec765_data_buffer,nec765_n_to_bytes(fdc.nec765_command_bytes[5]),ddam); |
| 1460 | floppy_drive_write_sector_data(current_image(machine), fdc.side, fdc.sector_id,nec765_data_buffer,nec765_n_to_bytes(fdc.nec765_command_bytes[5]),ddam); |
| 1462 | 1461 | |
| 1463 | | if (nec765_sector_count_complete()) |
| 1462 | if (nec765_sector_count_complete(machine)) |
| 1464 | 1463 | { |
| 1465 | | nec765_increment_sector(); |
| 1464 | nec765_increment_sector(machine); |
| 1466 | 1465 | nec765_write_complete(); |
| 1467 | 1466 | } |
| 1468 | 1467 | else |
| 1469 | 1468 | { |
| 1470 | | nec765_increment_sector(); |
| 1471 | | nec765_write_data(); |
| 1469 | nec765_increment_sector(machine); |
| 1470 | nec765_write_data(machine); |
| 1472 | 1471 | } |
| 1473 | 1472 | } |
| 1474 | 1473 | break; |
| r2822 | r2823 | |
| 1481 | 1480 | /* read all sectors? */ |
| 1482 | 1481 | |
| 1483 | 1482 | /* sector id == EOT */ |
| 1484 | | if (nec765_sector_count_complete() || nec765_read_data_stop()) |
| 1483 | if (nec765_sector_count_complete(machine) || nec765_read_data_stop()) |
| 1485 | 1484 | { |
| 1486 | 1485 | nec765_read_complete(); |
| 1487 | 1486 | } |
| 1488 | 1487 | else |
| 1489 | 1488 | { |
| 1490 | | nec765_increment_sector(); |
| 1491 | | nec765_read_data(); |
| 1489 | nec765_increment_sector(machine); |
| 1490 | nec765_read_data(machine); |
| 1492 | 1491 | } |
| 1493 | 1492 | } |
| 1494 | 1493 | break; |
| r2822 | r2823 | |
| 1553 | 1552 | |
| 1554 | 1553 | |
| 1555 | 1554 | |
| 1556 | | void nec765_update_state(void) |
| 1555 | void nec765_update_state(running_machine *machine) |
| 1557 | 1556 | { |
| 1558 | 1557 | switch (fdc.nec765_phase) { |
| 1559 | 1558 | case NEC765_RESULT_PHASE: |
| r2822 | r2823 | |
| 1641 | 1640 | |
| 1642 | 1641 | if (fdc.nec765_transfer_bytes_remaining==0) |
| 1643 | 1642 | { |
| 1644 | | nec765_setup_command(); |
| 1643 | nec765_setup_command(machine); |
| 1645 | 1644 | } |
| 1646 | 1645 | else |
| 1647 | 1646 | { |
| r2822 | r2823 | |
| 1661 | 1660 | |
| 1662 | 1661 | if (fdc.nec765_transfer_bytes_remaining==0) |
| 1663 | 1662 | { |
| 1664 | | nec765_setup_command(); |
| 1663 | nec765_setup_command(machine); |
| 1665 | 1664 | } |
| 1666 | 1665 | else |
| 1667 | 1666 | { |
| r2822 | r2823 | |
| 1688 | 1687 | } |
| 1689 | 1688 | |
| 1690 | 1689 | |
| 1691 | | READ8_HANDLER(nec765_data_r) |
| 1690 | READ8_HANDLER(nec765_data_r) |
| 1692 | 1691 | { |
| 1693 | 1692 | if ((fdc.FDC_main & 0x0c0) == 0x0c0) |
| 1694 | 1693 | { |
| r2822 | r2823 | |
| 1705 | 1704 | nec765_clear_data_request(); |
| 1706 | 1705 | |
| 1707 | 1706 | /* update state */ |
| 1708 | | nec765_update_state(); |
| 1707 | nec765_update_state(machine); |
| 1709 | 1708 | } |
| 1710 | 1709 | |
| 1711 | 1710 | if (LOG_EXTRA) |
| r2822 | r2823 | |
| 1737 | 1736 | nec765_clear_data_request(); |
| 1738 | 1737 | |
| 1739 | 1738 | /* update state */ |
| 1740 | | nec765_update_state(); |
| 1739 | nec765_update_state(machine); |
| 1741 | 1740 | } |
| 1742 | 1741 | } |
| 1743 | 1742 | |
| r2822 | r2823 | |
| 1748 | 1747 | nec765_setup_result_phase(1); |
| 1749 | 1748 | } |
| 1750 | 1749 | |
| 1751 | | static void nec765_setup_command(void) |
| 1750 | static void nec765_setup_command(running_machine *machine) |
| 1752 | 1751 | { |
| 1753 | 1752 | static const char *const commands[] = |
| 1754 | 1753 | { |
| r2822 | r2823 | |
| 1775 | 1774 | "Lock" /* [14] */ |
| 1776 | 1775 | }; |
| 1777 | 1776 | |
| 1778 | | const device_config *img = current_image(); |
| 1777 | const device_config *img = current_image(machine); |
| 1779 | 1778 | const char *cmd = NULL; |
| 1780 | 1779 | chrn_id id; |
| 1781 | 1780 | |
| r2822 | r2823 | |
| 1837 | 1836 | break; |
| 1838 | 1837 | |
| 1839 | 1838 | case 0x07: /* recalibrate */ |
| 1840 | | nec765_seek_setup(1); |
| 1839 | nec765_seek_setup(machine, 1); |
| 1841 | 1840 | break; |
| 1842 | 1841 | |
| 1843 | 1842 | case 0x0f: /* seek */ |
| 1844 | | nec765_seek_setup(0); |
| 1843 | nec765_seek_setup(machine, 0); |
| 1845 | 1844 | break; |
| 1846 | 1845 | |
| 1847 | 1846 | case 0x0a: /* read id */ |
| r2822 | r2823 | |
| 1966 | 1965 | fdc.nec765_status[1] = 0; |
| 1967 | 1966 | fdc.nec765_status[2] = 0; |
| 1968 | 1967 | |
| 1969 | | nec765_read_data(); |
| 1968 | nec765_read_data(machine); |
| 1970 | 1969 | break; |
| 1971 | 1970 | |
| 1972 | 1971 | case 0x0c: |
| r2822 | r2823 | |
| 1978 | 1977 | fdc.nec765_status[2] = 0; |
| 1979 | 1978 | |
| 1980 | 1979 | /* .. for now */ |
| 1981 | | nec765_read_data(); |
| 1980 | nec765_read_data(machine); |
| 1982 | 1981 | break; |
| 1983 | 1982 | |
| 1984 | 1983 | case 0x09: |
| r2822 | r2823 | |
| 1990 | 1989 | fdc.nec765_status[2] = 0; |
| 1991 | 1990 | |
| 1992 | 1991 | /* ... for now */ |
| 1993 | | nec765_write_data(); |
| 1992 | nec765_write_data(machine); |
| 1994 | 1993 | break; |
| 1995 | 1994 | |
| 1996 | 1995 | case 0x02: |
| r2822 | r2823 | |
| 2013 | 2012 | |
| 2014 | 2013 | fdc.sector_counter = 0; |
| 2015 | 2014 | |
| 2016 | | nec765_read_a_track(); |
| 2015 | nec765_read_a_track(machine); |
| 2017 | 2016 | break; |
| 2018 | 2017 | |
| 2019 | 2018 | case 0x05: /* write data */ |
| r2822 | r2823 | |
| 2023 | 2022 | fdc.nec765_status[1] = 0; |
| 2024 | 2023 | fdc.nec765_status[2] = 0; |
| 2025 | 2024 | |
| 2026 | | nec765_write_data(); |
| 2025 | nec765_write_data(machine); |
| 2027 | 2026 | break; |
| 2028 | 2027 | |
| 2029 | 2028 | case 0x0d: /* format a track */ |
| r2822 | r2823 | |
| 2035 | 2034 | |
| 2036 | 2035 | fdc.sector_counter = 0; |
| 2037 | 2036 | |
| 2038 | | nec765_format_track(); |
| 2037 | nec765_format_track(machine); |
| 2039 | 2038 | break; |
| 2040 | 2039 | |
| 2041 | 2040 | default: /* invalid */ |
| r2822 | r2823 | |
| 2114 | 2113 | } |
| 2115 | 2114 | |
| 2116 | 2115 | |
| 2117 | | void nec765_reset(int offset) |
| 2116 | void nec765_reset(running_machine *machine, int offset) |
| 2118 | 2117 | { |
| 2119 | 2118 | /* nec765 in idle state - ready to accept commands */ |
| 2120 | 2119 | nec765_idle(); |
| r2822 | r2823 | |
| 2140 | 2139 | are checked or only the drive selected with the drive select bits?? */ |
| 2141 | 2140 | |
| 2142 | 2141 | a_drive_is_ready = 0; |
| 2143 | | for (i = 0; i < device_count(Machine, IO_FLOPPY); i++) |
| 2142 | for (i = 0; i < device_count(machine, IO_FLOPPY); i++) |
| 2144 | 2143 | { |
| 2145 | 2144 | if (image_exists(image_from_devtype_and_index(IO_FLOPPY, i))) |
| 2146 | 2145 | { |
| r2822 | r2823 | |
| 2159 | 2158 | } |
| 2160 | 2159 | } |
| 2161 | 2160 | |
| 2162 | | void nec765_set_reset_state(int state) |
| 2161 | void nec765_set_reset_state(running_machine *machine, int state) |
| 2163 | 2162 | { |
| 2164 | 2163 | int flags; |
| 2165 | 2164 | |
| r2822 | r2823 | |
| 2187 | 2186 | if ((fdc.nec765_flags & NEC765_RESET)==0) |
| 2188 | 2187 | { |
| 2189 | 2188 | /* reset nec */ |
| 2190 | | nec765_reset(0); |
| 2189 | nec765_reset(machine, 0); |
| 2191 | 2190 | } |
| 2192 | 2191 | } |
| 2193 | 2192 | } |