src/mess/machine/dgn_beta.c
| r2816 | r2817 | |
| 59 | 59 | #include <assert.h> |
| 60 | 60 | |
| 61 | 61 | #include "driver.h" |
| 62 | | #include "deprecat.h" |
| 63 | 62 | #include "debug/debugcon.h" |
| 64 | 63 | #include "cpu/m6809/m6809.h" |
| 65 | 64 | #include "machine/6821pia.h" |
| r2816 | r2817 | |
| 235 | 234 | // this should probably be considdered a hack ! |
| 236 | 235 | // |
| 237 | 236 | |
| 238 | | static void UpdateBanks(int first, int last) |
| 237 | static void UpdateBanks(running_machine *machine, int first, int last) |
| 239 | 238 | { |
| 240 | 239 | int Page; |
| 241 | 240 | UINT8 *readbank; |
| r2816 | r2817 | |
| 292 | 291 | |
| 293 | 292 | PageRegs[TaskReg][Page].memory=readbank; |
| 294 | 293 | memory_set_bankptr(Page+1,readbank); |
| 295 | | memory_install_write8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, bank_start, bank_end,0,0,writebank); |
| 296 | | memory_install_write8_handler(Machine, 1, ADDRESS_SPACE_PROGRAM, bank_start, bank_end,0,0,writebank); |
| 294 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, bank_start, bank_end,0,0,writebank); |
| 295 | memory_install_write8_handler(machine, 1, ADDRESS_SPACE_PROGRAM, bank_start, bank_end,0,0,writebank); |
| 297 | 296 | |
| 298 | 297 | LOG_BANK_UPDATE(("UpdateBanks:MapPage=$%02X readbank=$%X\n",MapPage,(int)(FPTR)readbank)); |
| 299 | 298 | LOG_BANK_UPDATE(("PageRegsSet Task=%X Page=%x\n",TaskReg,Page)); |
| r2816 | r2817 | |
| 304 | 303 | } |
| 305 | 304 | |
| 306 | 305 | // |
| 307 | | static void SetDefaultTask(void) |
| 306 | static void SetDefaultTask(running_machine *machine) |
| 308 | 307 | { |
| 309 | 308 | int Idx; |
| 310 | 309 | |
| r2816 | r2817 | |
| 334 | 333 | PageRegs[TaskReg][IOPage].value=IOPageValue; |
| 335 | 334 | PageRegs[TaskReg][IOPage+1].value=IOPageValue; |
| 336 | 335 | |
| 337 | | UpdateBanks(0,IOPage+1); |
| 336 | UpdateBanks(machine, 0,IOPage+1); |
| 338 | 337 | |
| 339 | 338 | /* Map video ram to base of area it can use, that way we can take the literal RA */ |
| 340 | 339 | /* from the 6845 without having to mask it ! */ |
| r2816 | r2817 | |
| 359 | 358 | |
| 360 | 359 | if (EnableMapRegs) |
| 361 | 360 | { |
| 362 | | UpdateBanks(offset,offset); |
| 361 | UpdateBanks(machine, offset,offset); |
| 363 | 362 | if (offset==15) |
| 364 | | UpdateBanks(offset+1,offset+1); |
| 363 | UpdateBanks(machine, offset+1,offset+1); |
| 365 | 364 | } |
| 366 | 365 | } |
| 367 | 366 | |
| r2816 | r2817 | |
| 807 | 806 | { |
| 808 | 807 | TaskReg=NoPagingTask; |
| 809 | 808 | } |
| 810 | | UpdateBanks(0,IOPage+1); |
| 809 | UpdateBanks(machine, 0,IOPage+1); |
| 811 | 810 | } |
| 812 | 811 | else |
| 813 | 812 | { |
| r2816 | r2817 | |
| 815 | 814 | if ((PIATaskReg!=OldTask) && (EnableMapRegs)) |
| 816 | 815 | { |
| 817 | 816 | TaskReg=PIATaskReg; |
| 818 | | UpdateBanks(0,IOPage+1); |
| 817 | UpdateBanks(machine, 0,IOPage+1); |
| 819 | 818 | } |
| 820 | 819 | } |
| 821 | 820 | LOG_TASK(("TaskReg=$%02X PIATaskReg=$%02X\n",TaskReg,PIATaskReg)); |
| r2816 | r2817 | |
| 1045 | 1044 | PIATaskReg=0; |
| 1046 | 1045 | EnableMapRegs=0; |
| 1047 | 1046 | memset(PageRegs,0,sizeof(PageRegs)); /* Reset page registers to 0 */ |
| 1048 | | SetDefaultTask(); |
| 1047 | SetDefaultTask(machine); |
| 1049 | 1048 | |
| 1050 | 1049 | pia_reset(); |
| 1051 | 1050 | |
src/mess/machine/b2m.c
| r2816 | r2817 | |
| 150 | 150 | } |
| 151 | 151 | static PIT8253_FREQUENCY_CHANGED(bm2_pit_clk) |
| 152 | 152 | { |
| 153 | | pit8253_set_clockin((device_config*)device_list_find_by_tag( Machine->config->devicelist, PIT8253, "pit8253"), 0, frequency); |
| 153 | pit8253_set_clockin((device_config*)device_list_find_by_tag( device->machine->config->devicelist, PIT8253, "pit8253"), 0, frequency); |
| 154 | 154 | } |
| 155 | 155 | |
| 156 | 156 | static PIT8253_OUTPUT_CHANGED(bm2_pit_irq) |
| 157 | 157 | { |
| 158 | | pic8259_set_irq_line((device_config*)device_list_find_by_tag( Machine->config->devicelist, PIC8259, "pic8259"),1,state); |
| 158 | pic8259_set_irq_line((device_config*)device_list_find_by_tag( device->machine->config->devicelist, PIC8259, "pic8259"),1,state); |
| 159 | 159 | } |
| 160 | 160 | |
| 161 | 161 | |
| r2816 | r2817 | |
| 320 | 320 | |
| 321 | 321 | static PIC8259_SET_INT_LINE( b2m_pic_set_int_line ) |
| 322 | 322 | { |
| 323 | | cpunum_set_input_line(Machine, 0, 0,interrupt ? HOLD_LINE : CLEAR_LINE); |
| 323 | cpunum_set_input_line(device->machine, 0, 0,interrupt ? HOLD_LINE : CLEAR_LINE); |
| 324 | 324 | } |
| 325 | 325 | UINT8 vblank_state = 0; |
| 326 | 326 | |
| r2816 | r2817 | |
| 380 | 380 | |
| 381 | 381 | IRQ_CALLBACK(b2m_irq_callback) |
| 382 | 382 | { |
| 383 | | return pic8259_acknowledge((device_config*)device_list_find_by_tag( Machine->config->devicelist, PIC8259, "pic8259")); |
| 383 | return pic8259_acknowledge((device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259")); |
| 384 | 384 | } |
| 385 | 385 | |
| 386 | 386 | |
| r2816 | r2817 | |
| 392 | 392 | { |
| 393 | 393 | //vblank_state++; |
| 394 | 394 | //if (vblank_state>1) vblank_state=0; |
| 395 | | //pic8259_set_irq_line((device_config*)device_list_find_by_tag( Machine->config->devicelist, PIC8259, "pic8259"),0,vblank_state); |
| 395 | //pic8259_set_irq_line((device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259"),0,vblank_state); |
| 396 | 396 | } |
| 397 | 397 | static TIMER_CALLBACK (b2m_callback) |
| 398 | 398 | { |
| 399 | 399 | vblank_state++; |
| 400 | 400 | if (vblank_state>1) vblank_state=0; |
| 401 | | pic8259_set_irq_line((device_config*)device_list_find_by_tag( Machine->config->devicelist, PIC8259, "pic8259"),0,vblank_state); |
| 401 | pic8259_set_irq_line((device_config*)device_list_find_by_tag( machine->config->devicelist, PIC8259, "pic8259"),0,vblank_state); |
| 402 | 402 | } |
| 403 | 403 | |
| 404 | 404 | MACHINE_RESET(b2m) |
src/mess/machine/spectrum.c
| r2816 | r2817 | |
| 24 | 24 | ***************************************************************************/ |
| 25 | 25 | |
| 26 | 26 | #include "driver.h" |
| 27 | | #include "deprecat.h" |
| 28 | 27 | #include "cpu/z80/z80.h" |
| 29 | 28 | #include "includes/spectrum.h" |
| 30 | 29 | #include "eventlst.h" |
| r2816 | r2817 | |
| 126 | 125 | * value for the ROM paging. |
| 127 | 126 | * |
| 128 | 127 | *******************************************************************/ |
| 129 | | static void spectrum_update_paging(void) |
| 128 | static void spectrum_update_paging(running_machine *machine) |
| 130 | 129 | { |
| 131 | 130 | if (spectrum_128_port_7ffd_data == -1) |
| 132 | 131 | return; |
| 133 | 132 | if (spectrum_plus3_port_1ffd_data == -1) |
| 134 | | spectrum_128_update_memory(Machine); |
| 133 | spectrum_128_update_memory(machine); |
| 135 | 134 | |
| 136 | 135 | else |
| 137 | 136 | { |
| r2816 | r2817 | |
| 140 | 139 | spectrum_plus3_port_1ffd_data = 0x04; |
| 141 | 140 | else |
| 142 | 141 | spectrum_plus3_port_1ffd_data = 0; |
| 143 | | spectrum_plus3_update_memory(Machine); |
| 142 | spectrum_plus3_update_memory(machine); |
| 144 | 143 | } |
| 145 | 144 | } |
| 146 | 145 | |
| 147 | 146 | /* Page in the 48K Basic ROM. Used when running 48K snapshots on a 128K machine. */ |
| 148 | | static void spectrum_page_basicrom(void) |
| 147 | static void spectrum_page_basicrom(running_machine *machine) |
| 149 | 148 | { |
| 150 | 149 | if (spectrum_128_port_7ffd_data == -1) |
| 151 | 150 | return; |
| 152 | 151 | spectrum_128_port_7ffd_data |= 0x10; |
| 153 | | spectrum_update_paging(); |
| 152 | spectrum_update_paging(machine); |
| 154 | 153 | } |
| 155 | 154 | |
| 156 | 155 | /******************************************************************* |
| r2816 | r2817 | |
| 286 | 285 | cpunum_set_input_line(machine, 0, INPUT_LINE_NMI, data); |
| 287 | 286 | cpunum_set_input_line(machine, 0, INPUT_LINE_HALT, 0); |
| 288 | 287 | |
| 289 | | spectrum_page_basicrom(); |
| 288 | spectrum_page_basicrom(machine); |
| 290 | 289 | |
| 291 | 290 | /* memory dump */ |
| 292 | 291 | for (i = 0; i < size; i++) |
| r2816 | r2817 | |
| 333 | 332 | |
| 334 | 333 | if ((SnapshotSize != 49179) && (spectrum_128_port_7ffd_data == -1)) |
| 335 | 334 | { |
| 336 | | logerror("Can't load 128K .SNA file into 48K Machine\n"); |
| 335 | logerror("Can't load 128K .SNA file into 48K machine\n"); |
| 337 | 336 | return; |
| 338 | 337 | } |
| 339 | 338 | |
| r2816 | r2817 | |
| 391 | 390 | |
| 392 | 391 | if (SnapshotSize == 49179) |
| 393 | 392 | /* 48K Snapshot */ |
| 394 | | spectrum_page_basicrom(); |
| 393 | spectrum_page_basicrom(machine); |
| 395 | 394 | else |
| 396 | 395 | { |
| 397 | 396 | /* 128K Snapshot */ |
| 398 | 397 | spectrum_128_port_7ffd_data = (pSnapshot[49181] & 0x0ff); |
| 399 | | spectrum_update_paging(); |
| 398 | spectrum_update_paging(machine); |
| 400 | 399 | } |
| 401 | 400 | |
| 402 | 401 | /* memory dump */ |
| r2816 | r2817 | |
| 437 | 436 | logerror("Loading bank %d from offset %ld\n", i, bank_offset); |
| 438 | 437 | spectrum_128_port_7ffd_data &= 0xf8; |
| 439 | 438 | spectrum_128_port_7ffd_data += i; |
| 440 | | spectrum_update_paging(); |
| 439 | spectrum_update_paging(machine); |
| 441 | 440 | for (j = 0; j < 16384; j++) |
| 442 | 441 | program_write_byte(j + 49152, pSnapshot[bank_offset + j]); |
| 443 | 442 | bank_offset += 16384; |
| r2816 | r2817 | |
| 446 | 445 | |
| 447 | 446 | /* Reset paging */ |
| 448 | 447 | spectrum_128_port_7ffd_data = (pSnapshot[49181] & 0x0ff); |
| 449 | | spectrum_update_paging(); |
| 448 | spectrum_update_paging(machine); |
| 450 | 449 | |
| 451 | 450 | /* program counter */ |
| 452 | 451 | lo = pSnapshot[49179] & 0x0ff; |
| r2816 | r2817 | |
| 717 | 716 | hi = pSnapshot[7] & 0x0ff; |
| 718 | 717 | cpunum_set_reg(0, Z80_PC, (hi << 8) | lo); |
| 719 | 718 | |
| 720 | | spectrum_page_basicrom(); |
| 719 | spectrum_page_basicrom(machine); |
| 721 | 720 | |
| 722 | 721 | if ((pSnapshot[12] & 0x020) == 0) |
| 723 | 722 | { |
| r2816 | r2817 | |
| 757 | 756 | |
| 758 | 757 | if (z80_type == SPECTRUM_Z80_SNAPSHOT_48K) |
| 759 | 758 | /* Ensure 48K Basic ROM is used */ |
| 760 | | spectrum_page_basicrom(); |
| 759 | spectrum_page_basicrom(machine); |
| 761 | 760 | |
| 762 | 761 | do |
| 763 | 762 | { |
| r2816 | r2817 | |
| 785 | 784 | { |
| 786 | 785 | /* Page the appropriate bank into 0xc000 - 0xfff */ |
| 787 | 786 | spectrum_128_port_7ffd_data = page - 3; |
| 788 | | spectrum_update_paging(); |
| 787 | spectrum_update_paging(machine); |
| 789 | 788 | Dest = 0x0c000; |
| 790 | 789 | } |
| 791 | 790 | else |
| r2816 | r2817 | |
| 822 | 821 | { |
| 823 | 822 | /* Set up paging */ |
| 824 | 823 | spectrum_128_port_7ffd_data = (pSnapshot[35] & 0x0ff); |
| 825 | | spectrum_update_paging(); |
| 824 | spectrum_update_paging(machine); |
| 826 | 825 | } |
| 827 | 826 | if ((z80_type == SPECTRUM_Z80_SNAPSHOT_48K) && !strcmp(machine->gamedrv->name,"ts2068")) |
| 828 | 827 | { |
| 829 | 828 | ts2068_port_f4_data = 0x03; |
| 830 | 829 | ts2068_port_ff_data = 0x00; |
| 831 | | ts2068_update_memory(Machine); |
| 830 | ts2068_update_memory(machine); |
| 832 | 831 | } |
| 833 | 832 | if (z80_type == SPECTRUM_Z80_SNAPSHOT_TS2068 && !strcmp(machine->gamedrv->name,"ts2068")) |
| 834 | 833 | { |
| 835 | 834 | ts2068_port_f4_data = pSnapshot[35]; |
| 836 | 835 | ts2068_port_ff_data = pSnapshot[36]; |
| 837 | | ts2068_update_memory(Machine); |
| 836 | ts2068_update_memory(machine); |
| 838 | 837 | } |
| 839 | 838 | } |
| 840 | 839 | } |
src/mess/machine/c128.c
| r2816 | r2817 | |
| 10 | 10 | ***************************************************************************/ |
| 11 | 11 | |
| 12 | 12 | #include "driver.h" |
| 13 | | #include "deprecat.h" |
| 14 | 13 | |
| 15 | 14 | #include "cpu/m6502/m6502.h" |
| 16 | 15 | #include "sound/sid6581.h" |
| r2816 | r2817 | |
| 145 | 144 | return c64_colorram[offset & 0x3ff]; |
| 146 | 145 | else if (offset == 0xc00) |
| 147 | 146 | { |
| 148 | | cia_set_port_mask_value(0, 0, input_port_read(Machine, "DSW0") & 0x0100 ? c64_keyline[8] : c64_keyline[9] ); |
| 147 | cia_set_port_mask_value(0, 0, input_port_read(machine, "DSW0") & 0x0100 ? c64_keyline[8] : c64_keyline[9] ); |
| 149 | 148 | return cia_0_r(machine, offset); |
| 150 | 149 | } |
| 151 | 150 | else if (offset == 0xc01) |
| 152 | 151 | { |
| 153 | | cia_set_port_mask_value(0, 1, input_port_read(Machine, "DSW0") & 0x0100 ? c64_keyline[9] : c64_keyline[8] ); |
| 152 | cia_set_port_mask_value(0, 1, input_port_read(machine, "DSW0") & 0x0100 ? c64_keyline[9] : c64_keyline[8] ); |
| 154 | 153 | return cia_0_r(machine, offset); |
| 155 | 154 | } |
| 156 | 155 | else if (offset < 0xd00) |
| r2816 | r2817 | |
| 285 | 284 | |
| 286 | 285 | /* typical z80 configuration |
| 287 | 286 | 0x3f 0x3f 0x7f 0x3e 0x7e 0xb0 0x0b 0x00 0x00 0x01 0x00 */ |
| 288 | | static void c128_bankswitch_z80 (void) |
| 289 | | { |
| 287 | static void c128_bankswitch_z80 (running_machine *machine) |
| 288 | { |
| 290 | 289 | c128_ram = c64_memory + MMU_RAM_ADDR; |
| 291 | 290 | c128_va1617 = MMU_VIC_ADDR; |
| 292 | 291 | #if 1 |
| 293 | 292 | memory_set_bankptr(10, c128_z80); |
| 294 | 293 | memory_set_bankptr(11, c128_ram + 0x1000); |
| 295 | | if ( (( (input_port_read(Machine, "CFG") & 0x300) == 0x100 ) && (MMU_RAM_ADDR >= 0x40000)) |
| 296 | | || (( (input_port_read(Machine, "CFG") & 0x300) == 0x000) && (MMU_RAM_ADDR >= 0x20000)) ) |
| 294 | if ( (( (input_port_read(machine, "CFG") & 0x300) == 0x100 ) && (MMU_RAM_ADDR >= 0x40000)) |
| 295 | || (( (input_port_read(machine, "CFG") & 0x300) == 0x000) && (MMU_RAM_ADDR >= 0x20000)) ) |
| 297 | 296 | c128_ram = NULL; |
| 298 | 297 | #else |
| 299 | 298 | if (MMU_BOTTOM) |
| r2816 | r2817 | |
| 359 | 358 | memory_set_bankptr(9, c64_memory + 0xff05); |
| 360 | 359 | } |
| 361 | 360 | |
| 362 | | if ( (( (input_port_read(Machine, "CFG") & 0x300) == 0x100 ) && (MMU_RAM_ADDR >= 0x40000)) |
| 363 | | || (( (input_port_read(Machine, "CFG") & 0x300) == 0x000) && (MMU_RAM_ADDR >= 0x20000)) ) |
| 361 | if ( (( (input_port_read(machine, "CFG") & 0x300) == 0x100 ) && (MMU_RAM_ADDR >= 0x40000)) |
| 362 | || (( (input_port_read(machine, "CFG") & 0x300) == 0x000) && (MMU_RAM_ADDR >= 0x20000)) ) |
| 364 | 363 | c128_ram = NULL; |
| 365 | 364 | #endif |
| 366 | | } |
| 365 | } |
| 367 | 366 | |
| 368 | 367 | static void c128_bankswitch_128 (running_machine *machine, int reset) |
| 369 | 368 | { |
| r2816 | r2817 | |
| 526 | 525 | memory_set_bankptr(16, c128_external_function + 0x3f05); |
| 527 | 526 | } |
| 528 | 527 | |
| 529 | | if ( (( (input_port_read(Machine, "CFG") & 0x300) == 0x100 ) && (MMU_RAM_ADDR >= 0x40000)) |
| 530 | | || (( (input_port_read(Machine, "CFG") & 0x300) == 0x000) && (MMU_RAM_ADDR >= 0x20000)) ) |
| 528 | if ( (( (input_port_read(machine, "CFG") & 0x300) == 0x100 ) && (MMU_RAM_ADDR >= 0x40000)) |
| 529 | || (( (input_port_read(machine, "CFG") & 0x300) == 0x000) && (MMU_RAM_ADDR >= 0x20000)) ) |
| 531 | 530 | c128_ram = NULL; |
| 532 | 531 | } |
| 533 | 532 | } |
| r2816 | r2817 | |
| 542 | 541 | DBG_LOG (1, "switching to z80", |
| 543 | 542 | ("active %d\n",cpu_getactivecpu()) ); |
| 544 | 543 | memory_set_context(0); |
| 545 | | c128_bankswitch_z80(); |
| 544 | c128_bankswitch_z80(machine); |
| 546 | 545 | memory_set_context(1); |
| 547 | 546 | cpunum_set_input_line(machine, 0, INPUT_LINE_HALT, CLEAR_LINE); |
| 548 | 547 | cpunum_set_input_line(machine, 1, INPUT_LINE_HALT, ASSERT_LINE); |
| r2816 | r2817 | |
| 576 | 575 | return; |
| 577 | 576 | } |
| 578 | 577 | if (!MMU_CPU8502) |
| 579 | | c128_bankswitch_z80(); |
| 578 | c128_bankswitch_z80(machine); |
| 580 | 579 | else |
| 581 | 580 | c128_bankswitch_128(machine, reset); |
| 582 | 581 | } |
| r2816 | r2817 | |
| 630 | 629 | } |
| 631 | 630 | } |
| 632 | 631 | |
| 633 | | READ8_HANDLER( c128_mmu8722_port_r ) |
| 632 | READ8_HANDLER( c128_mmu8722_port_r ) |
| 634 | 633 | { |
| 635 | 634 | int data; |
| 636 | 635 | |
| r2816 | r2817 | |
| 645 | 644 | data &= ~0x10; |
| 646 | 645 | if (!c64_exrom) |
| 647 | 646 | data &= ~0x20; |
| 648 | | if (input_port_read(Machine, "SPECIAL") & 0x10) |
| 647 | if (input_port_read(machine, "SPECIAL") & 0x10) |
| 649 | 648 | data &= ~0x80; |
| 650 | 649 | break; |
| 651 | 650 | case 0xb: |
| 652 | 651 | /* hinybble number of 64 kb memory blocks */ |
| 653 | | if ((input_port_read(Machine, "CFG") & 0x300) == 0x100) // 256KB RAM |
| 652 | if ((input_port_read(machine, "CFG") & 0x300) == 0x100) // 256KB RAM |
| 654 | 653 | data = 0x4f; |
| 655 | | else if ((input_port_read(Machine, "CFG") & 0x300) == 0x200) // 1MB |
| 654 | else if ((input_port_read(machine, "CFG") & 0x300) == 0x200) // 1MB |
| 656 | 655 | data = 0xf; |
| 657 | 656 | else |
| 658 | 657 | data = 0x2f; |
src/mess/machine/amigacrt.c
| r2816 | r2817 | |
| 127 | 127 | amiga_chip_ram_w( offset * 2, data ); |
| 128 | 128 | } |
| 129 | 129 | |
| 130 | | static void amiga_ar1_check_overlay( void ) |
| 130 | static void amiga_ar1_check_overlay( running_machine *machine ) |
| 131 | 131 | { |
| 132 | | memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x000000, 0x00007f, 0, 0, amiga_ar1_chipmem_w); |
| 132 | memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x000000, 0x00007f, 0, 0, amiga_ar1_chipmem_w); |
| 133 | 133 | } |
| 134 | 134 | |
| 135 | | static void amiga_ar1_init( void ) |
| 135 | static void amiga_ar1_init( running_machine *machine ) |
| 136 | 136 | { |
| 137 | 137 | void *ar_ram; |
| 138 | 138 | |
| r2816 | r2817 | |
| 148 | 148 | memset(ar_ram, 0, 0x4000); |
| 149 | 149 | |
| 150 | 150 | /* Install ROM */ |
| 151 | | memory_install_read16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0xf00000, 0xf7ffff, 0, 0, SMH_BANK2); |
| 152 | | memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0xf00000, 0xf7ffff, 0, 0, SMH_ROM); |
| 151 | memory_install_read16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0xf00000, 0xf7ffff, 0, 0, SMH_BANK2); |
| 152 | memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0xf00000, 0xf7ffff, 0, 0, SMH_ROM); |
| 153 | 153 | |
| 154 | 154 | /* Install RAM */ |
| 155 | | memory_install_read16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x9fc000, 0x9fffff, 0, 0, SMH_BANK3); |
| 156 | | memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x9fc000, 0x9fffff, 0, 0, SMH_BANK3); |
| 155 | memory_install_read16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x9fc000, 0x9fffff, 0, 0, SMH_BANK3); |
| 156 | memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x9fc000, 0x9fffff, 0, 0, SMH_BANK3); |
| 157 | 157 | |
| 158 | 158 | /* Configure Banks */ |
| 159 | 159 | memory_set_bankptr(2, memory_region(REGION_USER2)); |
| r2816 | r2817 | |
| 333 | 333 | } |
| 334 | 334 | #endif |
| 335 | 335 | |
| 336 | | static void amiga_ar23_check_overlay( void ) |
| 336 | static void amiga_ar23_check_overlay( running_machine *machine ) |
| 337 | 337 | { |
| 338 | 338 | amiga_ar23_mode = 3; |
| 339 | | memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x000000, 0x00000f, 0, 0, amiga_ar23_chipmem_w); |
| 339 | memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x000000, 0x00000f, 0, 0, amiga_ar23_chipmem_w); |
| 340 | 340 | } |
| 341 | 341 | |
| 342 | | static void amiga_ar23_init( int ar3 ) |
| 342 | static void amiga_ar23_init( running_machine *machine, int ar3 ) |
| 343 | 343 | { |
| 344 | 344 | UINT32 mirror = 0x20000, size = 0x1ffff; |
| 345 | 345 | void *ar_ram; |
| r2816 | r2817 | |
| 363 | 363 | } |
| 364 | 364 | |
| 365 | 365 | /* Install ROM */ |
| 366 | | memory_install_read16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x400000, 0x400000+size, 0, mirror, SMH_BANK2); |
| 367 | | memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x400000, 0x400000+size, 0, mirror, SMH_ROM); |
| 366 | memory_install_read16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x400000, 0x400000+size, 0, mirror, SMH_BANK2); |
| 367 | memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x400000, 0x400000+size, 0, mirror, SMH_ROM); |
| 368 | 368 | |
| 369 | 369 | /* Install RAM */ |
| 370 | | memory_install_read16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x440000, 0x44ffff, 0, 0, SMH_BANK3); |
| 371 | | memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x440000, 0x44ffff, 0, 0, SMH_BANK3); |
| 370 | memory_install_read16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x440000, 0x44ffff, 0, 0, SMH_BANK3); |
| 371 | memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x440000, 0x44ffff, 0, 0, SMH_BANK3); |
| 372 | 372 | |
| 373 | 373 | /* Install Custom chip monitor */ |
| 374 | | // memory_install_read16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0xdff000, 0xdff1ff, 0, 0, amiga_ar23_custom_r); |
| 375 | | // memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0xdff000, 0xdff1ff, 0, 0, amiga_ar23_custom_w); |
| 374 | // memory_install_read16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0xdff000, 0xdff1ff, 0, 0, amiga_ar23_custom_r); |
| 375 | // memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0xdff000, 0xdff1ff, 0, 0, amiga_ar23_custom_w); |
| 376 | 376 | |
| 377 | 377 | /* Install status/mode handlers */ |
| 378 | | memory_install_read16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x400000, 0x400007, 0, mirror, amiga_ar23_mode_r); |
| 379 | | memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, 0x400000, 0x400003, 0, mirror, amiga_ar23_mode_w); |
| 378 | memory_install_read16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x400000, 0x400007, 0, mirror, amiga_ar23_mode_r); |
| 379 | memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, 0x400000, 0x400003, 0, mirror, amiga_ar23_mode_w); |
| 380 | 380 | |
| 381 | 381 | /* Configure Banks */ |
| 382 | 382 | memory_set_bankptr(2, memory_region(REGION_USER2)); |
| r2816 | r2817 | |
| 395 | 395 | |
| 396 | 396 | ***************************************************************************/ |
| 397 | 397 | |
| 398 | | void amiga_cart_init( void ) |
| 398 | void amiga_cart_init( running_machine *machine ) |
| 399 | 399 | { |
| 400 | 400 | /* see what is there */ |
| 401 | 401 | UINT16 *mem = (UINT16 *)memory_region( REGION_USER2 ); |
| r2816 | r2817 | |
| 407 | 407 | if ( mem[0x00] == 0x1111 ) |
| 408 | 408 | { |
| 409 | 409 | amiga_cart_type = ACTION_REPLAY; |
| 410 | | amiga_ar1_init(); |
| 410 | amiga_ar1_init(machine); |
| 411 | 411 | } |
| 412 | 412 | else if ( mem[0x0C] == 0x4D6B ) |
| 413 | 413 | { |
| 414 | 414 | amiga_cart_type = ACTION_REPLAY_MKII; |
| 415 | | amiga_ar23_init(0); |
| 415 | amiga_ar23_init(machine, 0); |
| 416 | 416 | } |
| 417 | 417 | else if ( mem[0x0C] == 0x4D4B ) |
| 418 | 418 | { |
| 419 | 419 | amiga_cart_type = ACTION_REPLAY_MKIII; |
| 420 | | amiga_ar23_init(1); |
| 420 | amiga_ar23_init(machine, 1); |
| 421 | 421 | } |
| 422 | 422 | } |
| 423 | 423 | } |
| 424 | 424 | |
| 425 | | void amiga_cart_check_overlay( void ) |
| 425 | void amiga_cart_check_overlay( running_machine *machine ) |
| 426 | 426 | { |
| 427 | 427 | if ( amiga_cart_type < 0 ) |
| 428 | 428 | return; |
| r2816 | r2817 | |
| 430 | 430 | switch( amiga_cart_type ) |
| 431 | 431 | { |
| 432 | 432 | case ACTION_REPLAY: |
| 433 | | amiga_ar1_check_overlay(); |
| 433 | amiga_ar1_check_overlay(machine); |
| 434 | 434 | break; |
| 435 | 435 | |
| 436 | 436 | case ACTION_REPLAY_MKII: |
| 437 | 437 | case ACTION_REPLAY_MKIII: |
| 438 | | amiga_ar23_check_overlay(); |
| 438 | amiga_ar23_check_overlay(machine); |
| 439 | 439 | break; |
| 440 | 440 | } |
| 441 | 441 | } |
src/mess/machine/samcoupe.c
| r2816 | r2817 | |
| 8 | 8 | ***************************************************************************/ |
| 9 | 9 | |
| 10 | 10 | #include "driver.h" |
| 11 | | #include "deprecat.h" |
| 12 | 11 | #include "includes/samcoupe.h" |
| 13 | 12 | #include "devices/basicdsk.h" |
| 14 | 13 | #include "machine/wd17xx.h" |
| r2816 | r2817 | |
| 23 | 22 | struct samcoupe_asic samcoupe_regs; |
| 24 | 23 | |
| 25 | 24 | |
| 26 | | static void samcoupe_update_bank(int bank, UINT8 *memory, int is_readonly) |
| 25 | static void samcoupe_update_bank(running_machine *machine, int bank, UINT8 *memory, int is_readonly) |
| 27 | 26 | { |
| 28 | 27 | read8_machine_func rh = SMH_NOP; |
| 29 | 28 | write8_machine_func wh = SMH_NOP; |
| r2816 | r2817 | |
| 35 | 34 | wh = is_readonly ? SMH_UNMAP : (write8_machine_func) (STATIC_BANK1 + (FPTR)bank - 1); |
| 36 | 35 | } |
| 37 | 36 | |
| 38 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, ((bank-1) * 0x4000), ((bank-1) * 0x4000) + 0x3FFF, 0, 0, rh); |
| 39 | | memory_install_write8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, ((bank-1) * 0x4000), ((bank-1) * 0x4000) + 0x3FFF, 0, 0, wh); |
| 37 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, ((bank-1) * 0x4000), ((bank-1) * 0x4000) + 0x3FFF, 0, 0, rh); |
| 38 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, ((bank-1) * 0x4000), ((bank-1) * 0x4000) + 0x3FFF, 0, 0, wh); |
| 40 | 39 | } |
| 41 | 40 | |
| 42 | 41 | |
| 43 | | static void samcoupe_install_ext_mem(void) |
| 42 | static void samcoupe_install_ext_mem(running_machine *machine) |
| 44 | 43 | { |
| 45 | 44 | UINT8 *mem; |
| 46 | 45 | |
| r2816 | r2817 | |
| 50 | 49 | else |
| 51 | 50 | mem = NULL; |
| 52 | 51 | |
| 53 | | samcoupe_update_bank(3, mem, FALSE); |
| 52 | samcoupe_update_bank(machine, 3, mem, FALSE); |
| 54 | 53 | |
| 55 | 54 | /* bank 4 */ |
| 56 | 55 | if (samcoupe_regs.hext >> 6 < mess_ram_size >> 20) |
| r2816 | r2817 | |
| 58 | 57 | else |
| 59 | 58 | mem = NULL; |
| 60 | 59 | |
| 61 | | samcoupe_update_bank(4, mem, FALSE); |
| 60 | samcoupe_update_bank(machine, 4, mem, FALSE); |
| 62 | 61 | } |
| 63 | 62 | |
| 64 | 63 | |
| r2816 | r2817 | |
| 83 | 82 | memory = rom; /* Rom0 paged in */ |
| 84 | 83 | is_readonly = TRUE; |
| 85 | 84 | } |
| 86 | | samcoupe_update_bank(1, memory, is_readonly); |
| 85 | samcoupe_update_bank(machine, 1, memory, is_readonly); |
| 87 | 86 | |
| 88 | 87 | |
| 89 | 88 | /* BANK2 */ |
| r2816 | r2817 | |
| 91 | 90 | memory = &mess_ram[((samcoupe_regs.lmpr + 1) & PAGE_MASK) * 0x4000]; |
| 92 | 91 | else |
| 93 | 92 | memory = NULL; /* Attempt to page in non existant ram region */ |
| 94 | | samcoupe_update_bank(2, memory, FALSE); |
| 93 | samcoupe_update_bank(machine, 2, memory, FALSE); |
| 95 | 94 | |
| 96 | 95 | /* only update bank 3 and 4 when external memory is not enabled */ |
| 97 | 96 | if (samcoupe_regs.hmpr & HMPR_MCNTRL) |
| 98 | 97 | { |
| 99 | | samcoupe_install_ext_mem(); |
| 98 | samcoupe_install_ext_mem(machine); |
| 100 | 99 | } |
| 101 | 100 | else |
| 102 | 101 | { |
| r2816 | r2817 | |
| 105 | 104 | memory = &mess_ram[(samcoupe_regs.hmpr & PAGE_MASK)*0x4000]; |
| 106 | 105 | else |
| 107 | 106 | memory = NULL; /* Attempt to page in non existant ram region */ |
| 108 | | samcoupe_update_bank(3, memory, FALSE); |
| 107 | samcoupe_update_bank(machine, 3, memory, FALSE); |
| 109 | 108 | |
| 110 | 109 | |
| 111 | 110 | /* BANK4 */ |
| r2816 | r2817 | |
| 122 | 121 | memory = NULL; /* Attempt to page in non existant ram region */ |
| 123 | 122 | is_readonly = FALSE; |
| 124 | 123 | } |
| 125 | | samcoupe_update_bank(4, memory, FALSE); |
| 124 | samcoupe_update_bank(machine, 4, memory, FALSE); |
| 126 | 125 | } |
| 127 | 126 | |
| 128 | 127 | /* video memory location */ |
| r2816 | r2817 | |
| 143 | 142 | /* external RAM enabled? */ |
| 144 | 143 | if (samcoupe_regs.hmpr & HMPR_MCNTRL) |
| 145 | 144 | { |
| 146 | | samcoupe_install_ext_mem(); |
| 145 | samcoupe_install_ext_mem(machine); |
| 147 | 146 | } |
| 148 | 147 | } |
| 149 | 148 | |
src/mess/machine/vtech2.c
| r2816 | r2817 | |
| 14 | 14 | ****************************************************************************/ |
| 15 | 15 | |
| 16 | 16 | #include "driver.h" |
| 17 | | #include "deprecat.h" |
| 18 | 17 | #include "includes/vtech2.h" |
| 19 | 18 | #include "devices/cassette.h" |
| 20 | 19 | #include "sound/speaker.h" |
| r2816 | r2817 | |
| 54 | 53 | static WRITE8_HANDLER ( mwa_bank4 ) { mwa_bank(3,offset,data); } |
| 55 | 54 | |
| 56 | 55 | /* read from banked memory (handle memory mapped i/o) */ |
| 57 | | static int mra_bank(int bank, int offs); |
| 56 | static int mra_bank(running_machine *machine, int bank, int offs); |
| 58 | 57 | |
| 59 | 58 | /* wrappers for bank #1 to #4 */ |
| 60 | | static READ8_HANDLER ( mra_bank1) { return mra_bank(0,offset); } |
| 61 | | static READ8_HANDLER ( mra_bank2) { return mra_bank(1,offset); } |
| 62 | | static READ8_HANDLER ( mra_bank3) { return mra_bank(2,offset); } |
| 63 | | static READ8_HANDLER ( mra_bank4) { return mra_bank(3,offset); } |
| 59 | static READ8_HANDLER ( mra_bank1) { return mra_bank(machine,0,offset); } |
| 60 | static READ8_HANDLER ( mra_bank2) { return mra_bank(machine,1,offset); } |
| 61 | static READ8_HANDLER ( mra_bank3) { return mra_bank(machine,2,offset); } |
| 62 | static READ8_HANDLER ( mra_bank4) { return mra_bank(machine,3,offset); } |
| 64 | 63 | |
| 65 | 64 | /* read banked memory (handle memory mapped i/o) */ |
| 66 | 65 | static const read8_machine_func mra_bank_soft[4] = |
| r2816 | r2817 | |
| 214 | 213 | * 1 column 1 |
| 215 | 214 | * 0 column 0 |
| 216 | 215 | ************************************************/ |
| 217 | | static int mra_bank(int bank, int offs) |
| 216 | static int mra_bank(running_machine *machine, int bank, int offs) |
| 218 | 217 | { |
| 219 | 218 | static int level_old = 0, cassette_bit = 0; |
| 220 | 219 | int level, data = 0xff; |
| r2816 | r2817 | |
| 225 | 224 | static int row_a,row_b,row_c,row_d; |
| 226 | 225 | if( (offs & 0x0300) == 0x0000 ) /* keyboard row A */ |
| 227 | 226 | { |
| 228 | | if( input_port_read(Machine, "ROWA") != row_a ) |
| 227 | if( input_port_read(machine, "ROWA") != row_a ) |
| 229 | 228 | { |
| 230 | | row_a = input_port_read(Machine, "ROWA"); |
| 229 | row_a = input_port_read(machine, "ROWA"); |
| 231 | 230 | data &= row_a; |
| 232 | 231 | } |
| 233 | 232 | } |
| 234 | 233 | if( (offs & 0x0300) == 0x0100 ) /* keyboard row B */ |
| 235 | 234 | { |
| 236 | | if( input_port_read(Machine, "ROWB") != row_b ) |
| 235 | if( input_port_read(machine, "ROWB") != row_b ) |
| 237 | 236 | { |
| 238 | | row_b = input_port_read(Machine, "ROWB"); |
| 237 | row_b = input_port_read(machine, "ROWB"); |
| 239 | 238 | data &= row_b; |
| 240 | 239 | } |
| 241 | 240 | } |
| 242 | 241 | if( (offs & 0x0300) == 0x0200 ) /* keyboard row C */ |
| 243 | 242 | { |
| 244 | | if( input_port_read(Machine, "ROWC") != row_c ) |
| 243 | if( input_port_read(machine, "ROWC") != row_c ) |
| 245 | 244 | { |
| 246 | | row_c = input_port_read(Machine, "ROWC"); |
| 245 | row_c = input_port_read(machine, "ROWC"); |
| 247 | 246 | data &= row_c; |
| 248 | 247 | } |
| 249 | 248 | } |
| 250 | 249 | if( (offs & 0x0300) == 0x0300 ) /* keyboard row D */ |
| 251 | 250 | { |
| 252 | | if( input_port_read(Machine, "ROWD") != row_d ) |
| 251 | if( input_port_read(machine, "ROWD") != row_d ) |
| 253 | 252 | { |
| 254 | | row_d = input_port_read(Machine, "ROWD"); |
| 253 | row_d = input_port_read(machine, "ROWD"); |
| 255 | 254 | data &= row_d; |
| 256 | 255 | } |
| 257 | 256 | } |
| r2816 | r2817 | |
| 260 | 259 | { |
| 261 | 260 | /* All Lasers keyboard rows 0 through 7 */ |
| 262 | 261 | if( !(offs & 0x01) ) |
| 263 | | data &= input_port_read(Machine, "ROW0"); |
| 262 | data &= input_port_read(machine, "ROW0"); |
| 264 | 263 | if( !(offs & 0x02) ) |
| 265 | | data &= input_port_read(Machine, "ROW1"); |
| 264 | data &= input_port_read(machine, "ROW1"); |
| 266 | 265 | if( !(offs & 0x04) ) |
| 267 | | data &= input_port_read(Machine, "ROW2"); |
| 266 | data &= input_port_read(machine, "ROW2"); |
| 268 | 267 | if( !(offs & 0x08) ) |
| 269 | | data &= input_port_read(Machine, "ROW3"); |
| 268 | data &= input_port_read(machine, "ROW3"); |
| 270 | 269 | if( !(offs & 0x10) ) |
| 271 | | data &= input_port_read(Machine, "ROW4"); |
| 270 | data &= input_port_read(machine, "ROW4"); |
| 272 | 271 | if( !(offs & 0x20) ) |
| 273 | | data &= input_port_read(Machine, "ROW5"); |
| 272 | data &= input_port_read(machine, "ROW5"); |
| 274 | 273 | if( !(offs & 0x40) ) |
| 275 | | data &= input_port_read(Machine, "ROW6"); |
| 274 | data &= input_port_read(machine, "ROW6"); |
| 276 | 275 | if( !(offs & 0x80) ) |
| 277 | | data &= input_port_read(Machine, "ROW7"); |
| 276 | data &= input_port_read(machine, "ROW7"); |
| 278 | 277 | } |
| 279 | 278 | |
| 280 | 279 | /* what's bit 7 good for? tape input maybe? */ |
src/mess/machine/mac.c
| r2816 | r2817 | |
| 104 | 104 | |
| 105 | 105 | |
| 106 | 106 | |
| 107 | | static void mac_install_memory(offs_t memory_begin, offs_t memory_end, |
| 107 | static void mac_install_memory(running_machine *machine, offs_t memory_begin, offs_t memory_end, |
| 108 | 108 | offs_t memory_size, void *memory_data, int is_rom, int bank) |
| 109 | 109 | { |
| 110 | 110 | offs_t memory_mask; |
| r2816 | r2817 | |
| 117 | 117 | rh = (read16_machine_func) (FPTR)bank; |
| 118 | 118 | wh = is_rom ? SMH_UNMAP : (write16_machine_func) (FPTR)bank; |
| 119 | 119 | |
| 120 | | memory_install_read16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, memory_begin, |
| 120 | memory_install_read16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, memory_begin, |
| 121 | 121 | memory_end, memory_mask, 0, rh); |
| 122 | | memory_install_write16_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, memory_begin, |
| 122 | memory_install_write16_handler(machine, 0, ADDRESS_SPACE_PROGRAM, memory_begin, |
| 123 | 123 | memory_end, memory_mask, 0, wh); |
| 124 | 124 | |
| 125 | 125 | memory_set_bankptr(bank, memory_data); |
| r2816 | r2817 | |
| 227 | 227 | } |
| 228 | 228 | |
| 229 | 229 | /* install the memory */ |
| 230 | | mac_install_memory(0x000000, 0x3fffff, memory_size, memory_data, is_rom, 1); |
| 230 | mac_install_memory(machine, 0x000000, 0x3fffff, memory_size, memory_data, is_rom, 1); |
| 231 | 231 | |
| 232 | 232 | mac_overlay = overlay; |
| 233 | 233 | |
| r2816 | r2817 | |
| 1343 | 1343 | mac_model = model; |
| 1344 | 1344 | |
| 1345 | 1345 | /* set up RAM mirror at 0x600000-0x6fffff (0x7fffff ???) */ |
| 1346 | | mac_install_memory(0x600000, 0x6fffff, mess_ram_size, mess_ram, FALSE, 2); |
| 1346 | mac_install_memory(machine, 0x600000, 0x6fffff, mess_ram_size, mess_ram, FALSE, 2); |
| 1347 | 1347 | |
| 1348 | 1348 | /* set up ROM at 0x400000-0x43ffff (-0x5fffff for mac 128k/512k/512ke) */ |
| 1349 | | mac_install_memory(0x400000, (model >= MODEL_MAC_PLUS) ? 0x43ffff : 0x5fffff, |
| 1349 | mac_install_memory(machine, 0x400000, (model >= MODEL_MAC_PLUS) ? 0x43ffff : 0x5fffff, |
| 1350 | 1350 | memory_region_length(REGION_USER1), memory_region(REGION_USER1), TRUE, 3); |
| 1351 | 1351 | |
| 1352 | 1352 | set_memory_overlay(machine, 1); |
| r2816 | r2817 | |
| 1364 | 1364 | |
| 1365 | 1365 | /* save state stuff */ |
| 1366 | 1366 | state_save_register_global(mac_overlay); |
| 1367 | | state_save_register_postload(Machine, mac_state_load, NULL); |
| 1367 | state_save_register_postload(machine, mac_state_load, NULL); |
| 1368 | 1368 | } |
| 1369 | 1369 | |
| 1370 | 1370 | |
src/mess/machine/nes.c
| r2816 | r2817 | |
| 1 | 1 | #include "driver.h" |
| 2 | | #include "deprecat.h" |
| 3 | 2 | #include "cpu/m6502/m6502.h" |
| 4 | 3 | #include "video/ppu2c0x.h" |
| 5 | 4 | #include "includes/nes.h" |
| r2816 | r2817 | |
| 299 | 298 | |
| 300 | 299 | |
| 301 | 300 | |
| 302 | | static void nes_read_input_device(int cfg, nes_input *vals, int pad_port, |
| 301 | static void nes_read_input_device(running_machine *machine, int cfg, nes_input *vals, int pad_port, |
| 303 | 302 | int supports_zapper, int paddle_port) |
| 304 | 303 | { |
| 305 | 304 | char port[5]; |
| r2816 | r2817 | |
| 314 | 313 | if (pad_port >= 0) |
| 315 | 314 | { |
| 316 | 315 | sprintf(port, "PAD%d", pad_port+1); |
| 317 | | vals->i0 = input_port_read(Machine, port); |
| 316 | vals->i0 = input_port_read(machine, port); |
| 318 | 317 | } |
| 319 | 318 | break; |
| 320 | 319 | |
| 321 | 320 | case 0x02: /* zapper 1 */ |
| 322 | 321 | if (supports_zapper) |
| 323 | 322 | { |
| 324 | | vals->i0 = input_port_read(Machine, "ZAPPER1_T"); |
| 325 | | vals->i1 = input_port_read(Machine, "ZAPPER1_X"); |
| 326 | | vals->i2 = input_port_read(Machine, "ZAPPER1_Y"); |
| 323 | vals->i0 = input_port_read(machine, "ZAPPER1_T"); |
| 324 | vals->i1 = input_port_read(machine, "ZAPPER1_X"); |
| 325 | vals->i2 = input_port_read(machine, "ZAPPER1_Y"); |
| 327 | 326 | } |
| 328 | 327 | break; |
| 329 | 328 | |
| 330 | 329 | case 0x03: /* zapper 2 */ |
| 331 | 330 | if (supports_zapper) |
| 332 | 331 | { |
| 333 | | vals->i0 = input_port_read(Machine, "ZAPPER2_T"); |
| 334 | | vals->i1 = input_port_read(Machine, "ZAPPER2_X"); |
| 335 | | vals->i2 = input_port_read(Machine, "ZAPPER2_Y"); |
| 332 | vals->i0 = input_port_read(machine, "ZAPPER2_T"); |
| 333 | vals->i1 = input_port_read(machine, "ZAPPER2_X"); |
| 334 | vals->i2 = input_port_read(machine, "ZAPPER2_Y"); |
| 336 | 335 | } |
| 337 | 336 | break; |
| 338 | 337 | |
| 339 | 338 | case 0x04: /* arkanoid paddle */ |
| 340 | 339 | if (paddle_port >= 0) |
| 341 | | vals->i0 = (UINT8) ((UINT8) input_port_read(Machine, "PADDLE") + (UINT8)0x52) ^ 0xff; |
| 340 | vals->i0 = (UINT8) ((UINT8) input_port_read(machine, "PADDLE") + (UINT8)0x52) ^ 0xff; |
| 342 | 341 | break; |
| 343 | 342 | } |
| 344 | 343 | } |
| r2816 | r2817 | |
| 364 | 363 | cfg = input_port_read(machine, "CONTROLLERS"); |
| 365 | 364 | |
| 366 | 365 | /* Read the input devices */ |
| 367 | | nes_read_input_device(cfg >> 0, &in_0, 0, TRUE, -1); |
| 368 | | nes_read_input_device(cfg >> 4, &in_1, 1, TRUE, 1); |
| 369 | | nes_read_input_device(cfg >> 8, &in_2, 2, FALSE, -1); |
| 370 | | nes_read_input_device(cfg >> 12, &in_3, 3, FALSE, -1); |
| 366 | nes_read_input_device(machine, cfg >> 0, &in_0, 0, TRUE, -1); |
| 367 | nes_read_input_device(machine, cfg >> 4, &in_1, 1, TRUE, 1); |
| 368 | nes_read_input_device(machine, cfg >> 8, &in_2, 2, FALSE, -1); |
| 369 | nes_read_input_device(machine, cfg >> 12, &in_3, 3, FALSE, -1); |
| 371 | 370 | |
| 372 | 371 | if (cfg & 0x0f00) |
| 373 | 372 | in_0.i0 |= (in_2.i0 << 8) | (0x08 << 16); |
src/mess/machine/i82439tx.c
| r2816 | r2817 | |
| 199 | 199 | } |
| 200 | 200 | |
| 201 | 201 | /* hack to compensate for weird issue (maybe the Pentium core needs to support caching? */ |
| 202 | | if ((cpunum_get_reg(0, REG_PC) == 0xFCB01) && !strcmp(Machine->gamedrv->name, "at586")) |
| 202 | if ((cpunum_get_reg(0, REG_PC) == 0xFCB01) && !strcmp(machine->gamedrv->name, "at586")) |
| 203 | 203 | { |
| 204 | 204 | memory_region(REGION_USER1)[0x3CB01] = 0xF3; |
| 205 | 205 | memory_region(REGION_USER1)[0x3CB02] = 0xA4; |
| r2816 | r2817 | |
| 218 | 218 | |
| 219 | 219 | |
| 220 | 220 | |
| 221 | | void intel82439tx_init(void) |
| 221 | void intel82439tx_init(running_machine *machine) |
| 222 | 222 | { |
| 223 | 223 | /* setup PCI */ |
| 224 | 224 | pci_init(); |
| r2816 | r2817 | |
| 232 | 232 | i82439tx->regs[0x04] = 0x02020202; |
| 233 | 233 | i82439tx->regs[0x05] = 0x00000002; |
| 234 | 234 | |
| 235 | | intel82439tx_configure_memory(Machine, 0, 0xF0000, 0xFFFFF, BANK_F0000_R, bank_f0000_w); |
| 236 | | intel82439tx_configure_memory(Machine, 0, 0xC0000, 0xC3FFF, BANK_C0000_R, bank_c0000_w); |
| 237 | | intel82439tx_configure_memory(Machine, 0, 0xC4000, 0xC7FFF, BANK_C4000_R, bank_c4000_w); |
| 238 | | intel82439tx_configure_memory(Machine, 0, 0xC8000, 0xCCFFF, BANK_C8000_R, bank_c8000_w); |
| 239 | | intel82439tx_configure_memory(Machine, 0, 0xCC000, 0xCFFFF, BANK_CC000_R, bank_cc000_w); |
| 240 | | intel82439tx_configure_memory(Machine, 0, 0xD0000, 0xD3FFF, BANK_D0000_R, bank_d0000_w); |
| 241 | | intel82439tx_configure_memory(Machine, 0, 0xD4000, 0xD7FFF, BANK_D4000_R, bank_d4000_w); |
| 242 | | intel82439tx_configure_memory(Machine, 0, 0xD8000, 0xDBFFF, BANK_D8000_R, bank_d8000_w); |
| 243 | | intel82439tx_configure_memory(Machine, 0, 0xDC000, 0xDFFFF, BANK_DC000_R, bank_dc000_w); |
| 244 | | intel82439tx_configure_memory(Machine, 0, 0xE0000, 0xE3FFF, BANK_E0000_R, bank_e0000_w); |
| 245 | | intel82439tx_configure_memory(Machine, 0, 0xE4000, 0xE7FFF, BANK_E4000_R, bank_e4000_w); |
| 246 | | intel82439tx_configure_memory(Machine, 0, 0xE8000, 0xECFFF, BANK_E8000_R, bank_e8000_w); |
| 247 | | intel82439tx_configure_memory(Machine, 0, 0xEC000, 0xEFFFF, BANK_EC000_R, bank_ec000_w); |
| 235 | intel82439tx_configure_memory(machine, 0, 0xF0000, 0xFFFFF, BANK_F0000_R, bank_f0000_w); |
| 236 | intel82439tx_configure_memory(machine, 0, 0xC0000, 0xC3FFF, BANK_C0000_R, bank_c0000_w); |
| 237 | intel82439tx_configure_memory(machine, 0, 0xC4000, 0xC7FFF, BANK_C4000_R, bank_c4000_w); |
| 238 | intel82439tx_configure_memory(machine, 0, 0xC8000, 0xCCFFF, BANK_C8000_R, bank_c8000_w); |
| 239 | intel82439tx_configure_memory(machine, 0, 0xCC000, 0xCFFFF, BANK_CC000_R, bank_cc000_w); |
| 240 | intel82439tx_configure_memory(machine, 0, 0xD0000, 0xD3FFF, BANK_D0000_R, bank_d0000_w); |
| 241 | intel82439tx_configure_memory(machine, 0, 0xD4000, 0xD7FFF, BANK_D4000_R, bank_d4000_w); |
| 242 | intel82439tx_configure_memory(machine, 0, 0xD8000, 0xDBFFF, BANK_D8000_R, bank_d8000_w); |
| 243 | intel82439tx_configure_memory(machine, 0, 0xDC000, 0xDFFFF, BANK_DC000_R, bank_dc000_w); |
| 244 | intel82439tx_configure_memory(machine, 0, 0xE0000, 0xE3FFF, BANK_E0000_R, bank_e0000_w); |
| 245 | intel82439tx_configure_memory(machine, 0, 0xE4000, 0xE7FFF, BANK_E4000_R, bank_e4000_w); |
| 246 | intel82439tx_configure_memory(machine, 0, 0xE8000, 0xECFFF, BANK_E8000_R, bank_e8000_w); |
| 247 | intel82439tx_configure_memory(machine, 0, 0xEC000, 0xEFFFF, BANK_EC000_R, bank_ec000_w); |
| 248 | 248 | } |
| 249 | 249 | |
src/mess/machine/apple2.c
| r2816 | r2817 | |
| 194 | 194 | |
| 195 | 195 | /* install the actual handlers */ |
| 196 | 196 | if (begin <= end_r) |
| 197 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, begin, end_r, 0, 0, rh); |
| 197 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, begin, end_r, 0, 0, rh); |
| 198 | 198 | |
| 199 | 199 | /* did we 'go past the end?' */ |
| 200 | 200 | if (end_r < apple2_mem_config.memmap[i].end) |
| 201 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, end_r + 1, apple2_mem_config.memmap[i].end, 0, 0, SMH_NOP); |
| 201 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, end_r + 1, apple2_mem_config.memmap[i].end, 0, 0, SMH_NOP); |
| 202 | 202 | |
| 203 | 203 | /* set the memory bank */ |
| 204 | 204 | if (rbase) |
| r2816 | r2817 | |
| 269 | 269 | |
| 270 | 270 | /* install the actual handlers */ |
| 271 | 271 | if (begin <= end_w) |
| 272 | | memory_install_write8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, begin, end_w, 0, 0, wh); |
| 272 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, begin, end_w, 0, 0, wh); |
| 273 | 273 | |
| 274 | 274 | /* did we 'go past the end?' */ |
| 275 | 275 | if (end_w < apple2_mem_config.memmap[i].end) |
| 276 | | memory_install_write8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, end_w + 1, apple2_mem_config.memmap[i].end, 0, 0, SMH_NOP); |
| 276 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, end_w + 1, apple2_mem_config.memmap[i].end, 0, 0, SMH_NOP); |
| 277 | 277 | |
| 278 | 278 | /* set the memory bank */ |
| 279 | 279 | if (wbase) |
| r2816 | r2817 | |
| 1101 | 1101 | |
| 1102 | 1102 | static int apple2_fdc_diskreg; |
| 1103 | 1103 | |
| 1104 | | static int apple2_fdc_has_35(void) |
| 1104 | static int apple2_fdc_has_35(running_machine *machine) |
| 1105 | 1105 | { |
| 1106 | | return device_count_tag_from_machine(Machine, "sonydriv") > 0; |
| 1106 | return device_count_tag_from_machine(machine, "sonydriv") > 0; |
| 1107 | 1107 | } |
| 1108 | 1108 | |
| 1109 | | static int apple2_fdc_has_525(void) |
| 1109 | static int apple2_fdc_has_525(running_machine *machine) |
| 1110 | 1110 | { |
| 1111 | | return device_count_tag_from_machine(Machine, "apple525driv") > 0; |
| 1111 | return device_count_tag_from_machine(machine, "apple525driv") > 0; |
| 1112 | 1112 | } |
| 1113 | 1113 | |
| 1114 | 1114 | static void apple2_fdc_set_lines(UINT8 lines) |
| 1115 | 1115 | { |
| 1116 | 1116 | if (apple2_fdc_diskreg & 0x40) |
| 1117 | 1117 | { |
| 1118 | | if (apple2_fdc_has_35()) |
| 1118 | if (apple2_fdc_has_35(Machine)) |
| 1119 | 1119 | { |
| 1120 | 1120 | /* slot 5: 3.5" disks */ |
| 1121 | 1121 | sony_set_lines(lines); |
| r2816 | r2817 | |
| 1123 | 1123 | } |
| 1124 | 1124 | else |
| 1125 | 1125 | { |
| 1126 | | if (apple2_fdc_has_525()) |
| 1126 | if (apple2_fdc_has_525(Machine)) |
| 1127 | 1127 | { |
| 1128 | 1128 | /* slot 6: 5.25" disks */ |
| 1129 | 1129 | apple525_set_lines(lines); |
| r2816 | r2817 | |
| 1143 | 1143 | else |
| 1144 | 1144 | slot6_enable_mask = enable_mask; |
| 1145 | 1145 | |
| 1146 | | if (apple2_fdc_has_35()) |
| 1146 | if (apple2_fdc_has_35(Machine)) |
| 1147 | 1147 | { |
| 1148 | 1148 | /* set the 3.5" enable lines */ |
| 1149 | 1149 | sony_set_enable_lines(slot5_enable_mask); |
| 1150 | 1150 | } |
| 1151 | 1151 | |
| 1152 | | if (apple2_fdc_has_525()) |
| 1152 | if (apple2_fdc_has_525(Machine)) |
| 1153 | 1153 | { |
| 1154 | 1154 | /* set the 5.25" enable lines */ |
| 1155 | 1155 | apple525_set_enable_lines(slot6_enable_mask); |
| r2816 | r2817 | |
| 1164 | 1164 | |
| 1165 | 1165 | if (apple2_fdc_diskreg & 0x40) |
| 1166 | 1166 | { |
| 1167 | | if (apple2_fdc_has_35()) |
| 1167 | if (apple2_fdc_has_35(Machine)) |
| 1168 | 1168 | { |
| 1169 | 1169 | /* slot 5: 3.5" disks */ |
| 1170 | 1170 | result = sony_read_data(); |
| r2816 | r2817 | |
| 1172 | 1172 | } |
| 1173 | 1173 | else |
| 1174 | 1174 | { |
| 1175 | | if (apple2_fdc_has_525()) |
| 1175 | if (apple2_fdc_has_525(Machine)) |
| 1176 | 1176 | { |
| 1177 | 1177 | /* slot 6: 5.25" disks */ |
| 1178 | 1178 | result = apple525_read_data(); |
| r2816 | r2817 | |
| 1187 | 1187 | { |
| 1188 | 1188 | if (apple2_fdc_diskreg & 0x40) |
| 1189 | 1189 | { |
| 1190 | | if (apple2_fdc_has_35()) |
| 1190 | if (apple2_fdc_has_35(Machine)) |
| 1191 | 1191 | { |
| 1192 | 1192 | /* slot 5: 3.5" disks */ |
| 1193 | 1193 | sony_write_data(data); |
| r2816 | r2817 | |
| 1195 | 1195 | } |
| 1196 | 1196 | else |
| 1197 | 1197 | { |
| 1198 | | if (apple2_fdc_has_525()) |
| 1198 | if (apple2_fdc_has_525(Machine)) |
| 1199 | 1199 | { |
| 1200 | 1200 | /* slot 6: 5.25" disks */ |
| 1201 | 1201 | apple525_write_data(data); |
| r2816 | r2817 | |
| 1211 | 1211 | |
| 1212 | 1212 | if (apple2_fdc_diskreg & 0x40) |
| 1213 | 1213 | { |
| 1214 | | if (apple2_fdc_has_35()) |
| 1214 | if (apple2_fdc_has_35(Machine)) |
| 1215 | 1215 | { |
| 1216 | 1216 | /* slot 5: 3.5" disks */ |
| 1217 | 1217 | result = sony_read_status(); |
| r2816 | r2817 | |
| 1219 | 1219 | } |
| 1220 | 1220 | else |
| 1221 | 1221 | { |
| 1222 | | if (apple2_fdc_has_525()) |
| 1222 | if (apple2_fdc_has_525(Machine)) |
| 1223 | 1223 | { |
| 1224 | 1224 | /* slot 6: 5.25" disks */ |
| 1225 | 1225 | result = apple525_read_status(); |
| r2816 | r2817 | |
| 1230 | 1230 | |
| 1231 | 1231 | |
| 1232 | 1232 | |
| 1233 | | void apple2_iwm_setdiskreg(UINT8 data) |
| 1233 | void apple2_iwm_setdiskreg(running_machine *machine, UINT8 data) |
| 1234 | 1234 | { |
| 1235 | 1235 | apple2_fdc_diskreg = data & 0xC0; |
| 1236 | | if (apple2_fdc_has_35()) |
| 1236 | if (apple2_fdc_has_35(machine)) |
| 1237 | 1237 | sony_set_sel_line(apple2_fdc_diskreg & 0x80); |
| 1238 | 1238 | } |
| 1239 | 1239 | |
src/mess/machine/ti99_4x.c
| r2816 | r2817 | |
| 84 | 84 | static int ti99_R9901_3(int offset); |
| 85 | 85 | |
| 86 | 86 | static void ti99_handset_set_ack(int offset, int data); |
| 87 | | static void ti99_handset_task(void); |
| 88 | | static void mecmouse_poll(void); |
| 87 | static void ti99_handset_task(running_machine *machine); |
| 88 | static void mecmouse_poll(running_machine *machine); |
| 89 | 89 | static void ti99_KeyC(int offset, int data); |
| 90 | 90 | static void ti99_AlphaW(int offset, int data); |
| 91 | 91 | |
| r2816 | r2817 | |
| 946 | 946 | { |
| 947 | 947 | TMS9928A_interrupt(machine); |
| 948 | 948 | if (has_handset) |
| 949 | | ti99_handset_task(); |
| 949 | ti99_handset_task(machine); |
| 950 | 950 | has_mecmouse = (input_port_read(machine, "CFG") >> config_mecmouse_bit) & config_mecmouse_mask; |
| 951 | 951 | if (has_mecmouse) |
| 952 | | mecmouse_poll(); |
| 952 | mecmouse_poll(machine); |
| 953 | 953 | } |
| 954 | 954 | |
| 955 | 955 | INTERRUPT_GEN( ti99_4ev_hblank_interrupt ) |
| r2816 | r2817 | |
| 961 | 961 | line_count = 0; |
| 962 | 962 | has_mecmouse = (input_port_read(machine, "CFG") >> config_mecmouse_bit) & config_mecmouse_mask; |
| 963 | 963 | if (has_mecmouse) |
| 964 | | mecmouse_poll(); |
| 964 | mecmouse_poll(machine); |
| 965 | 965 | } |
| 966 | 966 | } |
| 967 | 967 | |
| r2816 | r2817 | |
| 1767 | 1767 | |
| 1768 | 1768 | if (handset_buflen == 0) |
| 1769 | 1769 | /* See if we need to post a new event */ |
| 1770 | | ti99_handset_task(); |
| 1770 | ti99_handset_task(machine); |
| 1771 | 1771 | } |
| 1772 | 1772 | |
| 1773 | 1773 | /* |
| r2816 | r2817 | |
| 1813 | 1813 | |
| 1814 | 1814 | Returns TRUE if the handset state has changed and a message was posted. |
| 1815 | 1815 | */ |
| 1816 | | static int ti99_handset_poll_keyboard(int num) |
| 1816 | static int ti99_handset_poll_keyboard(running_machine *machine, int num) |
| 1817 | 1817 | { |
| 1818 | | running_machine *machine = Machine; |
| 1819 | 1818 | static UINT8 previous_key[max_handsets]; |
| 1820 | 1819 | |
| 1821 | 1820 | UINT32 key_buf; |
| r2816 | r2817 | |
| 1897 | 1896 | |
| 1898 | 1897 | Returns TRUE if the handset state has changed and a message was posted. |
| 1899 | 1898 | */ |
| 1900 | | static int ti99_handset_poll_joystick(int num) |
| 1899 | static int ti99_handset_poll_joystick(running_machine *machine, int num) |
| 1901 | 1900 | { |
| 1902 | 1901 | static UINT8 previous_joy[max_handsets]; |
| 1903 | | running_machine *machine = Machine; |
| 1904 | 1902 | UINT8 current_joy; |
| 1905 | 1903 | int current_joy_x, current_joy_y; |
| 1906 | 1904 | int message; |
| r2816 | r2817 | |
| 1969 | 1967 | |
| 1970 | 1968 | Manage handsets, posting an event if the state of any handset has changed. |
| 1971 | 1969 | */ |
| 1972 | | static void ti99_handset_task(void) |
| 1970 | static void ti99_handset_task(running_machine *machine) |
| 1973 | 1971 | { |
| 1974 | 1972 | int i; |
| 1975 | 1973 | |
| 1976 | 1974 | if (handset_buflen == 0) |
| 1977 | 1975 | { /* poll every handset */ |
| 1978 | 1976 | for (i=0; i<max_handsets; i++) |
| 1979 | | if (ti99_handset_poll_joystick(i)) |
| 1977 | if (ti99_handset_poll_joystick(machine, i)) |
| 1980 | 1978 | return; |
| 1981 | 1979 | for (i=0; i<max_handsets; i++) |
| 1982 | | if (ti99_handset_poll_keyboard(i)) |
| 1980 | if (ti99_handset_poll_keyboard(machine, i)) |
| 1983 | 1981 | return; |
| 1984 | 1982 | } |
| 1985 | 1983 | else if (handset_buflen == 3) |
| 1986 | 1984 | { /* update messages after they have been posted */ |
| 1987 | 1985 | if (handset_buf & 1) |
| 1988 | 1986 | { /* keyboard */ |
| 1989 | | ti99_handset_poll_keyboard((~ (handset_buf >> 1)) & 0x3); |
| 1987 | ti99_handset_poll_keyboard(machine, (~ (handset_buf >> 1)) & 0x3); |
| 1990 | 1988 | } |
| 1991 | 1989 | else |
| 1992 | 1990 | { /* joystick */ |
| 1993 | | ti99_handset_poll_joystick((~ (handset_buf >> 1)) & 0x3); |
| 1991 | ti99_handset_poll_joystick(machine, (~ (handset_buf >> 1)) & 0x3); |
| 1994 | 1992 | } |
| 1995 | 1993 | } |
| 1996 | 1994 | } |
| r2816 | r2817 | |
| 2089 | 2087 | } |
| 2090 | 2088 | } |
| 2091 | 2089 | |
| 2092 | | static void mecmouse_poll(void) |
| 2090 | static void mecmouse_poll(running_machine *machine) |
| 2093 | 2091 | { |
| 2094 | 2092 | static int last_mx = 0, last_my = 0; |
| 2095 | | running_machine *machine = Machine; |
| 2096 | 2093 | int new_mx, new_my; |
| 2097 | 2094 | int delta_x, delta_y; |
| 2098 | 2095 | |
src/mess/machine/kc.c
| r2816 | r2817 | |
| 1 | 1 | /* Core includes */ |
| 2 | 2 | #include "driver.h" |
| 3 | | #include "deprecat.h" |
| 4 | 3 | #include "includes/kc.h" |
| 5 | 4 | |
| 6 | 5 | /* Components */ |
| r2816 | r2817 | |
| 846 | 845 | */ |
| 847 | 846 | |
| 848 | 847 | static kc_keyboard keyboard_data; |
| 849 | | static void kc_keyboard_attempt_transmit(void); |
| 848 | static void kc_keyboard_attempt_transmit(running_machine *machine); |
| 850 | 849 | static TIMER_CALLBACK(kc_keyboard_update); |
| 851 | 850 | |
| 852 | 851 | /* this is called at a regular interval */ |
| r2816 | r2817 | |
| 899 | 898 | |
| 900 | 899 | |
| 901 | 900 | /* initialise keyboard queue */ |
| 902 | | static void kc_keyboard_init(void) |
| 901 | static void kc_keyboard_init(running_machine *machine) |
| 903 | 902 | { |
| 904 | 903 | int i; |
| 905 | 904 | char port[6]; |
| r2816 | r2817 | |
| 928 | 927 | { |
| 929 | 928 | sprintf(port, "KEY%d", i); |
| 930 | 929 | /* read input port */ |
| 931 | | kc_previous_keyboard[i] = input_port_read(Machine, port); |
| 930 | kc_previous_keyboard[i] = input_port_read(machine, port); |
| 932 | 931 | } |
| 933 | 932 | } |
| 934 | 933 | |
| r2816 | r2817 | |
| 969 | 968 | } |
| 970 | 969 | |
| 971 | 970 | |
| 972 | | static void kc_keyboard_begin_transmit(int scan_code) |
| 971 | static void kc_keyboard_begin_transmit(running_machine *machine, int scan_code) |
| 973 | 972 | { |
| 974 | 973 | int i; |
| 975 | 974 | int scan; |
| r2816 | r2817 | |
| 983 | 982 | scan = scan_code; |
| 984 | 983 | |
| 985 | 984 | /* state of shift key */ |
| 986 | | kc_keyboard_add_bit(((input_port_read(Machine, "SHIFT") & 0x01)^0x01)); |
| 985 | kc_keyboard_add_bit(((input_port_read(machine, "SHIFT") & 0x01)^0x01)); |
| 987 | 986 | |
| 988 | 987 | for (i=0; i<6; i++) |
| 989 | 988 | { |
| r2816 | r2817 | |
| 1016 | 1015 | } |
| 1017 | 1016 | |
| 1018 | 1017 | /* attempt to transmit a new keycode to the base unit */ |
| 1019 | | static void kc_keyboard_attempt_transmit(void) |
| 1018 | static void kc_keyboard_attempt_transmit(running_machine *machine) |
| 1020 | 1019 | { |
| 1021 | 1020 | /* is the keyboard transmit is idle */ |
| 1022 | 1021 | if (keyboard_data.transmit_state == KC_KEYBOARD_TRANSMIT_IDLE) |
| r2816 | r2817 | |
| 1034 | 1033 | keyboard_data.head = (keyboard_data.head + 1) % KC_KEYCODE_QUEUE_LENGTH; |
| 1035 | 1034 | |
| 1036 | 1035 | /* setup transmit buffer with scan-code */ |
| 1037 | | kc_keyboard_begin_transmit(code); |
| 1036 | kc_keyboard_begin_transmit(machine, code); |
| 1038 | 1037 | } |
| 1039 | 1038 | } |
| 1040 | 1039 | } |
| r2816 | r2817 | |
| 1087 | 1086 | } |
| 1088 | 1087 | } |
| 1089 | 1088 | |
| 1090 | | kc_keyboard_attempt_transmit(); |
| 1089 | kc_keyboard_attempt_transmit(machine); |
| 1091 | 1090 | } |
| 1092 | 1091 | |
| 1093 | 1092 | /*********************************************************************/ |
| r2816 | r2817 | |
| 1834 | 1833 | kc85_zc2_callback |
| 1835 | 1834 | }; |
| 1836 | 1835 | |
| 1837 | | static void kc85_common_init(void) |
| 1836 | static void kc85_common_init(running_machine *machine) |
| 1838 | 1837 | { |
| 1839 | 1838 | z80pio_init(0, &kc85_pio_intf); |
| 1840 | 1839 | z80ctc_init(0, &kc85_ctc_intf); |
| r2816 | r2817 | |
| 1843 | 1842 | z80pio_reset(0); |
| 1844 | 1843 | |
| 1845 | 1844 | kc_cassette_init(); |
| 1846 | | kc_keyboard_init(); |
| 1845 | kc_keyboard_init(machine); |
| 1847 | 1846 | |
| 1848 | 1847 | /* kc85 has a 50hz input to the ctc channel 2 and 3 */ |
| 1849 | 1848 | /* channel 2 this controls the video colour flash */ |
| r2816 | r2817 | |
| 1873 | 1872 | kc85_4_update_0x0c000(machine); |
| 1874 | 1873 | kc85_4_update_0x0e000(machine); |
| 1875 | 1874 | |
| 1876 | | kc85_common_init(); |
| 1875 | kc85_common_init(machine); |
| 1877 | 1876 | |
| 1878 | 1877 | kc85_4_update_0x00000(machine); |
| 1879 | 1878 | |
| r2816 | r2817 | |
| 1906 | 1905 | kc85_3_update_0x0c000(machine); |
| 1907 | 1906 | kc85_3_update_0x0e000(machine); |
| 1908 | 1907 | |
| 1909 | | kc85_common_init(); |
| 1908 | kc85_common_init(machine); |
| 1910 | 1909 | |
| 1911 | 1910 | kc85_3_update_0x00000(machine); |
| 1912 | 1911 | |
src/mess/drivers/nc.c
| r2816 | r2817 | |
| 338 | 338 | static const write8_machine_func nc_bankhandler_w[]={ |
| 339 | 339 | SMH_BANK5, SMH_BANK6, SMH_BANK7, SMH_BANK8}; |
| 340 | 340 | |
| 341 | | static void nc_refresh_memory_bank_config(int bank) |
| 341 | static void nc_refresh_memory_bank_config(running_machine *machine, int bank) |
| 342 | 342 | { |
| 343 | 343 | int mem_type; |
| 344 | 344 | int mem_bank; |
| r2816 | r2817 | |
| 400 | 400 | memory_set_bankptr(bank+1, addr); |
| 401 | 401 | |
| 402 | 402 | /* write enabled? */ |
| 403 | | if (input_port_read(Machine, "EXTRA") & 0x02) |
| 403 | if (input_port_read(machine, "EXTRA") & 0x02) |
| 404 | 404 | { |
| 405 | 405 | /* yes */ |
| 406 | 406 | memory_set_bankptr(bank+5, addr); |
| r2816 | r2817 | |
| 425 | 425 | break; |
| 426 | 426 | } |
| 427 | 427 | |
| 428 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, |
| 428 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, |
| 429 | 429 | (bank * 0x4000), (bank * 0x4000) + 0x3fff, 0, 0, read_handler); |
| 430 | 430 | |
| 431 | 431 | if (write_handler) |
| 432 | 432 | { |
| 433 | | memory_install_write8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, |
| 433 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, |
| 434 | 434 | (bank * 0x4000), (bank * 0x4000) + 0x3fff, 0, 0, write_handler); |
| 435 | 435 | } |
| 436 | 436 | } |
| 437 | 437 | |
| 438 | | static void nc_refresh_memory_config(void) |
| 438 | static void nc_refresh_memory_config(running_machine *machine) |
| 439 | 439 | { |
| 440 | | nc_refresh_memory_bank_config(0); |
| 441 | | nc_refresh_memory_bank_config(1); |
| 442 | | nc_refresh_memory_bank_config(2); |
| 443 | | nc_refresh_memory_bank_config(3); |
| 440 | nc_refresh_memory_bank_config(machine, 0); |
| 441 | nc_refresh_memory_bank_config(machine, 1); |
| 442 | nc_refresh_memory_bank_config(machine, 2); |
| 443 | nc_refresh_memory_bank_config(machine, 3); |
| 444 | 444 | } |
| 445 | 445 | |
| 446 | 446 | |
| r2816 | r2817 | |
| 552 | 552 | if (changed_bits & 0x02) |
| 553 | 553 | { |
| 554 | 554 | /* yes refresh memory config */ |
| 555 | | nc_refresh_memory_config(); |
| 555 | nc_refresh_memory_config(machine); |
| 556 | 556 | } |
| 557 | 557 | |
| 558 | 558 | previous_inputport_10_state = inputport_10_state; |
| r2816 | r2817 | |
| 588 | 588 | /* at reset set to 1 */ |
| 589 | 589 | nc_poweroff_control = 1; |
| 590 | 590 | |
| 591 | | nc_refresh_memory_config(); |
| 591 | nc_refresh_memory_config(machine); |
| 592 | 592 | nc_update_interrupts(machine); |
| 593 | 593 | |
| 594 | 594 | /* keyboard timer */ |
| r2816 | r2817 | |
| 623 | 623 | LOG(("Memory management W: %02x %02x\n",offset,data)); |
| 624 | 624 | nc_memory_config[offset] = data; |
| 625 | 625 | |
| 626 | | nc_refresh_memory_config(); |
| 626 | nc_refresh_memory_config(machine); |
| 627 | 627 | } |
| 628 | 628 | |
| 629 | 629 | static WRITE8_HANDLER(nc_irq_mask_w) |
src/mess/drivers/pcw16.c
| r2816 | r2817 | |
| 374 | 374 | return 0x0ff; |
| 375 | 375 | } |
| 376 | 376 | |
| 377 | | static void pcw16_set_bank_handlers(int bank, PCW16_RAM_TYPE type) |
| 377 | static void pcw16_set_bank_handlers(running_machine *machine, int bank, PCW16_RAM_TYPE type) |
| 378 | 378 | { |
| 379 | 379 | read8_machine_func read_handler; |
| 380 | 380 | write8_machine_func write_handler; |
| r2816 | r2817 | |
| 410 | 410 | break; |
| 411 | 411 | } |
| 412 | 412 | |
| 413 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, |
| 413 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, |
| 414 | 414 | (bank * 0x4000), (bank * 0x4000) + 0x3fff, 0, 0, read_handler); |
| 415 | | memory_install_write8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, |
| 415 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, |
| 416 | 416 | (bank * 0x4000), (bank * 0x4000) + 0x3fff, 0, 0, write_handler); |
| 417 | 417 | } |
| 418 | 418 | |
| r2816 | r2817 | |
| 469 | 469 | if (bank_id<4) |
| 470 | 470 | { |
| 471 | 471 | /* rom */ |
| 472 | | pcw16_set_bank_handlers(bank, PCW16_MEM_ROM); |
| 472 | pcw16_set_bank_handlers(machine, bank, PCW16_MEM_ROM); |
| 473 | 473 | } |
| 474 | 474 | else |
| 475 | 475 | { |
| r2816 | r2817 | |
| 477 | 477 | 64-128 are for flash-rom 1 */ |
| 478 | 478 | if ((bank_id & 0x040)==0) |
| 479 | 479 | { |
| 480 | | pcw16_set_bank_handlers(bank, PCW16_MEM_FLASH_1); |
| 480 | pcw16_set_bank_handlers(machine, bank, PCW16_MEM_FLASH_1); |
| 481 | 481 | } |
| 482 | 482 | else |
| 483 | 483 | { |
| 484 | | pcw16_set_bank_handlers(bank, PCW16_MEM_FLASH_2); |
| 484 | pcw16_set_bank_handlers(machine, bank, PCW16_MEM_FLASH_2); |
| 485 | 485 | } |
| 486 | 486 | } |
| 487 | 487 | } |
| 488 | 488 | else |
| 489 | 489 | { |
| 490 | | pcw16_set_bank_handlers(bank, PCW16_MEM_DRAM); |
| 490 | pcw16_set_bank_handlers(machine, bank, PCW16_MEM_DRAM); |
| 491 | 491 | } |
| 492 | 492 | } |
| 493 | 493 | |
| r2816 | r2817 | |
| 1252 | 1252 | new_inputs = 0; |
| 1253 | 1253 | |
| 1254 | 1254 | /* Power switch is connected to Ring indicator */ |
| 1255 | | if (input_port_read(Machine, "EXTRA") & 0x040) |
| 1255 | if (input_port_read(device->machine, "EXTRA") & 0x040) |
| 1256 | 1256 | { |
| 1257 | 1257 | new_inputs = UART8250_INPUTS_RING_INDICATOR; |
| 1258 | 1258 | } |
src/mess/drivers/pcw.c
| r2816 | r2817 | |
| 258 | 258 | * PCW Banking |
| 259 | 259 | * ----------------------------------------------------------------------- */ |
| 260 | 260 | |
| 261 | | static void pcw_update_read_memory_block(int block, int bank) |
| 261 | static void pcw_update_read_memory_block(running_machine *machine, int block, int bank) |
| 262 | 262 | { |
| 263 | 263 | memory_set_bankptr(block + 1, mess_ram + ((bank * 0x4000) % mess_ram_size)); |
| 264 | 264 | |
| r2816 | r2817 | |
| 267 | 267 | { |
| 268 | 268 | /* when upper 16 bytes are accessed use keyboard read |
| 269 | 269 | handler */ |
| 270 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, |
| 270 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, |
| 271 | 271 | block * 0x04000 + 0x3ff0, block * 0x04000 + 0x3fff, 0, 0, |
| 272 | 272 | pcw_keyboard_r); |
| 273 | 273 | } |
| 274 | 274 | else |
| 275 | 275 | { |
| 276 | 276 | /* restore bank handler across entire block */ |
| 277 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, |
| 277 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, |
| 278 | 278 | block * 0x04000 + 0x0000, block * 0x04000 + 0x3fff, 0, 0, |
| 279 | 279 | (read8_machine_func) (STATIC_BANK1 + (FPTR)block)); |
| 280 | 280 | } |
| r2816 | r2817 | |
| 293 | 293 | /* &F4 O b7-b4: when set, force memory reads to access the same bank as |
| 294 | 294 | writes for &C000, &0000, &8000, and &4000 respectively */ |
| 295 | 295 | |
| 296 | | static void pcw_update_mem(int block, int data) |
| 296 | static void pcw_update_mem(running_machine *machine, int block, int data) |
| 297 | 297 | { |
| 298 | 298 | /* expansion ram select. |
| 299 | 299 | if block is 0-7, selects internal ram instead for read/write |
| r2816 | r2817 | |
| 305 | 305 | /* same bank for reading and writing */ |
| 306 | 306 | bank = data & 0x7f; |
| 307 | 307 | |
| 308 | | pcw_update_read_memory_block(block, bank); |
| 308 | pcw_update_read_memory_block(machine, block, bank); |
| 309 | 309 | pcw_update_write_memory_block(block, bank); |
| 310 | 310 | } |
| 311 | 311 | else |
| r2816 | r2817 | |
| 351 | 351 | read_bank = (data>>4) & 0x07; |
| 352 | 352 | } |
| 353 | 353 | |
| 354 | | pcw_update_read_memory_block(block, read_bank); |
| 354 | pcw_update_read_memory_block(machine, block, read_bank); |
| 355 | 355 | |
| 356 | 356 | write_bank = data & 0x07; |
| 357 | 357 | pcw_update_write_memory_block(block, write_bank); |
| r2816 | r2817 | |
| 369 | 369 | } |
| 370 | 370 | |
| 371 | 371 | /* from Jacob Nevins docs */ |
| 372 | | static int pcw_get_sys_status(void) |
| 372 | static int pcw_get_sys_status(running_machine *machine) |
| 373 | 373 | { |
| 374 | | return pcw_interrupt_counter | (input_port_read(Machine, "EXTRA") & (0x040 | 0x010)) | pcw_system_status; |
| 374 | return pcw_interrupt_counter | (input_port_read(machine, "EXTRA") & (0x040 | 0x010)) | pcw_system_status; |
| 375 | 375 | } |
| 376 | 376 | |
| 377 | 377 | static READ8_HANDLER(pcw_interrupt_counter_r) |
| r2816 | r2817 | |
| 381 | 381 | /* from Jacob Nevins docs */ |
| 382 | 382 | |
| 383 | 383 | /* get data */ |
| 384 | | data = pcw_get_sys_status(); |
| 384 | data = pcw_get_sys_status(machine); |
| 385 | 385 | /* clear int counter */ |
| 386 | 386 | pcw_interrupt_counter = 0; |
| 387 | 387 | /* update interrupt */ |
| r2816 | r2817 | |
| 396 | 396 | LOG(("BANK: %2x %x\n",offset, data)); |
| 397 | 397 | pcw_banks[offset] = data; |
| 398 | 398 | |
| 399 | | pcw_update_mem(offset, data); |
| 399 | pcw_update_mem(machine, offset, data); |
| 400 | 400 | } |
| 401 | 401 | |
| 402 | 402 | static WRITE8_HANDLER(pcw_bank_force_selection_w) |
| 403 | 403 | { |
| 404 | 404 | pcw_bank_force = data; |
| 405 | 405 | |
| 406 | | pcw_update_mem(0, pcw_banks[0]); |
| 407 | | pcw_update_mem(1, pcw_banks[1]); |
| 408 | | pcw_update_mem(2, pcw_banks[2]); |
| 409 | | pcw_update_mem(3, pcw_banks[3]); |
| 406 | pcw_update_mem(machine, 0, pcw_banks[0]); |
| 407 | pcw_update_mem(machine, 1, pcw_banks[1]); |
| 408 | pcw_update_mem(machine, 2, pcw_banks[2]); |
| 409 | pcw_update_mem(machine, 3, pcw_banks[3]); |
| 410 | 410 | } |
| 411 | 411 | |
| 412 | 412 | |
| r2816 | r2817 | |
| 439 | 439 | case 0: |
| 440 | 440 | { |
| 441 | 441 | pcw_boot = 0; |
| 442 | | pcw_update_mem(0, pcw_banks[0]); |
| 442 | pcw_update_mem(machine, 0, pcw_banks[0]); |
| 443 | 443 | } |
| 444 | 444 | break; |
| 445 | 445 | |
| r2816 | r2817 | |
| 579 | 579 | } |
| 580 | 580 | } |
| 581 | 581 | |
| 582 | | static READ8_HANDLER(pcw_system_status_r) |
| 582 | static READ8_HANDLER(pcw_system_status_r) |
| 583 | 583 | { |
| 584 | 584 | /* from Jacob Nevins docs */ |
| 585 | | return pcw_get_sys_status(); |
| 585 | return pcw_get_sys_status(machine); |
| 586 | 586 | } |
| 587 | 587 | |
| 588 | 588 | /* read from expansion hardware - additional hardware not part of |
| r2816 | r2817 | |
| 763 | 763 | pcw_banks[2] = 2; |
| 764 | 764 | pcw_banks[3] = 3; |
| 765 | 765 | |
| 766 | | pcw_update_mem(0, pcw_banks[0]); |
| 767 | | pcw_update_mem(1, pcw_banks[1]); |
| 768 | | pcw_update_mem(2, pcw_banks[2]); |
| 769 | | pcw_update_mem(3, pcw_banks[3]); |
| 766 | pcw_update_mem(machine, 0, pcw_banks[0]); |
| 767 | pcw_update_mem(machine, 1, pcw_banks[1]); |
| 768 | pcw_update_mem(machine, 2, pcw_banks[2]); |
| 769 | pcw_update_mem(machine, 3, pcw_banks[3]); |
| 770 | 770 | |
| 771 | 771 | /* lower 4 bits are interrupt counter */ |
| 772 | 772 | pcw_system_status = 0x000; |
src/mess/drivers/avigo.c
| r2816 | r2817 | |
| 94 | 94 | } |
| 95 | 95 | } |
| 96 | 96 | |
| 97 | | static void avigo_setbank(int bank, void *address, read8_machine_func rh, write8_machine_func wh) |
| 97 | static void avigo_setbank(running_machine *machine, int bank, void *address, read8_machine_func rh, write8_machine_func wh) |
| 98 | 98 | { |
| 99 | 99 | if (address) |
| 100 | 100 | { |
| r2816 | r2817 | |
| 104 | 104 | } |
| 105 | 105 | if (rh) |
| 106 | 106 | { |
| 107 | | memory_install_read8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, (bank * 0x4000), |
| 107 | memory_install_read8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, (bank * 0x4000), |
| 108 | 108 | (bank * 0x4000) + 0x3FFF, 0, 0, rh); |
| 109 | 109 | } |
| 110 | 110 | if (wh) |
| 111 | 111 | { |
| 112 | | memory_install_write8_handler(Machine, 0, ADDRESS_SPACE_PROGRAM, (bank * 0x4000), |
| 112 | memory_install_write8_handler(machine, 0, ADDRESS_SPACE_PROGRAM, (bank * 0x4000), |
| 113 | 113 | (bank * 0x4000) + 0x3FFF, 0, 0, wh); |
| 114 | 114 | } |
| 115 | 115 | } |
| r2816 | r2817 | |
| 292 | 292 | avigo_tc8521_alarm_int |
| 293 | 293 | }; |
| 294 | 294 | |
| 295 | | static void avigo_refresh_memory(void) |
| 295 | static void avigo_refresh_memory(running_machine *machine) |
| 296 | 296 | { |
| 297 | 297 | unsigned char *addr; |
| 298 | 298 | |
| r2816 | r2817 | |
| 319 | 319 | |
| 320 | 320 | addr = (unsigned char *)intelflash_getmemptr(avigo_flash_at_0x4000); |
| 321 | 321 | addr = addr + (avigo_rom_bank_l<<14); |
| 322 | | avigo_setbank(1, addr, avigo_flash_0x4000_read_handler, avigo_flash_0x4000_write_handler); |
| 322 | avigo_setbank(machine, 1, addr, avigo_flash_0x4000_read_handler, avigo_flash_0x4000_write_handler); |
| 323 | 323 | |
| 324 | 324 | switch (avigo_ram_bank_h) |
| 325 | 325 | { |
| 326 | 326 | /* %101 */ |
| 327 | 327 | /* screen */ |
| 328 | 328 | case 0x06: |
| 329 | | avigo_setbank(2, NULL, avigo_vid_memory_r, avigo_vid_memory_w); |
| 329 | avigo_setbank(machine, 2, NULL, avigo_vid_memory_r, avigo_vid_memory_w); |
| 330 | 330 | break; |
| 331 | 331 | |
| 332 | 332 | /* %001 */ |
| 333 | 333 | /* ram */ |
| 334 | 334 | case 0x01: |
| 335 | 335 | addr = mess_ram + ((avigo_ram_bank_l & 0x07)<<14); |
| 336 | | avigo_setbank(2, addr, SMH_BANK3, SMH_BANK7); |
| 336 | avigo_setbank(machine, 2, addr, SMH_BANK3, SMH_BANK7); |
| 337 | 337 | break; |
| 338 | 338 | |
| 339 | 339 | /* %111 */ |
| r2816 | r2817 | |
| 343 | 343 | |
| 344 | 344 | addr = (unsigned char *)intelflash_getmemptr(avigo_flash_at_0x8000); |
| 345 | 345 | addr = addr + (avigo_ram_bank_l<<14); |
| 346 | | avigo_setbank(2, addr, avigo_flash_0x8000_read_handler, |
| 346 | avigo_setbank(machine, 2, addr, avigo_flash_0x8000_read_handler, |
| 347 | 347 | SMH_NOP /* avigo_flash_0x8000_write_handler */); |
| 348 | 348 | break; |
| 349 | 349 | |
| r2816 | r2817 | |
| 352 | 352 | |
| 353 | 353 | addr = (unsigned char *)intelflash_getmemptr(avigo_flash_at_0x8000); |
| 354 | 354 | addr = addr + (avigo_ram_bank_l<<14); |
| 355 | | avigo_setbank(2, addr, avigo_flash_0x8000_read_handler, |
| 355 | avigo_setbank(machine, 2, addr, avigo_flash_0x8000_read_handler, |
| 356 | 356 | SMH_NOP /* avigo_flash_0x8000_write_handler */); |
| 357 | 357 | break; |
| 358 | 358 | } |
| r2816 | r2817 | |
| 371 | 371 | avigo_irq |= (1<<3); |
| 372 | 372 | } |
| 373 | 373 | |
| 374 | | avigo_refresh_ints(Machine); |
| 374 | avigo_refresh_ints(device->machine); |
| 375 | 375 | } |
| 376 | 376 | |
| 377 | 377 | |
| r2816 | r2817 | |
| 442 | 442 | memory_set_opbase_handler(0, avigo_opbase_handler); |
| 443 | 443 | |
| 444 | 444 | addr = (unsigned char *)intelflash_getmemptr(0); |
| 445 | | avigo_setbank(0, addr, avigo_flash_0x0000_read_handler, avigo_flash_0x0000_write_handler); |
| 445 | avigo_setbank(machine, 0, addr, avigo_flash_0x0000_read_handler, avigo_flash_0x0000_write_handler); |
| 446 | 446 | |
| 447 | | avigo_setbank(3, mess_ram, NULL, NULL); |
| 447 | avigo_setbank(machine, 3, mess_ram, NULL, NULL); |
| 448 | 448 | |
| 449 | 449 | /* 0x08000 is specially banked! */ |
| 450 | | avigo_refresh_memory(); |
| 450 | avigo_refresh_memory(machine); |
| 451 | 451 | } |
| 452 | 452 | |
| 453 | 453 | static MACHINE_START( avigo ) |
| r2816 | r2817 | |
| 544 | 544 | |
| 545 | 545 | avigo_rom_bank_l = data & 0x03f; |
| 546 | 546 | |
| 547 | | avigo_refresh_memory(); |
| 547 | avigo_refresh_memory(machine); |
| 548 | 548 | } |
| 549 | 549 | |
| 550 | 550 | static WRITE8_HANDLER(avigo_rom_bank_h_w) |
| r2816 | r2817 | |
| 564 | 564 | avigo_rom_bank_h = data; |
| 565 | 565 | |
| 566 | 566 | |
| 567 | | avigo_refresh_memory(); |
| 567 | avigo_refresh_memory(machine); |
| 568 | 568 | } |
| 569 | 569 | |
| 570 | 570 | static WRITE8_HANDLER(avigo_ram_bank_l_w) |
| r2816 | r2817 | |
| 573 | 573 | |
| 574 | 574 | avigo_ram_bank_l = data & 0x03f; |
| 575 | 575 | |
| 576 | | avigo_refresh_memory(); |
| 576 | avigo_refresh_memory(machine); |
| 577 | 577 | } |
| 578 | 578 | |
| 579 | 579 | static WRITE8_HANDLER(avigo_ram_bank_h_w) |
| r2816 | r2817 | |
| 582 | 582 | |
| 583 | 583 | avigo_ram_bank_h = data; |
| 584 | 584 | |
| 585 | | avigo_refresh_memory(); |
| 585 | avigo_refresh_memory(machine); |
| 586 | 586 | } |
| 587 | 587 | |
| 588 | 588 | static READ8_HANDLER(avigo_ad_control_status_r) |