src/mame/machine/playch10.c
| r5336 | r5337 | |
| 4 | 4 | #include "includes/playch10.h" |
| 5 | 5 | |
| 6 | 6 | /* prototypes */ |
| 7 | | void pc10_set_mirroring( int mirroring ); |
| 8 | | WRITE8_HANDLER( pc10_nt_w ); |
| 9 | | READ8_HANDLER( pc10_nt_r ); |
| 10 | | WRITE8_HANDLER( pc10_chr_w ); |
| 11 | | READ8_HANDLER( pc10_chr_r ); |
| 12 | | void pc10_set_videorom_bank( running_machine *machine, int first, int count, int bank, int size ); |
| 13 | | void set_videoram_bank( running_machine *machine, int first, int count, int bank, int size ); |
| 7 | static void pc10_set_mirroring( int mirroring ); |
| 8 | static WRITE8_HANDLER( pc10_nt_w ); |
| 9 | static READ8_HANDLER( pc10_nt_r ); |
| 10 | static WRITE8_HANDLER( pc10_chr_w ); |
| 11 | static READ8_HANDLER( pc10_chr_r ); |
| 12 | static void pc10_set_videorom_bank( running_machine *machine, int first, int count, int bank, int size ); |
| 13 | static void set_videoram_bank( running_machine *machine, int first, int count, int bank, int size ); |
| 14 | 14 | |
| 15 | 15 | typedef struct |
| 16 | 16 | { |
| r5336 | r5337 | |
| 318 | 318 | * |
| 319 | 319 | *************************************/ |
| 320 | 320 | |
| 321 | | WRITE8_HANDLER( pc10_nt_w ) |
| 321 | static WRITE8_HANDLER( pc10_nt_w ) |
| 322 | 322 | { |
| 323 | 323 | int page = ((offset & 0xc00) >> 10); |
| 324 | 324 | nametable[page][offset & 0x3ff] = data; |
| 325 | 325 | } |
| 326 | 326 | |
| 327 | | READ8_HANDLER( pc10_nt_r ) |
| 327 | static READ8_HANDLER( pc10_nt_r ) |
| 328 | 328 | { |
| 329 | 329 | int page = ((offset & 0xc00) >> 10); |
| 330 | 330 | return nametable[page][offset & 0x3ff]; |
| 331 | 331 | } |
| 332 | 332 | |
| 333 | | WRITE8_HANDLER( pc10_chr_w ) |
| 333 | static WRITE8_HANDLER( pc10_chr_w ) |
| 334 | 334 | { |
| 335 | 335 | int bank = offset >> 10; |
| 336 | 336 | if (chr_page[bank].writable) |
| r5336 | r5337 | |
| 339 | 339 | } |
| 340 | 340 | } |
| 341 | 341 | |
| 342 | | READ8_HANDLER( pc10_chr_r ) |
| 342 | static READ8_HANDLER( pc10_chr_r ) |
| 343 | 343 | { |
| 344 | 344 | int bank = offset >> 10; |
| 345 | 345 | return chr_page[bank].chr[offset & 0x3ff]; |
| 346 | 346 | } |
| 347 | 347 | |
| 348 | | |
| 349 | | void pc10_set_mirroring( int mirroring ) |
| 348 | static void pc10_set_mirroring( int mirroring ) |
| 350 | 349 | { |
| 351 | 350 | switch (mirroring) |
| 352 | 351 | { |
| r5336 | r5337 | |
| 386 | 385 | * 64 1 * |
| 387 | 386 | \*****************/ |
| 388 | 387 | |
| 389 | | void pc10_set_videorom_bank( running_machine *machine, int first, int count, int bank, int size ) |
| 388 | static void pc10_set_videorom_bank( running_machine *machine, int first, int count, int bank, int size ) |
| 390 | 389 | { |
| 391 | 390 | int i, len; |
| 392 | 391 | /* first = first bank to map */ |
| r5336 | r5337 | |
| 411 | 410 | } |
| 412 | 411 | } |
| 413 | 412 | |
| 414 | | void set_videoram_bank( running_machine *machine, int first, int count, int bank, int size ) |
| 413 | static void set_videoram_bank( running_machine *machine, int first, int count, int bank, int size ) |
| 415 | 414 | { |
| 416 | 415 | int i; |
| 417 | 416 | /* first = first bank to map */ |
src/mess/machine/nes_mmc.c
| r5336 | r5337 | |
| 122 | 122 | |
| 123 | 123 | static emu_timer *nes_irq_timer; |
| 124 | 124 | |
| 125 | | void set_nt_page(int page, int source, int bank, int writable); |
| 125 | static void set_nt_page(int page, int source, int bank, int writable); |
| 126 | 126 | |
| 127 | 127 | static TIMER_CALLBACK(nes_irq_callback) |
| 128 | 128 | { |
| r5336 | r5337 | |
| 132 | 132 | |
| 133 | 133 | WRITE8_HANDLER( nes_chr_w) |
| 134 | 134 | { |
| 135 | | int bank =offset>>10; |
| 135 | int bank = offset >> 10; |
| 136 | 136 | if(chr_map[bank].source == CHRRAM) |
| 137 | 137 | { |
| 138 | | chr_map[bank].access[offset&0x3FF]=data; |
| 138 | chr_map[bank].access[offset & 0x3ff] = data; |
| 139 | 139 | } |
| 140 | 140 | } |
| 141 | |
| 141 | 142 | READ8_HANDLER( nes_chr_r) |
| 142 | 143 | { |
| 143 | | int bank =offset>>10; |
| 144 | | return chr_map[bank].access[offset&0x3FF]; |
| 144 | int bank = offset >> 10; |
| 145 | return chr_map[bank].access[offset & 0x3ff]; |
| 145 | 146 | } |
| 146 | 147 | |
| 147 | 148 | WRITE8_HANDLER(nes_nt_w) |
| 148 | 149 | { |
| 149 | | int page=((offset&0xC00)>>10); |
| 150 | | if(nt_page[page].writable ==0) |
| 150 | int page = ((offset & 0xc00) >> 10); |
| 151 | |
| 152 | if (nt_page[page].writable == 0) |
| 151 | 153 | return; |
| 152 | | nt_page[page].access[offset&0x3FF]=data; |
| 154 | |
| 155 | nt_page[page].access[offset & 0x3ff] = data; |
| 153 | 156 | } |
| 157 | |
| 154 | 158 | READ8_HANDLER(nes_nt_r) |
| 155 | 159 | { |
| 156 | | int page=((offset&0xC00)>>10); |
| 157 | | return nt_page[page].access[offset&0x3FF]; |
| 160 | int page = ((offset & 0xc00) >> 10); |
| 161 | |
| 162 | return nt_page[page].access[offset & 0x3ff]; |
| 158 | 163 | } |
| 159 | 164 | |
| 160 | 165 | WRITE8_HANDLER( nes_low_mapper_w ) |
| r5336 | r5337 | |
| 164 | 169 | { |
| 165 | 170 | logerror("Unimplemented LOW mapper write, offset: %04x, data: %02x\n", offset, data); |
| 166 | 171 | #ifdef MAME_DEBUG |
| 167 | | if (! mapper_warning) |
| 172 | if (!mapper_warning) |
| 168 | 173 | { |
| 169 | 174 | logerror ("This game is writing to the low mapper area but no mapper is set. You may get better results by switching to a valid mapper.\n"); |
| 170 | 175 | mapper_warning = 1; |
| r5336 | r5337 | |
| 184 | 189 | return 0; |
| 185 | 190 | } |
| 186 | 191 | |
| 187 | | WRITE8_HANDLER ( nes_mid_mapper_w ) |
| 192 | WRITE8_HANDLER( nes_mid_mapper_w ) |
| 188 | 193 | { |
| 189 | 194 | if (mmc_write_mid) (*mmc_write_mid)(space, offset, data); |
| 190 | 195 | else if (nes.mid_ram_enable) |
| r5336 | r5337 | |
| 202 | 207 | } |
| 203 | 208 | } |
| 204 | 209 | |
| 205 | | READ8_HANDLER ( nes_mid_mapper_r ) |
| 210 | READ8_HANDLER( nes_mid_mapper_r ) |
| 206 | 211 | { |
| 207 | 212 | if ((nes.mid_ram_enable) || (nes.mapper == 5)) |
| 208 | 213 | return nes_battery_ram[offset]; |
| r5336 | r5337 | |
| 210 | 215 | return 0; |
| 211 | 216 | } |
| 212 | 217 | |
| 213 | | WRITE8_HANDLER ( nes_mapper_w ) |
| 218 | WRITE8_HANDLER( nes_mapper_w ) |
| 214 | 219 | { |
| 215 | 220 | if (mmc_write) (*mmc_write)(space, offset, data); |
| 216 | 221 | else |
| r5336 | r5337 | |
| 241 | 246 | * Some helpful routines used by the mappers |
| 242 | 247 | */ |
| 243 | 248 | |
| 244 | | void ppu_mirror_custom (int page, int address) |
| 249 | static void ppu_mirror_custom( int page, int address ) |
| 245 | 250 | { |
| 246 | | fatalerror("Unimplemented: custom NT mirroring"); |
| 251 | logerror("Unimplemented: custom NT mirroring"); |
| 247 | 252 | } |
| 248 | 253 | |
| 249 | | void ppu_mirror_MMC5 (int page, int src) |
| 254 | static void ppu_mirror_MMC5( int page, int src ) |
| 250 | 255 | { |
| 251 | 256 | switch(src) |
| 252 | 257 | { |
| 253 | | case 0://CIRAM0 |
| 254 | | set_nt_page(page, CIRAM, 0,1); |
| 258 | case 0: /* CIRAM0 */ |
| 259 | set_nt_page(page, CIRAM, 0, 1); |
| 255 | 260 | break; |
| 256 | | case 1://CIRAM1 |
| 257 | | set_nt_page(page, CIRAM, 1,1); |
| 261 | case 1: /* CIRAM1 */ |
| 262 | set_nt_page(page, CIRAM, 1, 1); |
| 258 | 263 | break; |
| 259 | | case 2://ExRAM |
| 260 | | set_nt_page(page, EXRAM,0,1);//actually only works during rendering. |
| 264 | case 2: /* ExRAM */ |
| 265 | set_nt_page(page, EXRAM, 0, 1); // actually only works during rendering. |
| 261 | 266 | break; |
| 262 | | case 3://FillRegisters -useless without dot-based PPU, in general |
| 263 | | //break; |
| 264 | | default: fatalerror("Unimplemented: Fill support"); |
| 267 | case 3: /* FillRegisters -useless without dot-based PPU, in general */ |
| 268 | default: |
| 269 | logerror("Unimplemented: Fill support"); |
| 265 | 270 | } |
| 266 | 271 | } |
| 267 | 272 | |
| 268 | | void ppu_mirror_custom_vrom (int page, int address) |
| 273 | static void ppu_mirror_custom_vrom( int page, int address ) |
| 269 | 274 | { |
| 270 | | set_nt_page(page, ROM, address,0); |
| 275 | set_nt_page(page, ROM, address, 0); |
| 271 | 276 | } |
| 272 | 277 | |
| 273 | 278 | static void prg8_89 (const address_space *space, int bank) |
| r5336 | r5337 | |
| 351 | 356 | } |
| 352 | 357 | } |
| 353 | 358 | |
| 354 | | void set_nt_page(int page, int source, int bank, int writable) |
| 359 | static void set_nt_page( int page, int source, int bank, int writable ) |
| 355 | 360 | { |
| 356 | 361 | UINT8* base_ptr; |
| 357 | 362 | |
| 358 | | switch(source) |
| 363 | switch (source) |
| 359 | 364 | { |
| 360 | | case ROM:base_ptr=nes.vrom; |
| 361 | | case EXRAM:base_ptr=nes.exram; |
| 365 | case ROM: |
| 366 | base_ptr = nes.vrom; |
| 367 | case EXRAM: |
| 368 | base_ptr = nes.exram; |
| 362 | 369 | case CIRAM: |
| 363 | | default: base_ptr=nes.ciram; |
| 370 | default: |
| 371 | base_ptr = nes.ciram; |
| 364 | 372 | } |
| 365 | 373 | |
| 366 | | page&=3; //mask down to the 4 logical pages |
| 367 | | nt_page[page].source=source; |
| 368 | | nt_page[page].origin=bank*0x400; |
| 369 | | nt_page[page].access=base_ptr+nt_page[page].origin; |
| 370 | | nt_page[page].writable=writable; |
| 374 | page &= 3; // mask down to the 4 logical pages |
| 375 | nt_page[page].source = source; |
| 376 | nt_page[page].origin = bank * 0x400; |
| 377 | nt_page[page].access = base_ptr + nt_page[page].origin; |
| 378 | nt_page[page].writable = writable; |
| 371 | 379 | } |
| 372 | 380 | |
| 373 | | void set_nt_mirroring(int mirroring ) |
| 381 | void set_nt_mirroring( int mirroring ) |
| 374 | 382 | { |
| 375 | 383 | /* setup our videomem handlers based on mirroring */ |
| 376 | | switch( mirroring ) |
| 384 | switch (mirroring) |
| 377 | 385 | { |
| 378 | 386 | case PPU_MIRROR_VERT: |
| 379 | 387 | set_nt_page(0, CIRAM, 0, 1); |
| r5336 | r5337 | |
| 408 | 416 | default: |
| 409 | 417 | /* external RAM needs to be used somehow. */ |
| 410 | 418 | /* but as a default, we'll arbitrarily set vertical so as not to crash*/ |
| 411 | | |
| 412 | 419 | logerror("Mapper set 4-screen mirroring without supplying external nametable memory!\n"); |
| 413 | 420 | |
| 414 | 421 | set_nt_page(0, CIRAM, 0, 1); |
| r5336 | r5337 | |
| 419 | 426 | } |
| 420 | 427 | } |
| 421 | 428 | |
| 422 | | static void chr8 (running_machine *machine, int bank, int source) |
| 429 | static void chr8( running_machine *machine, int bank, int source ) |
| 423 | 430 | { |
| 424 | 431 | int i; |
| 425 | | //nes_state *state = machine->driver_data; |
| 426 | | bank &= (nes.chr_chunks - 1); |
| 427 | | |
| 428 | | for(i=0;i<8;i++) |
| 432 | |
| 433 | bank &= (nes.chr_chunks - 1); |
| 434 | for (i = 0; i < 8; i++) |
| 429 | 435 | { |
| 430 | | chr_map[i].source=source; |
| 431 | | chr_map[i].origin=(bank*0x2000)+(i*0x400); //for save state uses! |
| 432 | | if(source==CHRRAM) |
| 433 | | chr_map[i].access=&nes.vram[chr_map[i].origin]; |
| 434 | | else chr_map[i].access=&nes.vrom[chr_map[i].origin]; |
| 436 | chr_map[i].source = source; |
| 437 | chr_map[i].origin = (bank * 0x2000) + (i * 0x400); // for save state uses! |
| 438 | |
| 439 | if (source == CHRRAM) |
| 440 | chr_map[i].access = &nes.vram[chr_map[i].origin]; |
| 441 | else |
| 442 | chr_map[i].access = &nes.vrom[chr_map[i].origin]; |
| 435 | 443 | } |
| 436 | | //ppu2c0x_set_videorom_bank(state->ppu, 0, 8, bank, 512); |
| 437 | 444 | } |
| 438 | | static void chr4_x (running_machine *machine, int start, int bank, int source) |
| 445 | |
| 446 | static void chr4_x( running_machine *machine, int start, int bank, int source ) |
| 439 | 447 | { |
| 440 | 448 | int i; |
| 449 | |
| 441 | 450 | bank &= ((nes.chr_chunks << 1) - 1); |
| 442 | | for(i=0;i<4;i++) |
| 451 | for (i = 0; i < 4; i++) |
| 443 | 452 | { |
| 444 | | chr_map[i+start].source=source; |
| 445 | | chr_map[i+start].origin=(bank*0x1000)+(i*0x400); //for save state uses! |
| 446 | | if(source==CHRRAM) |
| 447 | | chr_map[i+start].access=&nes.vram[chr_map[i+start].origin]; |
| 448 | | else chr_map[i+start].access=&nes.vrom[chr_map[i+start].origin]; |
| 453 | chr_map[i + start].source = source; |
| 454 | chr_map[i + start].origin = (bank * 0x1000) + (i * 0x400); // for save state uses! |
| 455 | |
| 456 | if (source == CHRRAM) |
| 457 | chr_map[i+start].access = &nes.vram[chr_map[i + start].origin]; |
| 458 | else |
| 459 | chr_map[i+start].access = &nes.vrom[chr_map[i + start].origin]; |
| 449 | 460 | } |
| 450 | | // ppu2c0x_set_videorom_bank(state->ppu, 0, 4, bank, 256); |
| 451 | 461 | } |
| 452 | 462 | |
| 453 | | static void chr4_0 (running_machine *machine, int bank, int source) |
| 463 | static void chr4_0( running_machine *machine, int bank, int source ) |
| 454 | 464 | { |
| 455 | 465 | chr4_x(machine, 0, bank, source); |
| 456 | 466 | } |
| 457 | 467 | |
| 458 | | static void chr4_4 (running_machine *machine, int bank, int source) |
| 468 | static void chr4_4( running_machine *machine, int bank, int source ) |
| 459 | 469 | { |
| 460 | 470 | chr4_x(machine, 4, bank, source); |
| 461 | 471 | } |
| 462 | | static void chr2_x (running_machine *machine, int start, int bank, int source) |
| 472 | |
| 473 | static void chr2_x( running_machine *machine, int start, int bank, int source ) |
| 463 | 474 | { |
| 464 | 475 | int i; |
| 476 | |
| 465 | 477 | bank &= ((nes.chr_chunks << 2) - 1); |
| 466 | | for(i=0;i<2;i++) |
| 478 | for (i = 0; i < 2; i++) |
| 467 | 479 | { |
| 468 | | chr_map[i+start].source=source; |
| 469 | | chr_map[i+start].origin=(bank*0x800)+(i*0x400); |
| 470 | | if(source==CHRRAM) |
| 471 | | chr_map[i+start].access=&nes.vram[chr_map[i+start].origin]; |
| 472 | | else chr_map[i+start].access=&nes.vrom[chr_map[i+start].origin]; |
| 480 | chr_map[i + start].source = source; |
| 481 | chr_map[i + start].origin = (bank * 0x800) + (i * 0x400); |
| 482 | |
| 483 | if (source == CHRRAM) |
| 484 | chr_map[i + start].access = &nes.vram[chr_map[i + start].origin]; |
| 485 | else |
| 486 | chr_map[i + start].access = &nes.vrom[chr_map[i + start].origin]; |
| 473 | 487 | } |
| 474 | 488 | } |
| 475 | 489 | |
| 476 | | static void chr2_0 (running_machine *machine, int bank, int source) |
| 490 | static void chr2_0( running_machine *machine, int bank, int source ) |
| 477 | 491 | { |
| 478 | 492 | chr2_x(machine, 0, bank, source); |
| 479 | 493 | } |
| 480 | 494 | |
| 481 | | static void chr2_2 (running_machine *machine, int bank, int source) |
| 495 | static void chr2_2( running_machine *machine, int bank, int source ) |
| 482 | 496 | { |
| 483 | 497 | chr2_x(machine, 2, bank, source); |
| 484 | 498 | } |
| 485 | 499 | |
| 486 | | static void chr2_4 (running_machine *machine, int bank, int source) |
| 500 | static void chr2_4( running_machine *machine, int bank, int source ) |
| 487 | 501 | { |
| 488 | 502 | chr2_x(machine, 4, bank, source); |
| 489 | 503 | } |
| 490 | 504 | |
| 491 | | static void chr2_6 (running_machine *machine, int bank, int source) |
| 505 | static void chr2_6( running_machine *machine, int bank, int source ) |
| 492 | 506 | { |
| 493 | 507 | chr2_x(machine, 6, bank, source); |
| 494 | 508 | } |
| 495 | | static void chr1_x (running_machine *machine, int start, int bank, int source) |
| 509 | |
| 510 | static void chr1_x( running_machine *machine, int start, int bank, int source ) |
| 496 | 511 | { |
| 497 | | chr_map[start].source=source; |
| 512 | chr_map[start].source = source; |
| 498 | 513 | bank &= ((nes.chr_chunks << 3) - 1); |
| 499 | | chr_map[start].origin=bank*0x400; |
| 500 | | if(source==CHRRAM) |
| 501 | | chr_map[start].access=&nes.vram[chr_map[start].origin]; |
| 502 | | else chr_map[start].access=&nes.vrom[chr_map[start].origin]; |
| 514 | chr_map[start].origin = bank * 0x400; |
| 515 | |
| 516 | if (source == CHRRAM) |
| 517 | chr_map[start].access = &nes.vram[chr_map[start].origin]; |
| 518 | else |
| 519 | chr_map[start].access = &nes.vrom[chr_map[start].origin]; |
| 503 | 520 | } |
| 521 | |
| 504 | 522 | static void chr1_0 (running_machine *machine, int bank, int source) |
| 505 | 523 | { |
| 506 | 524 | chr1_x(machine, 0, bank, source); |
| 507 | 525 | } |
| 508 | | static void chr1_1 (running_machine *machine, int bank, int source) |
| 526 | |
| 527 | static void chr1_1( running_machine *machine, int bank, int source ) |
| 509 | 528 | { |
| 510 | 529 | chr1_x(machine, 1, bank, source); |
| 511 | 530 | } |
| 512 | | static void chr1_2 (running_machine *machine, int bank, int source) |
| 531 | |
| 532 | static void chr1_2( running_machine *machine, int bank, int source ) |
| 513 | 533 | { |
| 514 | 534 | chr1_x(machine, 2, bank, source); |
| 515 | 535 | } |
| 516 | | static void chr1_3 (running_machine *machine, int bank, int source) |
| 536 | |
| 537 | static void chr1_3( running_machine *machine, int bank, int source ) |
| 517 | 538 | { |
| 518 | 539 | chr1_x(machine, 3, bank, source); |
| 519 | 540 | } |
| 520 | | static void chr1_4 (running_machine *machine, int bank, int source) |
| 541 | |
| 542 | static void chr1_4( running_machine *machine, int bank, int source ) |
| 521 | 543 | { |
| 522 | 544 | chr1_x(machine, 4, bank, source); |
| 523 | 545 | } |
| 524 | | static void chr1_5 (running_machine *machine, int bank, int source) |
| 546 | |
| 547 | static void chr1_5( running_machine *machine, int bank, int source ) |
| 525 | 548 | { |
| 526 | 549 | chr1_x(machine, 5, bank, source); |
| 527 | 550 | } |
| 528 | | static void chr1_6 (running_machine *machine, int bank, int source) |
| 551 | |
| 552 | static void chr1_6( running_machine *machine, int bank, int source ) |
| 529 | 553 | { |
| 530 | 554 | chr1_x(machine, 6, bank, source); |
| 531 | 555 | } |
| 532 | | static void chr1_7 (running_machine *machine, int bank, int source) |
| 556 | |
| 557 | static void chr1_7( running_machine *machine, int bank, int source ) |
| 533 | 558 | { |
| 534 | 559 | chr1_x(machine, 7, bank, source); |
| 535 | 560 | } |
| r5336 | r5337 | |
| 1164 | 1189 | } |
| 1165 | 1190 | } |
| 1166 | 1191 | |
| 1167 | | static READ8_HANDLER( mapper5_l_r ) |
| 1192 | static READ8_HANDLER( mapper5_l_r ) |
| 1168 | 1193 | { |
| 1169 | 1194 | int retVal; |
| 1170 | 1195 | |
| r5336 | r5337 | |
| 2367 | 2392 | } |
| 2368 | 2393 | } |
| 2369 | 2394 | |
| 2370 | | READ8_HANDLER ( fds_r ) |
| 2395 | READ8_HANDLER( fds_r ) |
| 2371 | 2396 | { |
| 2372 | 2397 | int ret = 0x00; |
| 2373 | 2398 | static int last_side = 0; |
| r5336 | r5337 | |
| 2420 | 2445 | return ret; |
| 2421 | 2446 | } |
| 2422 | 2447 | |
| 2423 | | WRITE8_HANDLER ( fds_w ) |
| 2448 | WRITE8_HANDLER( fds_w ) |
| 2424 | 2449 | { |
| 2425 | 2450 | switch (offset) |
| 2426 | 2451 | { |