src/mess/machine/bebox.c
| r4569 | r4570 | |
| 195 | 195 | result = bebox_crossproc_interrupts; |
| 196 | 196 | |
| 197 | 197 | /* return a different result depending on which CPU is accessing this handler */ |
| 198 | | if (space != cpu_get_address_space(space->machine->cpu[0], ADDRESS_SPACE_PROGRAM)) |
| 198 | if (space != cputag_get_address_space(space->machine, "ppc1", ADDRESS_SPACE_PROGRAM)) |
| 199 | 199 | result |= 0x02000000; |
| 200 | 200 | else |
| 201 | 201 | result &= ~0x02000000; |
| r4569 | r4570 | |
| 220 | 220 | }; |
| 221 | 221 | int i, line; |
| 222 | 222 | UINT32 old_crossproc_interrupts = bebox_crossproc_interrupts; |
| 223 | static const char *const cputags[] = { "ppc1", "ppc2" }; |
| 223 | 224 | |
| 224 | 225 | bebox_mbreg32_w(&bebox_crossproc_interrupts, data, mem_mask); |
| 225 | 226 | |
| r4569 | r4570 | |
| 241 | 242 | */ |
| 242 | 243 | } |
| 243 | 244 | |
| 244 | | cpu_set_input_line(space->machine->cpu[crossproc_map[i].cpunum], crossproc_map[i].inputline, line); |
| 245 | cputag_set_input_line(space->machine, cputags[crossproc_map[i].cpunum], crossproc_map[i].inputline, line); |
| 245 | 246 | } |
| 246 | 247 | } |
| 247 | 248 | } |
| r4569 | r4570 | |
| 252 | 253 | |
| 253 | 254 | if (b & 0x20) |
| 254 | 255 | { |
| 255 | | cpu_set_input_line( space->machine->cpu[1], INPUT_LINE_RESET, (b & 0x80) ? CLEAR_LINE : ASSERT_LINE); |
| 256 | cputag_set_input_line(space->machine, "ppc2", INPUT_LINE_RESET, (b & 0x80) ? CLEAR_LINE : ASSERT_LINE); |
| 256 | 257 | } |
| 257 | 258 | } |
| 258 | 259 | |
| r4569 | r4570 | |
| 261 | 262 | { |
| 262 | 263 | int cpunum; |
| 263 | 264 | UINT32 interrupt; |
| 265 | static const char *const cputags[] = { "ppc1", "ppc2" }; |
| 264 | 266 | |
| 265 | 267 | for (cpunum = 0; cpunum < 2; cpunum++) |
| 266 | 268 | { |
| r4569 | r4570 | |
| 272 | 274 | bebox_interrupts, bebox_cpu_imask[cpunum], interrupt ? "on" : "off"); |
| 273 | 275 | } |
| 274 | 276 | |
| 275 | | cpu_set_input_line(machine->cpu[cpunum], INPUT_LINE_IRQ0, interrupt ? ASSERT_LINE : CLEAR_LINE); |
| 277 | cputag_set_input_line(machine, cputags[cpunum], INPUT_LINE_IRQ0, interrupt ? ASSERT_LINE : CLEAR_LINE); |
| 276 | 278 | } |
| 277 | 279 | } |
| 278 | 280 | |
| r4569 | r4570 | |
| 322 | 324 | assert_always((interrupt_bit < ARRAY_LENGTH(interrupt_names)) && (interrupt_names[interrupt_bit] != NULL), "Raising invalid interrupt"); |
| 323 | 325 | |
| 324 | 326 | logerror("bebox_set_irq_bit(): pc[0]=0x%08x pc[1]=0x%08x %s interrupt #%u (%s)\n", |
| 325 | | (unsigned) cpu_get_reg( machine->cpu[0], REG_GENPC), |
| 326 | | (unsigned) cpu_get_reg( machine->cpu[1], REG_GENPC), |
| 327 | (unsigned) cpu_get_reg(cputag_get_cpu(machine, "ppc1"), REG_GENPC), |
| 328 | (unsigned) cpu_get_reg(cputag_get_cpu(machine, "ppc2"), REG_GENPC), |
| 327 | 329 | val ? "Asserting" : "Clearing", |
| 328 | 330 | interrupt_bit, interrupt_names[interrupt_bit]); |
| 329 | 331 | } |
| r4569 | r4570 | |
| 586 | 588 | |
| 587 | 589 | static void bebox_map_vga_memory(running_machine *machine, offs_t begin, offs_t end, read8_space_func rh, write8_space_func wh) |
| 588 | 590 | { |
| 589 | | const address_space *space = cpu_get_address_space( machine->cpu[0], ADDRESS_SPACE_PROGRAM ); |
| 591 | const address_space *space = cputag_get_address_space(machine, "ppc1", ADDRESS_SPACE_PROGRAM); |
| 590 | 592 | |
| 591 | 593 | read64_space_func rh64 = (rh == SMH_BANK4) ? SMH_BANK4 : bebox_vga_memory_r; |
| 592 | 594 | write64_space_func wh64 = (wh == SMH_BANK4) ? SMH_BANK4 : bebox_vga_memory_w; |
| r4569 | r4570 | |
| 722 | 724 | |
| 723 | 725 | static DMA8237_MEM_READ( bebox_dma_read_byte ) |
| 724 | 726 | { |
| 725 | | const address_space *space = cpu_get_address_space( device->machine->cpu[0], ADDRESS_SPACE_PROGRAM ); |
| 727 | const address_space *space = cputag_get_address_space(device->machine, "ppc1", ADDRESS_SPACE_PROGRAM); |
| 726 | 728 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 727 | 729 | & 0x7FFF0000; |
| 728 | 730 | return memory_read_byte(space, page_offset + offset); |
| r4569 | r4570 | |
| 731 | 733 | |
| 732 | 734 | static DMA8237_MEM_WRITE( bebox_dma_write_byte ) |
| 733 | 735 | { |
| 734 | | const address_space *space = cpu_get_address_space( device->machine->cpu[0], ADDRESS_SPACE_PROGRAM ); |
| 736 | const address_space *space = cputag_get_address_space(device->machine, "ppc1", ADDRESS_SPACE_PROGRAM); |
| 735 | 737 | offs_t page_offset = (((offs_t) dma_offset[0][channel]) << 16) |
| 736 | 738 | & 0x7FFF0000; |
| 737 | 739 | memory_write_byte(space, page_offset + offset, data); |
| r4569 | r4570 | |
| 952 | 954 | static UINT32 scsi53c810_fetch(running_machine *machine, UINT32 dsp) |
| 953 | 955 | { |
| 954 | 956 | UINT32 result; |
| 955 | | result = memory_read_dword_64be( cpu_get_address_space( machine->cpu[0], ADDRESS_SPACE_PROGRAM ), dsp & 0x7FFFFFFF); |
| 957 | result = memory_read_dword_64be(cputag_get_address_space(machine, "ppc1", ADDRESS_SPACE_PROGRAM), dsp & 0x7FFFFFFF); |
| 956 | 958 | return BYTE_REVERSE32(result); |
| 957 | 959 | } |
| 958 | 960 | |
| r4569 | r4570 | |
| 1018 | 1020 | /* brutal ugly hack; at some point the PCI code should be handling this stuff */ |
| 1019 | 1021 | if (scsi53c810_data[5] != 0xFFFFFFF0) |
| 1020 | 1022 | { |
| 1021 | | const address_space *space = cpu_get_address_space( device->machine->cpu[0], ADDRESS_SPACE_PROGRAM ); |
| 1023 | const address_space *space = cputag_get_address_space(device->machine, "ppc1", ADDRESS_SPACE_PROGRAM); |
| 1022 | 1024 | |
| 1023 | 1025 | addr = (scsi53c810_data[5] | 0xC0000000) & ~0xFF; |
| 1024 | 1026 | memory_install_read64_handler(space, addr, addr + 0xFF, 0, 0, scsi53c810_r); |
| r4569 | r4570 | |
| 1077 | 1079 | |
| 1078 | 1080 | timer_set(machine, attotime_zero, NULL, 0, bebox_get_devices ); |
| 1079 | 1081 | |
| 1080 | | cpu_set_input_line(machine->cpu[0], INPUT_LINE_RESET, CLEAR_LINE); |
| 1081 | | cpu_set_input_line(machine->cpu[1], INPUT_LINE_RESET, ASSERT_LINE); |
| 1082 | cputag_set_input_line(machine, "ppc1", INPUT_LINE_RESET, CLEAR_LINE); |
| 1083 | cputag_set_input_line(machine, "ppc2", INPUT_LINE_RESET, ASSERT_LINE); |
| 1082 | 1084 | } |
| 1083 | 1085 | |
| 1084 | 1086 | static void bebox_exit(running_machine *machine) |
| r4569 | r4570 | |
| 1096 | 1098 | |
| 1097 | 1099 | DRIVER_INIT( bebox ) |
| 1098 | 1100 | { |
| 1099 | | const address_space *space_0 = cpu_get_address_space( machine->cpu[0], ADDRESS_SPACE_PROGRAM ); |
| 1100 | | const address_space *space_1 = cpu_get_address_space( machine->cpu[1], ADDRESS_SPACE_PROGRAM ); |
| 1101 | const address_space *space_0 = cputag_get_address_space(machine, "ppc1", ADDRESS_SPACE_PROGRAM); |
| 1102 | const address_space *space_1 = cputag_get_address_space(machine, "ppc2", ADDRESS_SPACE_PROGRAM); |
| 1101 | 1103 | offs_t vram_begin; |
| 1102 | 1104 | offs_t vram_end; |
| 1103 | 1105 | |
src/mess/machine/bbc.c
| r4569 | r4570 | |
| 85 | 85 | bbc_rombank=data&0x0f; |
| 86 | 86 | if (bbc_rombank!=1) |
| 87 | 87 | { |
| 88 | | memory_set_bankptr(space->machine, 4,memory_region(space->machine, "user1")+(bbc_rombank<<14)); |
| 89 | | } else { |
| 90 | | memory_set_bankptr(space->machine, 4,memory_region(space->machine, "user2")+((bbc_DFSType)<<14)); |
| 88 | memory_set_bankptr(space->machine, 4, memory_region(space->machine, "user1") + (bbc_rombank << 14)); |
| 89 | } |
| 90 | else |
| 91 | { |
| 92 | memory_set_bankptr(space->machine, 4, memory_region(space->machine, "user2") + ((bbc_DFSType) << 14)); |
| 91 | 93 | } |
| 92 | 94 | } |
| 93 | 95 | |
| 94 | 96 | |
| 95 | 97 | WRITE8_HANDLER ( bbc_memoryb3_w ) |
| 96 | 98 | { |
| 97 | | if (bbc_RAMSize) { |
| 98 | | memory_region(space->machine, "maincpu")[offset+0x4000]=data; |
| 99 | if (bbc_RAMSize) |
| 100 | { |
| 101 | memory_region(space->machine, "maincpu")[offset + 0x4000] = data; |
| 99 | 102 | // this array is set so that the video emulator know which addresses to redraw |
| 100 | | bbc_vidmem[offset+0x4000]=1; |
| 101 | | } else { |
| 102 | | memory_region(space->machine, "maincpu")[offset]=data; |
| 103 | | bbc_vidmem[offset]=1; |
| 103 | bbc_vidmem[offset + 0x4000] = 1; |
| 104 | } |
| 105 | else |
| 106 | { |
| 107 | memory_region(space->machine, "maincpu")[offset] = data; |
| 108 | bbc_vidmem[offset] = 1; |
| 104 | 109 | } |
| 105 | 110 | |
| 106 | 111 | } |
| r4569 | r4570 | |
| 117 | 122 | |
| 118 | 123 | WRITE8_HANDLER ( bbc_memoryb4_w ) |
| 119 | 124 | { |
| 120 | | if (bbc_rombank==1) |
| 125 | if (bbc_rombank == 1) |
| 121 | 126 | { |
| 122 | 127 | // special DFS case for Acorn DFS E00 Hack that can write to the DFS RAM Bank; |
| 123 | | if (bbc_DFSType==3) memory_region(space->machine, "user2")[((bbc_DFSType)<<14)+offset]=data; |
| 128 | if (bbc_DFSType == 3) memory_region(space->machine, "user2")[((bbc_DFSType) << 14) + offset] = data; |
| 124 | 129 | } else |
| 125 | 130 | { |
| 126 | | switch (bbc_SWRAMtype) { |
| 127 | | case 1: if (bbc_SWRAMtype1[bbc_userport]) memory_region(space->machine, "user1")[(bbc_userport<<14)+offset]=data; |
| 128 | | case 2: if (bbc_SWRAMtype2[bbc_rombank]) memory_region(space->machine, "user1")[(bbc_rombank<<14)+offset]=data; |
| 129 | | case 3: if (bbc_SWRAMtype3[bbc_rombank]) memory_region(space->machine, "user1")[(bbc_rombank<<14)+offset]=data; |
| 131 | switch (bbc_SWRAMtype) |
| 132 | { |
| 133 | case 1: if (bbc_SWRAMtype1[bbc_userport]) memory_region(space->machine, "user1")[(bbc_userport << 14) + offset] = data; |
| 134 | case 2: if (bbc_SWRAMtype2[bbc_rombank]) memory_region(space->machine, "user1")[(bbc_rombank << 14) + offset] = data; |
| 135 | case 3: if (bbc_SWRAMtype3[bbc_rombank]) memory_region(space->machine, "user1")[(bbc_rombank << 14) + offset] = data; |
| 130 | 136 | } |
| 131 | 137 | } |
| 132 | 138 | } |
| r4569 | r4570 | |
| 135 | 141 | /* BBC B Plus memory handling function */ |
| 136 | 142 | /****************************************/ |
| 137 | 143 | |
| 138 | | static int pagedRAM=0; |
| 139 | | static int vdusel=0; |
| 144 | static int pagedRAM = 0; |
| 145 | static int vdusel = 0; |
| 140 | 146 | |
| 141 | 147 | /* this function should return true if |
| 142 | 148 | the instruction is in the VDU driver address ranged |
| r4569 | r4570 | |
| 147 | 153 | static int vdudriverset(running_machine *machine) |
| 148 | 154 | { |
| 149 | 155 | int PC; |
| 150 | | PC=cpu_get_pc( machine->cpu[0] ); // this needs to be set to the 6502 program counter |
| 151 | | return (((PC>=0xc000) && (PC<=0xdfff)) || ((pagedRAM) && ((PC>=0xa000) && (PC<=0xafff)))); |
| 156 | PC = cpu_get_pc(cputag_get_cpu(machine, "maincpu")); // this needs to be set to the 6502 program counter |
| 157 | return (((PC >= 0xc000) && (PC <= 0xdfff)) || ((pagedRAM) && ((PC >= 0xa000) && (PC <= 0xafff)))); |
| 152 | 158 | } |
| 153 | 159 | |
| 154 | 160 | |
| r4569 | r4570 | |
| 158 | 164 | { |
| 159 | 165 | if ((offset&0x04)==0) |
| 160 | 166 | { |
| 161 | | pagedRAM =(data>>7)&0x01; |
| 162 | | bbc_rombank= data &0x0f; |
| 167 | pagedRAM = (data >> 7) & 0x01; |
| 168 | bbc_rombank = data & 0x0f; |
| 163 | 169 | |
| 164 | 170 | if (pagedRAM) |
| 165 | 171 | { |
| 166 | 172 | /* if paged ram then set 8000 to afff to read from the ram 8000 to afff */ |
| 167 | | memory_set_bankptr(space->machine, 4,memory_region(space->machine, "maincpu")+0x8000); |
| 168 | | } else { |
| 173 | memory_set_bankptr(space->machine, 4, memory_region(space->machine, "maincpu") + 0x8000); |
| 174 | } |
| 175 | else |
| 176 | { |
| 169 | 177 | /* if paged rom then set the rom to be read from 8000 to afff */ |
| 170 | | memory_set_bankptr(space->machine, 4,memory_region(space->machine, "user1")+(bbc_rombank<<14)); |
| 178 | memory_set_bankptr(space->machine, 4, memory_region(space->machine, "user1") + (bbc_rombank << 14)); |
| 171 | 179 | }; |
| 172 | 180 | |
| 173 | 181 | /* set the rom to be read from b000 to bfff */ |
| r4569 | r4570 | |
| 213 | 221 | static DIRECT_UPDATE_HANDLER( bbcbp_direct_handler ) |
| 214 | 222 | { |
| 215 | 223 | UINT8 *ram = memory_region(space->machine, "maincpu"); |
| 216 | | if (vdusel==0) |
| 224 | if (vdusel == 0) |
| 217 | 225 | { |
| 218 | 226 | // not in shadow ram mode so just read normal ram |
| 219 | | memory_set_bankptr(space->machine, 2, ram+0x3000); |
| 220 | | } else { |
| 227 | memory_set_bankptr(space->machine, 2, ram + 0x3000); |
| 228 | } |
| 229 | else |
| 230 | { |
| 221 | 231 | if (vdudriverset(space->machine)) |
| 222 | 232 | { |
| 223 | 233 | // if VDUDriver set then read from shadow ram |
| 224 | | memory_set_bankptr(space->machine, 2, ram+0xb000); |
| 225 | | } else { |
| 234 | memory_set_bankptr(space->machine, 2, ram + 0xb000); |
| 235 | } |
| 236 | else |
| 237 | { |
| 226 | 238 | // else read from normal ram |
| 227 | | memory_set_bankptr(space->machine, 2, ram+0x3000); |
| 239 | memory_set_bankptr(space->machine, 2, ram + 0x3000); |
| 228 | 240 | } |
| 229 | 241 | } |
| 230 | 242 | return address; |
| r4569 | r4570 | |
| 237 | 249 | if (vdusel==0) |
| 238 | 250 | { |
| 239 | 251 | // not in shadow ram mode so just write to normal ram |
| 240 | | ram[offset+0x3000]=data; |
| 241 | | bbc_vidmem[offset+0x3000]=1; |
| 242 | | } else { |
| 252 | ram[offset + 0x3000] = data; |
| 253 | bbc_vidmem[offset + 0x3000] = 1; |
| 254 | } |
| 255 | else |
| 256 | { |
| 243 | 257 | if (vdudriverset(space->machine)) |
| 244 | 258 | { |
| 245 | 259 | // if VDUDriver set then write to shadow ram |
| 246 | | ram[offset+0xb000]=data; |
| 247 | | bbc_vidmem[offset+0xb000]=1; |
| 248 | | } else { |
| 260 | ram[offset + 0xb000] = data; |
| 261 | bbc_vidmem[offset + 0xb000] = 1; |
| 262 | } |
| 263 | else |
| 264 | { |
| 249 | 265 | // else write to normal ram |
| 250 | | ram[offset+0x3000]=data; |
| 251 | | bbc_vidmem[offset+0x3000]=1; |
| 266 | ram[offset + 0x3000] = data; |
| 267 | bbc_vidmem[offset + 0x3000] = 1; |
| 252 | 268 | } |
| 253 | 269 | } |
| 254 | 270 | } |
| r4569 | r4570 | |
| 388 | 404 | |
| 389 | 405 | if (tempIRR!=ACCCON_IRR) |
| 390 | 406 | { |
| 391 | | cpu_set_input_line(space->machine->cpu[0], M6502_IRQ_LINE, ACCCON_IRR); |
| 407 | cputag_set_input_line(space->machine, "maincpu", M6502_IRQ_LINE, ACCCON_IRR); |
| 392 | 408 | } |
| 393 | 409 | |
| 394 | 410 | if (ACCCON_Y) |
| 395 | 411 | { |
| 396 | | memory_set_bankptr(space->machine, 7,memory_region(space->machine, "maincpu")+0x9000); |
| 397 | | } else { |
| 398 | | memory_set_bankptr(space->machine, 7,memory_region(space->machine, "user1")+0x40000); |
| 412 | memory_set_bankptr(space->machine, 7, memory_region(space->machine, "maincpu") + 0x9000); |
| 413 | } |
| 414 | else |
| 415 | { |
| 416 | memory_set_bankptr(space->machine, 7, memory_region(space->machine, "user1") + 0x40000); |
| 399 | 417 | } |
| 400 | 418 | |
| 401 | 419 | bbcbp_setvideoshadow(space->machine, ACCCON_D); |
| r4569 | r4570 | |
| 404 | 422 | if (ACCCON_X) |
| 405 | 423 | { |
| 406 | 424 | memory_set_bankptr( space->machine, 2, memory_region( space->machine, "maincpu" ) + 0xb000 ); |
| 407 | | } else { |
| 425 | } |
| 426 | else |
| 427 | { |
| 408 | 428 | memory_set_bankptr( space->machine, 2, memory_region( space->machine, "maincpu" ) + 0x3000 ); |
| 409 | 429 | } |
| 410 | 430 | |
| r4569 | r4570 | |
| 427 | 447 | static int bbcm_vdudriverset(running_machine *machine) |
| 428 | 448 | { |
| 429 | 449 | int PC; |
| 430 | | PC=cpu_get_pc( machine->cpu[0] ); |
| 431 | | return ((PC>=0xc000) && (PC<=0xdfff)); |
| 450 | PC = cpu_get_pc(cputag_get_cpu(machine, "maincpu")); |
| 451 | return ((PC >= 0xc000) && (PC <= 0xdfff)); |
| 432 | 452 | } |
| 433 | 453 | |
| 434 | 454 | |
| 435 | 455 | static WRITE8_HANDLER ( page_selectbm_w ) |
| 436 | 456 | { |
| 437 | | pagedRAM=(data&0x80)>>7; |
| 438 | | bbc_rombank=data&0x0f; |
| 457 | pagedRAM = (data & 0x80) >> 7; |
| 458 | bbc_rombank = data & 0x0f; |
| 439 | 459 | |
| 440 | 460 | if (pagedRAM) |
| 441 | 461 | { |
| 442 | | memory_set_bankptr(space->machine, 4,memory_region(space->machine, "maincpu")+0x8000); |
| 462 | memory_set_bankptr(space->machine, 4, memory_region(space->machine, "maincpu") + 0x8000); |
| 443 | 463 | memory_set_bank(space->machine, 5, bbc_rombank); |
| 444 | | } else { |
| 445 | | memory_set_bankptr(space->machine, 4,memory_region(space->machine, "user1")+((bbc_rombank)<<14)); |
| 464 | } |
| 465 | else |
| 466 | { |
| 467 | memory_set_bankptr(space->machine, 4, memory_region(space->machine, "user1") + ((bbc_rombank) << 14)); |
| 446 | 468 | memory_set_bank(space->machine, 5, bbc_rombank); |
| 447 | 469 | } |
| 448 | 470 | } |
| r4569 | r4570 | |
| 451 | 473 | |
| 452 | 474 | WRITE8_HANDLER ( bbc_memorybm1_w ) |
| 453 | 475 | { |
| 454 | | memory_region(space->machine, "maincpu")[offset]=data; |
| 455 | | bbc_vidmem[offset]=1; |
| 476 | memory_region(space->machine, "maincpu")[offset] = data; |
| 477 | bbc_vidmem[offset] = 1; |
| 456 | 478 | } |
| 457 | 479 | |
| 458 | 480 | |
| r4569 | r4570 | |
| 461 | 483 | if (ACCCON_X) |
| 462 | 484 | { |
| 463 | 485 | memory_set_bankptr( space->machine, 2, memory_region( space->machine, "maincpu" ) + 0xb000 ); |
| 464 | | } else { |
| 486 | } |
| 487 | else |
| 488 | { |
| 465 | 489 | if (ACCCON_E && bbcm_vdudriverset(space->machine)) |
| 466 | 490 | { |
| 467 | 491 | memory_set_bankptr( space->machine, 2, memory_region( space->machine, "maincpu" ) + 0xb000 ); |
| 468 | | } else { |
| 492 | } |
| 493 | else |
| 494 | { |
| 469 | 495 | memory_set_bankptr( space->machine, 2, memory_region( space->machine, "maincpu" ) + 0x3000 ); |
| 470 | 496 | } |
| 471 | 497 | } |
| r4569 | r4570 | |
| 480 | 506 | UINT8 *ram = memory_region(space->machine, "maincpu"); |
| 481 | 507 | if (ACCCON_X) |
| 482 | 508 | { |
| 483 | | ram[offset+0xb000]=data; |
| 484 | | bbc_vidmem[offset+0xb000]=1; |
| 485 | | } else { |
| 509 | ram[offset + 0xb000] = data; |
| 510 | bbc_vidmem[offset + 0xb000] = 1; |
| 511 | } |
| 512 | else |
| 513 | { |
| 486 | 514 | if (ACCCON_E && bbcm_vdudriverset(space->machine)) |
| 487 | 515 | { |
| 488 | | ram[offset+0xb000]=data; |
| 489 | | bbc_vidmem[offset+0xb000]=1; |
| 490 | | } else { |
| 491 | | ram[offset+0x3000]=data; |
| 492 | | bbc_vidmem[offset+0x3000]=1; |
| 516 | ram[offset + 0xb000] = data; |
| 517 | bbc_vidmem[offset + 0xb000] = 1; |
| 518 | } |
| 519 | else |
| 520 | { |
| 521 | ram[offset + 0x3000] = data; |
| 522 | bbc_vidmem[offset + 0x3000] = 1; |
| 493 | 523 | } |
| 494 | 524 | } |
| 495 | 525 | } |
| r4569 | r4570 | |
| 836 | 866 | if ((input_port_read(device->machine, colnames[column]) | 0x01) != 0xff) |
| 837 | 867 | { |
| 838 | 868 | via_ca2_w(via_0, 0, 1); |
| 839 | | } else { |
| 869 | } |
| 870 | else |
| 871 | { |
| 840 | 872 | via_ca2_w(via_0, 0, 0); |
| 841 | 873 | } |
| 842 | 874 | |
| 843 | | } else { |
| 875 | } |
| 876 | else |
| 877 | { |
| 844 | 878 | via_ca2_w(via_0, 0, 0); |
| 845 | 879 | } |
| 846 | 880 | } |
| r4569 | r4570 | |
| 919 | 953 | { |
| 920 | 954 | via_system_porta=mc146818_port_r(space, 1); |
| 921 | 955 | //logerror("read 146818 data %d \n",via_system_porta); |
| 922 | | } else { |
| 923 | | mc146818_port_w(space, 1,via_system_porta); |
| 956 | } |
| 957 | else |
| 958 | { |
| 959 | mc146818_port_w(space, 1, via_system_porta); |
| 924 | 960 | //logerror("write 146818 data %d \n",via_system_porta); |
| 925 | 961 | } |
| 926 | 962 | } |
| r4569 | r4570 | |
| 928 | 964 | // if address select is set then set the address in the 146818 |
| 929 | 965 | if (MC146818_AS) |
| 930 | 966 | { |
| 931 | | mc146818_port_w(space, 0,via_system_porta); |
| 967 | mc146818_port_w(space, 0, via_system_porta); |
| 932 | 968 | //logerror("write 146818 address %d \n",via_system_porta); |
| 933 | 969 | } |
| 934 | 970 | } |
| r4569 | r4570 | |
| 937 | 973 | |
| 938 | 974 | static WRITE8_DEVICE_HANDLER( bbcb_via_system_write_porta ) |
| 939 | 975 | { |
| 940 | | const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM); |
| 976 | const address_space *space = cputag_get_address_space(device->machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 941 | 977 | //logerror("SYSTEM write porta %d\n",data); |
| 942 | 978 | |
| 943 | | via_system_porta=data; |
| 944 | | if (b0_sound==0) |
| 979 | via_system_porta = data; |
| 980 | if (b0_sound == 0) |
| 945 | 981 | { |
| 946 | 982 | //logerror("Doing an unsafe write to the sound chip %d \n",data); |
| 947 | 983 | sn76496_w(devtag_get_device(device->machine, "sn76489"), 0,via_system_porta); |
| 948 | 984 | } |
| 949 | | if (b3_keyboard==0) |
| 985 | if (b3_keyboard == 0) |
| 950 | 986 | { |
| 951 | 987 | //logerror("Doing an unsafe write to the keyboard %d \n",data); |
| 952 | | via_system_porta=bbc_keyboard(space, via_system_porta); |
| 988 | via_system_porta = bbc_keyboard(space, via_system_porta); |
| 953 | 989 | } |
| 954 | 990 | if (bbc_Master) MC146818_set(space); |
| 955 | 991 | } |
| r4569 | r4570 | |
| 957 | 993 | |
| 958 | 994 | static WRITE8_DEVICE_HANDLER( bbcb_via_system_write_portb ) |
| 959 | 995 | { |
| 960 | | const address_space *space = cpu_get_address_space(device->machine->cpu[0], ADDRESS_SPACE_PROGRAM); |
| 961 | | int bit,value; |
| 962 | | bit=data & 0x07; |
| 963 | | value=(data>>3) &0x01; |
| 996 | const address_space *space = cputag_get_address_space(device->machine, "maincpu", ADDRESS_SPACE_PROGRAM); |
| 997 | int bit, value; |
| 998 | bit = data & 0x07; |
| 999 | value = (data >> 3) & 0x01; |
| 964 | 1000 | |
| 965 | 1001 | |
| 966 | 1002 | //logerror("SYSTEM write portb %d %d %d\n",data,bit,value); |
| 967 | 1003 | |
| 968 | | if (value) { |
| 969 | | switch (bit) { |
| 1004 | if (value) |
| 1005 | { |
| 1006 | switch (bit) |
| 1007 | { |
| 970 | 1008 | case 0: |
| 971 | | if (b0_sound==0) { |
| 972 | | b0_sound=1; |
| 1009 | if (b0_sound == 0) |
| 1010 | { |
| 1011 | b0_sound = 1; |
| 973 | 1012 | } |
| 974 | 1013 | break; |
| 975 | 1014 | case 1: |
| 976 | 1015 | if (bbc_Master) |
| 977 | 1016 | { |
| 978 | | if (MC146818_WR==0) |
| 1017 | if (MC146818_WR == 0) |
| 979 | 1018 | { |
| 980 | 1019 | /* BBC MASTER has NV RAM Here */ |
| 981 | | MC146818_WR=1; |
| 1020 | MC146818_WR = 1; |
| 982 | 1021 | MC146818_set(space); |
| 983 | 1022 | } |
| 984 | | } else { |
| 985 | | if (b1_speech_read==0) { |
| 1023 | } |
| 1024 | else |
| 1025 | { |
| 1026 | if (b1_speech_read == 0) |
| 1027 | { |
| 986 | 1028 | /* VSP TMS 5220 */ |
| 987 | | b1_speech_read=1; |
| 1029 | b1_speech_read = 1; |
| 988 | 1030 | } |
| 989 | 1031 | } |
| 990 | 1032 | break; |
| 991 | 1033 | case 2: |
| 992 | 1034 | if (bbc_Master) |
| 993 | 1035 | { |
| 994 | | if (MC146818_DS==0) |
| 1036 | if (MC146818_DS == 0) |
| 995 | 1037 | { |
| 996 | 1038 | /* BBC MASTER has NV RAM Here */ |
| 997 | | MC146818_DS=1; |
| 1039 | MC146818_DS = 1; |
| 998 | 1040 | MC146818_set(space); |
| 999 | 1041 | } |
| 1000 | | } else { |
| 1001 | | if (b2_speech_write==0) { |
| 1042 | } |
| 1043 | else |
| 1044 | { |
| 1045 | if (b2_speech_write == 0) |
| 1046 | { |
| 1002 | 1047 | /* VSP TMS 5220 */ |
| 1003 | | b2_speech_write=1; |
| 1048 | b2_speech_write = 1; |
| 1004 | 1049 | } |
| 1005 | 1050 | } |
| 1006 | 1051 | break; |
| 1007 | 1052 | case 3: |
| 1008 | | if (b3_keyboard==0) { |
| 1009 | | b3_keyboard=1; |
| 1053 | if (b3_keyboard == 0) |
| 1054 | { |
| 1055 | b3_keyboard = 1; |
| 1010 | 1056 | } |
| 1011 | 1057 | break; |
| 1012 | 1058 | case 4: |
| 1013 | | if (b4_video0==0) { |
| 1014 | | b4_video0=1; |
| 1015 | | bbc_setscreenstart(b4_video0,b5_video1); |
| 1059 | if (b4_video0 == 0) |
| 1060 | { |
| 1061 | b4_video0 = 1; |
| 1062 | bbc_setscreenstart(b4_video0, b5_video1); |
| 1016 | 1063 | } |
| 1017 | 1064 | break; |
| 1018 | 1065 | case 5: |
| 1019 | | if (b5_video1==0) { |
| 1020 | | b5_video1=1; |
| 1021 | | bbc_setscreenstart(b4_video0,b5_video1); |
| 1066 | if (b5_video1 == 0) |
| 1067 | { |
| 1068 | b5_video1 = 1; |
| 1069 | bbc_setscreenstart(b4_video0, b5_video1); |
| 1022 | 1070 | } |
| 1023 | 1071 | break; |
| 1024 | 1072 | case 6: |
| 1025 | | if (b6_caps_lock_led==0) { |
| 1026 | | b6_caps_lock_led=1; |
| 1073 | if (b6_caps_lock_led == 0) |
| 1074 | { |
| 1075 | b6_caps_lock_led = 1; |
| 1027 | 1076 | /* call caps lock led update */ |
| 1028 | 1077 | } |
| 1029 | 1078 | break; |
| 1030 | 1079 | case 7: |
| 1031 | | if (b7_shift_lock_led==0) { |
| 1032 | | b7_shift_lock_led=1; |
| 1080 | if (b7_shift_lock_led == 0) |
| 1081 | { |
| 1082 | b7_shift_lock_led = 1; |
| 1033 | 1083 | /* call shift lock led update */ |
| 1034 | 1084 | } |
| 1035 | 1085 | break; |
| 1036 | | |
| 1037 | | } |
| 1038 | | } else { |
| 1039 | | switch (bit) { |
| 1086 | } |
| 1087 | } |
| 1088 | else |
| 1089 | { |
| 1090 | switch (bit) |
| 1091 | { |
| 1040 | 1092 | case 0: |
| 1041 | | if (b0_sound==1) { |
| 1042 | | b0_sound=0; |
| 1093 | if (b0_sound == 1) |
| 1094 | { |
| 1095 | b0_sound = 0; |
| 1043 | 1096 | sn76496_w(devtag_get_device(space->machine, "sn76489"), 0, via_system_porta); |
| 1044 | 1097 | } |
| 1045 | 1098 | break; |
| 1046 | 1099 | case 1: |
| 1047 | 1100 | if (bbc_Master) |
| 1048 | 1101 | { |
| 1049 | | if (MC146818_WR==1) |
| 1102 | if (MC146818_WR == 1) |
| 1050 | 1103 | { |
| 1051 | 1104 | /* BBC MASTER has NV RAM Here */ |
| 1052 | | MC146818_WR=0; |
| 1105 | MC146818_WR = 0; |
| 1053 | 1106 | MC146818_set(space); |
| 1054 | 1107 | } |
| 1055 | | } else { |
| 1056 | | if (b1_speech_read==1) { |
| 1108 | } |
| 1109 | else |
| 1110 | { |
| 1111 | if (b1_speech_read == 1) |
| 1112 | { |
| 1057 | 1113 | /* VSP TMS 5220 */ |
| 1058 | | b1_speech_read=0; |
| 1114 | b1_speech_read = 0; |
| 1059 | 1115 | } |
| 1060 | 1116 | } |
| 1061 | 1117 | break; |
| 1062 | 1118 | case 2: |
| 1063 | 1119 | if (bbc_Master) |
| 1064 | 1120 | { |
| 1065 | | if (MC146818_DS==1) |
| 1121 | if (MC146818_DS == 1) |
| 1066 | 1122 | { |
| 1067 | 1123 | /* BBC MASTER has NV RAM Here */ |
| 1068 | | MC146818_DS=0; |
| 1124 | MC146818_DS = 0; |
| 1069 | 1125 | MC146818_set(space); |
| 1070 | 1126 | } |
| 1071 | | } else { |
| 1072 | | if (b2_speech_write==1) { |
| 1127 | } |
| 1128 | else |
| 1129 | { |
| 1130 | if (b2_speech_write == 1) |
| 1131 | { |
| 1073 | 1132 | /* VSP TMS 5220 */ |
| 1074 | | b2_speech_write=0; |
| 1133 | b2_speech_write = 0; |
| 1075 | 1134 | } |
| 1076 | 1135 | } |
| 1077 | 1136 | break; |
| 1078 | 1137 | case 3: |
| 1079 | | if (b3_keyboard==1) { |
| 1080 | | b3_keyboard=0; |
| 1138 | if (b3_keyboard == 1) |
| 1139 | { |
| 1140 | b3_keyboard = 0; |
| 1081 | 1141 | /* *** call keyboard enabled *** */ |
| 1082 | 1142 | via_system_porta=bbc_keyboard(space, via_system_porta); |
| 1083 | 1143 | } |
| 1084 | 1144 | break; |
| 1085 | 1145 | case 4: |
| 1086 | | if (b4_video0==1) { |
| 1087 | | b4_video0=0; |
| 1088 | | bbc_setscreenstart(b4_video0,b5_video1); |
| 1146 | if (b4_video0 == 1) |
| 1147 | { |
| 1148 | b4_video0 = 0; |
| 1149 | bbc_setscreenstart(b4_video0, b5_video1); |
| 1089 | 1150 | } |
| 1090 | 1151 | break; |
| 1091 | 1152 | case 5: |
| 1092 | | if (b5_video1==1) { |
| 1093 | | b5_video1=0; |
| 1094 | | bbc_setscreenstart(b4_video0,b5_video1); |
| 1153 | if (b5_video1 == 1) |
| 1154 | { |
| 1155 | b5_video1 = 0; |
| 1156 | bbc_setscreenstart(b4_video0, b5_video1); |
| 1095 | 1157 | } |
| 1096 | 1158 | break; |
| 1097 | 1159 | case 6: |
| 1098 | | if (b6_caps_lock_led==1) { |
| 1099 | | b6_caps_lock_led=0; |
| 1160 | if (b6_caps_lock_led == 1) |
| 1161 | { |
| 1162 | b6_caps_lock_led = 0; |
| 1100 | 1163 | /* call caps lock led update */ |
| 1101 | 1164 | } |
| 1102 | 1165 | break; |
| 1103 | 1166 | case 7: |
| 1104 | | if (b7_shift_lock_led==1) { |
| 1105 | | b7_shift_lock_led=0; |
| 1167 | if (b7_shift_lock_led == 1) |
| 1168 | { |
| 1169 | b7_shift_lock_led = 0; |
| 1106 | 1170 | /* call shift lock led update */ |
| 1107 | 1171 | } |
| 1108 | 1172 | break; |
| r4569 | r4570 | |
| 1373 | 1437 | { |
| 1374 | 1438 | if (status) |
| 1375 | 1439 | { |
| 1376 | | cassette_change_state(devtag_get_device(machine, "cassette"),CASSETTE_MOTOR_ENABLED ,CASSETTE_MASK_MOTOR); |
| 1440 | cassette_change_state(devtag_get_device(machine, "cassette"), CASSETTE_MOTOR_ENABLED, CASSETTE_MASK_MOTOR); |
| 1377 | 1441 | timer_adjust_periodic(bbc_tape_timer, attotime_zero, 0, ATTOTIME_IN_HZ(44100)); |
| 1378 | | } else { |
| 1379 | | cassette_change_state(devtag_get_device(machine, "cassette"),CASSETTE_MOTOR_DISABLED,CASSETTE_MASK_MOTOR); |
| 1442 | } |
| 1443 | else |
| 1444 | { |
| 1445 | cassette_change_state(devtag_get_device(machine, "cassette"), CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR); |
| 1380 | 1446 | timer_reset(bbc_tape_timer, attotime_never); |
| 1381 | | len0=0; |
| 1382 | | len1=0; |
| 1383 | | len2=0; |
| 1384 | | len3=0; |
| 1385 | | wav_len=0; |
| 1447 | len0 = 0; |
| 1448 | len1 = 0; |
| 1449 | len2 = 0; |
| 1450 | len3 = 0; |
| 1451 | wav_len = 0; |
| 1386 | 1452 | } |
| 1387 | 1453 | } |
| 1388 | 1454 | |
| r4569 | r4570 | |
| 1602 | 1668 | { |
| 1603 | 1669 | /* I'll pulse it because if I used hold-line I'm not sure |
| 1604 | 1670 | it would clear - to be checked */ |
| 1605 | | cpu_set_input_line(device->machine->cpu[0], INPUT_LINE_NMI,PULSE_LINE); |
| 1671 | cputag_set_input_line(device->machine, "maincpu", INPUT_LINE_NMI,PULSE_LINE); |
| 1606 | 1672 | } |
| 1607 | 1673 | } |
| 1608 | 1674 | |
| r4569 | r4570 | |
| 1784 | 1850 | return wd17xx_data_r(fdc, 0); |
| 1785 | 1851 | } |
| 1786 | 1852 | |
| 1787 | | } else { |
| 1788 | | return memory_region(space->machine, "disks")[offset+(opusbank<<8)]; |
| 1853 | } |
| 1854 | else |
| 1855 | { |
| 1856 | return memory_region(space->machine, "disks")[offset + (opusbank << 8)]; |
| 1789 | 1857 | } |
| 1790 | 1858 | } |
| 1791 | 1859 | return 0xff; |
| r4569 | r4570 | |
| 1824 | 1892 | opusbank=(opusbank & 0xff00) | data; |
| 1825 | 1893 | break; |
| 1826 | 1894 | } |
| 1827 | | } else { |
| 1828 | | memory_region(space->machine, "disks")[offset+(opusbank<<8)]=data; |
| 1895 | } |
| 1896 | else |
| 1897 | { |
| 1898 | memory_region(space->machine, "disks")[offset + (opusbank << 8)] = data; |
| 1829 | 1899 | } |
| 1830 | 1900 | } |
| 1831 | 1901 | } |
| r4569 | r4570 | |
| 1986 | 2056 | |
| 1987 | 2057 | size = image_length (image); |
| 1988 | 2058 | |
| 1989 | | if (strcmp(image->tag,"cart1")==0) { |
| 2059 | if (strcmp(image->tag,"cart1") == 0) |
| 2060 | { |
| 1990 | 2061 | index = 0; |
| 1991 | 2062 | } |
| 1992 | | if (strcmp(image->tag,"cart2")==0) { |
| 2063 | if (strcmp(image->tag,"cart2") == 0) |
| 2064 | { |
| 1993 | 2065 | index = 1; |
| 1994 | 2066 | } |
| 1995 | | if (strcmp(image->tag,"cart3")==0) { |
| 2067 | if (strcmp(image->tag,"cart3") == 0) |
| 2068 | { |
| 1996 | 2069 | index = 2; |
| 1997 | 2070 | } |
| 1998 | | if (strcmp(image->tag,"cart4")==0) { |
| 2071 | if (strcmp(image->tag,"cart4") == 0) |
| 2072 | { |
| 1999 | 2073 | index = 3; |
| 2000 | 2074 | } |
| 2001 | 2075 | addr = 0x8000 + (0x4000 * index); |
| 2002 | 2076 | |
| 2003 | 2077 | |
| 2004 | | logerror("loading rom %s at %.4x size:%.4x\n",image_filename(image), addr, size); |
| 2078 | logerror("loading rom %s at %.4x size:%.4x\n", image_filename(image), addr, size); |
| 2005 | 2079 | |
| 2006 | 2080 | |
| 2007 | | switch (size) { |
| 2081 | switch (size) |
| 2082 | { |
| 2008 | 2083 | case 0x2000: |
| 2009 | 2084 | read_ = image_fread(image, mem + addr, size); |
| 2010 | | image_fseek(image,0,SEEK_SET); |
| 2085 | image_fseek(image, 0, SEEK_SET); |
| 2011 | 2086 | read_ = image_fread(image, mem + addr + 0x2000, size); |
| 2012 | 2087 | break; |
| 2013 | 2088 | case 0x4000: |
| r4569 | r4570 | |
| 2015 | 2090 | break; |
| 2016 | 2091 | default: |
| 2017 | 2092 | read_ = 0; |
| 2018 | | logerror("bad rom file size of %.4x\n",size); |
| 2093 | logerror("bad rom file size of %.4x\n", size); |
| 2019 | 2094 | break; |
| 2020 | 2095 | } |
| 2021 | 2096 | |
| r4569 | r4570 | |
| 2082 | 2157 | MACHINE_RESET( bbcb ) |
| 2083 | 2158 | { |
| 2084 | 2159 | UINT8 *ram = memory_region(machine, "maincpu"); |
| 2085 | | bbc_DFSType= (input_port_read(machine, "BBCCONFIG")>>0)&0x07; |
| 2086 | | bbc_SWRAMtype=(input_port_read(machine, "BBCCONFIG")>>3)&0x03; |
| 2087 | | bbc_RAMSize= (input_port_read(machine, "BBCCONFIG")>>5)&0x01; |
| 2160 | bbc_DFSType= (input_port_read(machine, "BBCCONFIG") >> 0) & 0x07; |
| 2161 | bbc_SWRAMtype = (input_port_read(machine, "BBCCONFIG") >> 3) & 0x03; |
| 2162 | bbc_RAMSize= (input_port_read(machine, "BBCCONFIG") >> 5) & 0x01; |
| 2088 | 2163 | |
| 2089 | 2164 | memory_set_bankptr(machine, 1,ram); |
| 2090 | 2165 | if (bbc_RAMSize) |
| 2091 | 2166 | { |
| 2092 | 2167 | /* 32K Model B */ |
| 2093 | | memory_set_bankptr(machine, 3,ram+0x4000); |
| 2168 | memory_set_bankptr(machine, 3, ram + 0x4000); |
| 2094 | 2169 | bbc_set_video_memory_lookups(32); |
| 2095 | | } else { |
| 2170 | } |
| 2171 | else |
| 2172 | { |
| 2096 | 2173 | /* 16K just repeat the lower 16K*/ |
| 2097 | | memory_set_bankptr(machine, 3,ram); |
| 2174 | memory_set_bankptr(machine, 3, ram); |
| 2098 | 2175 | bbc_set_video_memory_lookups(16); |
| 2099 | 2176 | } |
| 2100 | 2177 | |
| 2101 | | memory_set_bankptr(machine, 4,memory_region(machine, "user1")); /* bank 4 is the paged ROMs from 8000 to bfff */ |
| 2102 | | memory_set_bankptr(machine, 7,memory_region(machine, "user1")+0x40000); /* bank 7 points at the OS rom from c000 to ffff */ |
| 2178 | memory_set_bankptr(machine, 4, memory_region(machine, "user1")); /* bank 4 is the paged ROMs from 8000 to bfff */ |
| 2179 | memory_set_bankptr(machine, 7, memory_region(machine, "user1") + 0x40000); /* bank 7 points at the OS rom from c000 to ffff */ |
| 2103 | 2180 | |
| 2104 | 2181 | bbcb_IC32_initialise(); |
| 2105 | 2182 | |
| 2106 | 2183 | |
| 2107 | | opusbank=0; |
| 2184 | opusbank = 0; |
| 2108 | 2185 | /*set up the required disc controller*/ |
| 2109 | 2186 | //switch (bbc_DFSType) { |
| 2110 | 2187 | //case 0: case 1: case 2: case 3: |
| r4569 | r4570 | |
| 2119 | 2196 | { |
| 2120 | 2197 | mc6850_clock = 0; |
| 2121 | 2198 | |
| 2122 | | memory_set_direct_update_handler( cpu_get_address_space( machine->cpu[0], ADDRESS_SPACE_PROGRAM), bbcbp_direct_handler); |
| 2199 | memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), bbcbp_direct_handler); |
| 2123 | 2200 | |
| 2124 | 2201 | /* bank 6 is the paged ROMs from b000 to bfff */ |
| 2125 | 2202 | memory_configure_bank(machine, 6, 0, 16, memory_region(machine, "user1") + 0x3000, 1<<14); |
| r4569 | r4570 | |
| 2145 | 2222 | { |
| 2146 | 2223 | mc6850_clock = 0; |
| 2147 | 2224 | |
| 2148 | | memory_set_direct_update_handler( cpu_get_address_space( machine->cpu[0], ADDRESS_SPACE_PROGRAM ), bbcm_direct_handler); |
| 2225 | memory_set_direct_update_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), bbcm_direct_handler); |
| 2149 | 2226 | |
| 2150 | 2227 | /* bank 5 is the paged ROMs from 9000 to bfff */ |
| 2151 | 2228 | memory_configure_bank(machine, 5, 0, 16, memory_region(machine, "user1")+0x01000, 1<<14); |
| 2152 | 2229 | |
| 2153 | 2230 | /* Set ROM/IO bank to point to rom */ |
| 2154 | 2231 | memory_set_bankptr( machine, 8, memory_region(machine, "user1")+0x43c00); |
| 2155 | | memory_install_read_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM),0xFC00,0xFEFF,0,0,8); |
| 2232 | memory_install_read_handler(cputag_get_address_space(machine, "maincpu", ADDRESS_SPACE_PROGRAM), 0xFC00, 0xFEFF, 0, 0, 8); |
| 2156 | 2233 | } |
| 2157 | 2234 | |
| 2158 | 2235 | MACHINE_RESET( bbcm ) |
| 2159 | 2236 | { |
| 2160 | | memory_set_bankptr(machine, 1,memory_region(machine, "maincpu")); /* bank 1 regular lower ram from 0000 to 2fff */ |
| 2161 | | memory_set_bankptr(machine, 2,memory_region(machine, "maincpu")+0x3000); /* bank 2 screen/shadow ram from 3000 to 7fff */ |
| 2162 | | memory_set_bankptr(machine, 4,memory_region(machine, "user1")); /* bank 4 is paged ROM or RAM from 8000 to 8fff */ |
| 2237 | memory_set_bankptr(machine, 1, memory_region(machine, "maincpu")); /* bank 1 regular lower ram from 0000 to 2fff */ |
| 2238 | memory_set_bankptr(machine, 2, memory_region(machine, "maincpu") + 0x3000); /* bank 2 screen/shadow ram from 3000 to 7fff */ |
| 2239 | memory_set_bankptr(machine, 4, memory_region(machine, "user1")); /* bank 4 is paged ROM or RAM from 8000 to 8fff */ |
| 2163 | 2240 | memory_set_bank(machine, 5, 0); |
| 2164 | | memory_set_bankptr(machine, 7,memory_region(machine, "user1")+0x40000); /* bank 6 OS rom of RAM from c000 to dfff */ |
| 2241 | memory_set_bankptr(machine, 7, memory_region(machine, "user1") + 0x40000); /* bank 6 OS rom of RAM from c000 to dfff */ |
| 2165 | 2242 | |
| 2166 | 2243 | bbcb_IC32_initialise(); |
| 2167 | 2244 | |
src/mess/drivers/bw2.c
| r4569 | r4570 | |
| 103 | 103 | switch (state->bank) |
| 104 | 104 | { |
| 105 | 105 | case BANK_RAM1: |
| 106 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 106 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 107 | 107 | break; |
| 108 | 108 | |
| 109 | 109 | case BANK_VRAM: |
| 110 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, SMH_BANK1, SMH_BANK1); |
| 110 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, SMH_BANK1, SMH_BANK1); |
| 111 | 111 | break; |
| 112 | 112 | |
| 113 | 113 | case BANK_RAM2: |
| r4569 | r4570 | |
| 117 | 117 | case BANK_RAM6: |
| 118 | 118 | if (state->bank > max_ram_bank) |
| 119 | 119 | { |
| 120 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_UNMAP, SMH_UNMAP); |
| 120 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_UNMAP, SMH_UNMAP); |
| 121 | 121 | } |
| 122 | 122 | else |
| 123 | 123 | { |
| 124 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 124 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 125 | 125 | } |
| 126 | 126 | break; |
| 127 | 127 | |
| 128 | 128 | case BANK_ROM: |
| 129 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_UNMAP); |
| 129 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_UNMAP); |
| 130 | 130 | break; |
| 131 | 131 | } |
| 132 | 132 | |
| r4569 | r4570 | |
| 179 | 179 | { |
| 180 | 180 | case BANK_RAM1: |
| 181 | 181 | case BANK_RAMCARD_RAM: |
| 182 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 182 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 183 | 183 | break; |
| 184 | 184 | |
| 185 | 185 | case BANK_VRAM: |
| 186 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, SMH_BANK1, SMH_BANK1); |
| 186 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, SMH_BANK1, SMH_BANK1); |
| 187 | 187 | break; |
| 188 | 188 | |
| 189 | 189 | case BANK_RAM3: |
| r4569 | r4570 | |
| 191 | 191 | case BANK_RAM6: |
| 192 | 192 | if (state->bank > max_ram_bank) |
| 193 | 193 | { |
| 194 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_UNMAP, SMH_UNMAP); |
| 194 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_UNMAP, SMH_UNMAP); |
| 195 | 195 | } |
| 196 | 196 | else |
| 197 | 197 | { |
| 198 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 198 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 199 | 199 | } |
| 200 | 200 | break; |
| 201 | 201 | |
| 202 | 202 | case BANK_RAMCARD_ROM: |
| 203 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, SMH_BANK1, SMH_UNMAP); |
| 203 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x3fff, 0, 0x4000, SMH_BANK1, SMH_UNMAP); |
| 204 | 204 | break; |
| 205 | 205 | |
| 206 | 206 | case BANK_ROM: |
| 207 | | memory_install_readwrite8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_UNMAP); |
| 207 | memory_install_readwrite8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_UNMAP); |
| 208 | 208 | break; |
| 209 | 209 | } |
| 210 | 210 | |
| r4569 | r4570 | |
| 220 | 220 | |
| 221 | 221 | if ((get_ramdisk_size(space->machine) == 256) && (ramcard_bank > 7)) |
| 222 | 222 | { |
| 223 | | memory_install_readwrite8_handler(cpu_get_address_space(space->machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_UNMAP, SMH_UNMAP); |
| 223 | memory_install_readwrite8_handler(cputag_get_address_space(space->machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_UNMAP, SMH_UNMAP); |
| 224 | 224 | } |
| 225 | 225 | else |
| 226 | 226 | { |
| 227 | | memory_install_readwrite8_handler(cpu_get_address_space(space->machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 227 | memory_install_readwrite8_handler(cputag_get_address_space(space->machine, Z80_TAG, ADDRESS_SPACE_PROGRAM), 0x0000, 0x7fff, 0, 0, SMH_BANK1, SMH_BANK1); |
| 228 | 228 | } |
| 229 | 229 | |
| 230 | 230 | memory_configure_bank(space->machine, 1, BANK_RAMCARD_RAM, 1, state->ramcard_ram + bank_offset, 0); |
| r4569 | r4570 | |
| 300 | 300 | break; |
| 301 | 301 | |
| 302 | 302 | case WD17XX_DRQ_SET: |
| 303 | | if (cpu_get_reg(device->machine->cpu[0], Z80_HALT)) |
| 303 | if (cpu_get_reg(cputag_get_cpu(device->machine, Z80_TAG), Z80_HALT)) |
| 304 | 304 | { |
| 305 | 305 | cputag_set_input_line(device->machine, Z80_TAG, INPUT_LINE_NMI, HOLD_LINE); |
| 306 | 306 | } |
| r4569 | r4570 | |
| 611 | 611 | memory_configure_bank(machine, 1, BANK_RAM6, 1, state->work_ram + 0x18000, 0); |
| 612 | 612 | memory_configure_bank(machine, 1, BANK_ROM, 1, memory_region(machine, "ic1"), 0); |
| 613 | 613 | |
| 614 | | memory_install_write8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_IO), 0x30, 0x30, 0, 0x0f, &ramcard_bank_w); |
| 614 | memory_install_write8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_IO), 0x30, 0x30, 0, 0x0f, &ramcard_bank_w); |
| 615 | 615 | } |
| 616 | 616 | else |
| 617 | 617 | { |
| r4569 | r4570 | |
| 622 | 622 | memory_configure_bank(machine, 1, BANK_RAM2, 5, state->work_ram + 0x8000, 0x8000); |
| 623 | 623 | memory_configure_bank(machine, 1, BANK_ROM, 1, memory_region(machine, "ic1"), 0); |
| 624 | 624 | |
| 625 | | memory_install_write8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_IO), 0x30, 0x30, 0, 0x0f, SMH_UNMAP); |
| 625 | memory_install_write8_handler(cputag_get_address_space(machine, Z80_TAG, ADDRESS_SPACE_IO), 0x30, 0x30, 0, 0x0f, SMH_UNMAP); |
| 626 | 626 | } |
| 627 | 627 | |
| 628 | 628 | memory_set_bank(machine, 1, BANK_ROM); |
src/mess/drivers/crvision.c
| r4569 | r4570 | |
| 210 | 210 | |
| 211 | 211 | static void crvision_vdp_interrupt(running_machine *machine, int state) |
| 212 | 212 | { |
| 213 | | cpu_set_input_line(machine->cpu[0], INPUT_LINE_IRQ0, state); |
| 213 | cputag_set_input_line(machine, M6502_TAG, INPUT_LINE_IRQ0, state); |
| 214 | 214 | } |
| 215 | 215 | |
| 216 | 216 | static const TMS9928a_interface tms9918_intf = |
| r4569 | r4570 | |
| 422 | 422 | { |
| 423 | 423 | case 0x1000: // 4K |
| 424 | 424 | image_fread(image, mem + 0x9000, 0x1000); |
| 425 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 425 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 426 | 426 | break; |
| 427 | 427 | |
| 428 | 428 | case 0x1800: // 6K |
| 429 | 429 | image_fread(image, mem + 0x9000, 0x1000); |
| 430 | 430 | image_fread(image, mem + 0x8800, 0x0800); |
| 431 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 431 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 432 | 432 | break; |
| 433 | 433 | |
| 434 | 434 | case 0x2000: // 8K |
| 435 | 435 | image_fread(image, mem + 0x8000, 0x2000); |
| 436 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 436 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 437 | 437 | break; |
| 438 | 438 | |
| 439 | 439 | case 0x2800: // 10K |
| 440 | 440 | image_fread(image, mem + 0x8000, 0x2000); |
| 441 | 441 | image_fread(image, mem + 0x5800, 0x0800); |
| 442 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 443 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x4000, 0x5fff, 0, 0x2000, SMH_BANK2); |
| 442 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 443 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x4000, 0x5fff, 0, 0x2000, SMH_BANK2); |
| 444 | 444 | break; |
| 445 | 445 | |
| 446 | 446 | case 0x3000: // 12K |
| 447 | 447 | image_fread(image, mem + 0x8000, 0x2000); |
| 448 | 448 | image_fread(image, mem + 0x5000, 0x1000); |
| 449 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 450 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x4000, 0x5fff, 0, 0x2000, SMH_BANK2); |
| 449 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x8000, 0x9fff, 0, 0x2000, SMH_BANK1); |
| 450 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x4000, 0x5fff, 0, 0x2000, SMH_BANK2); |
| 451 | 451 | break; |
| 452 | 452 | |
| 453 | 453 | case 0x4000: // 16K |
| 454 | 454 | image_fread(image, mem + 0xa000, 0x2000); |
| 455 | 455 | image_fread(image, mem + 0x8000, 0x2000); |
| 456 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x8000, 0xbfff, 0, 0, SMH_BANK1); |
| 456 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x8000, 0xbfff, 0, 0, SMH_BANK1); |
| 457 | 457 | break; |
| 458 | 458 | |
| 459 | 459 | case 0x4800: // 18K |
| 460 | 460 | image_fread(image, mem + 0xa000, 0x2000); |
| 461 | 461 | image_fread(image, mem + 0x8000, 0x2000); |
| 462 | 462 | image_fread(image, mem + 0x4800, 0x0800); |
| 463 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x8000, 0x8fff, 0, 0, SMH_BANK1); |
| 464 | | memory_install_read8_handler(cpu_get_address_space(machine->cpu[0], ADDRESS_SPACE_PROGRAM), 0x4000, 0x4fff, 0, 0x3000, SMH_BANK2); |
| 463 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x8000, 0x8fff, 0, 0, SMH_BANK1); |
| 464 | memory_install_read8_handler(cputag_get_address_space(machine, M6502_TAG, ADDRESS_SPACE_PROGRAM), 0x4000, 0x4fff, 0, 0x3000, SMH_BANK2); |
| 465 | 465 | break; |
| 466 | 466 | |
| 467 | 467 | default: |