src/mess/machine/ti99/hsgpl.c
| r10339 | r10340 | |
| 209 | 209 | { |
| 210 | 210 | int port; |
| 211 | 211 | hsgpl_state *card = get_safe_token(device); |
| 212 | | |
| 213 | 212 | //activecpu_adjust_icount(-4); |
| 214 | 213 | |
| 215 | 214 | // 1001 10bb bbbb bba0 |
| r10339 | r10340 | |
| 398 | 397 | hsgpl_state *card = get_safe_token(device); |
| 399 | 398 | if (card->dsr_enabled) |
| 400 | 399 | { |
| 401 | | *value = at29c040a_r(card->dsr, (offset-0x4000) + 0x2000 * card->dsr_page); |
| 400 | *value = at29c040a_r(card->dsr, (offset & 0x1fff) + 0x2000 * card->dsr_page); |
| 402 | 401 | // logerror("hsgpl: read dsr %04x[%02x] -> %02x\n", offset, card->dsr_page, *value); |
| 403 | 402 | } |
| 404 | 403 | } |
| r10339 | r10340 | |
| 417 | 416 | |
| 418 | 417 | if ((port < 2) && (card->ram_enabled)) |
| 419 | 418 | { |
| 420 | | *value = card->ram6[(offset-0x6000) + 0x2000*card->current_bank + 0x8000*port]; |
| 419 | *value = card->ram6[(offset & 0x1fff) + 0x2000*card->current_bank + 0x8000*port]; |
| 421 | 420 | // logerror("hsgpl cart ram read %04x -> %02x\n", offset, *value); |
| 422 | 421 | return; |
| 423 | 422 | } |
| 424 | 423 | |
| 425 | 424 | if (port < 16) |
| 426 | 425 | { |
| 427 | | *value = at29c040a_r(card->rom6, (offset-0x6000) + 0x2000*card->current_bank + 0x8000*port); |
| 426 | *value = at29c040a_r(card->rom6, (offset & 0x1fff) + 0x2000*card->current_bank + 0x8000*port); |
| 428 | 427 | // logerror("hsgpl cart read %04x -> %02x\n", offset, *value); |
| 429 | 428 | } |
| 430 | 429 | else |
| 431 | 430 | { |
| 432 | 431 | if (port==32 || port==33) |
| 433 | 432 | { |
| 434 | | *value = card->ram6[(offset-0x6000) + 0x2000*card->current_bank + 0x8000*(port-32)]; |
| 433 | *value = card->ram6[(offset & 0x1fff) + 0x2000*card->current_bank + 0x8000*(port-32)]; |
| 435 | 434 | } |
| 436 | 435 | else |
| 437 | 436 | { |
| r10339 | r10340 | |
| 473 | 472 | { |
| 474 | 473 | if ((port < 2) && (card->ram_enabled)) |
| 475 | 474 | { |
| 476 | | card->ram6[(offset-0x6000) + 0x2000*card->current_bank + 0x8000*port ] = data; |
| 475 | card->ram6[(offset & 0x1fff) + 0x2000*card->current_bank + 0x8000*port ] = data; |
| 477 | 476 | } |
| 478 | 477 | else |
| 479 | 478 | { // keep in mind that these lines are also reached for port < 2 |
| r10339 | r10340 | |
| 491 | 490 | { |
| 492 | 491 | if (port==32 || port==33) |
| 493 | 492 | { |
| 494 | | card->ram6[(offset-0x6000) + 0x2000*card->current_bank + 0x8000*(port-32)] = data; |
| 493 | card->ram6[(offset & 0x1fff) + 0x2000*card->current_bank + 0x8000*(port-32)] = data; |
| 495 | 494 | } |
| 496 | 495 | else |
| 497 | 496 | { |
| r10339 | r10340 | |
| 507 | 506 | */ |
| 508 | 507 | static READ8Z_DEVICE_HANDLER ( data_rz ) |
| 509 | 508 | { |
| 510 | | if ((offset & 0xe000)==0x4000) |
| 509 | if ((offset & 0x7e000)==0x74000) |
| 511 | 510 | { |
| 512 | | hsgpl_dsrspace_rz(device, offset, value); |
| 511 | hsgpl_dsrspace_rz(device, offset & 0xffff, value); |
| 513 | 512 | } |
| 514 | 513 | |
| 515 | | if ((offset & 0xe000)==0x6000) |
| 514 | if ((offset & 0x7e000)==0x76000) |
| 516 | 515 | { |
| 517 | | hsgpl_cartspace_rz(device, offset, value); |
| 516 | hsgpl_cartspace_rz(device, offset & 0xffff, value); |
| 518 | 517 | } |
| 519 | 518 | |
| 520 | 519 | // 1001 1wbb bbbb bba0 |
| 521 | | if ((offset & 0xfc01)==0x9800) |
| 520 | if ((offset & 0x7fc01)==0x79800) |
| 522 | 521 | { |
| 523 | | hsgpl_grom_rz(device, offset, value); |
| 522 | hsgpl_grom_rz(device, offset & 0xffff, value); |
| 524 | 523 | } |
| 525 | 524 | } |
| 526 | 525 | |
| r10339 | r10340 | |
| 529 | 528 | */ |
| 530 | 529 | static WRITE8_DEVICE_HANDLER ( data_w ) |
| 531 | 530 | { |
| 532 | | if ((offset & 0xe000)==0x6000) |
| 531 | if ((offset & 0x7e000)==0x76000) |
| 533 | 532 | { |
| 534 | | hsgpl_cartspace_w(device, offset, data); |
| 533 | hsgpl_cartspace_w(device, offset & 0xffff, data); |
| 535 | 534 | } |
| 536 | 535 | |
| 537 | 536 | // 1001 1wbb bbbb bba0 |
| 538 | | if ((offset & 0xfc01)==0x9c00) |
| 537 | if ((offset & 0x7fc01)==0x79c00) |
| 539 | 538 | { |
| 540 | | hsgpl_grom_w(device, offset, data); |
| 539 | hsgpl_grom_w(device, offset & 0xffff, data); |
| 541 | 540 | } |
| 542 | 541 | } |
| 543 | 542 | |
src/mess/machine/ti99/genboard.c
| r10339 | r10340 | |
| 74 | 74 | int keep_keybuf; |
| 75 | 75 | int zero_wait; |
| 76 | 76 | |
| 77 | int genmod; |
| 78 | |
| 77 | 79 | /* GROM simulation */ |
| 78 | 80 | int grom_address; |
| 79 | 81 | int gromraddr_LSB; |
| r10339 | r10340 | |
| 324 | 326 | // speech |
| 325 | 327 | // ++++ ++-- ---- ---+ |
| 326 | 328 | // 1001 0000 0000 0000 |
| 327 | | // 0x17000 represents the proper AMA/B/C setting; will be masked away currently |
| 328 | | ti99_peb_data_rz(board->peribox, offset | 0x17000, &value); |
| 329 | // We need to add the address prefix bits |
| 330 | ti99_peb_data_rz(board->peribox, offset | ((board->genmod)? 0x170000 : 0x070000), &value); |
| 329 | 331 | return value; |
| 330 | 332 | } |
| 331 | 333 | if ((offset & 0xfc01)==0x9800) |
| r10339 | r10340 | |
| 364 | 366 | |
| 365 | 367 | physaddr |= (offset & 0x1fff); |
| 366 | 368 | |
| 367 | | if ((physaddr & 0x180000)==0x000000) |
| 369 | if (((physaddr & 0x180000)==0x000000) && !board->genmod) |
| 368 | 370 | { |
| 369 | | // DRAM. One wait state. |
| 371 | // DRAM. One wait state (only if not GenMod, in which case we route this to the P-Box) |
| 370 | 372 | cpu_adjust_icount(board->cpu, -4); |
| 371 | 373 | value = board->dram[physaddr & 0x07ffff]; |
| 372 | 374 | return value; |
| 373 | 375 | } |
| 374 | | if ((physaddr & 0x180000)==0x080000) |
| 375 | | { |
| 376 | | // Memex in PEB |
| 377 | | // 0 1aaa xxxx xxxx xxxx xxxx |
| 378 | | ti99_peb_data_rz(board->peribox, physaddr, &value); |
| 379 | | return value; |
| 380 | | } |
| 381 | | if ((physaddr & 0x180000)==0x100000) |
| 382 | | { |
| 383 | | // 1 0aaa xxxx xxxx xxxx xxxx p-box address block |
| 384 | | // Cards in PEB (aaa = AMC, AMB, AMA) |
| 385 | | ti99_peb_data_rz(board->peribox, physaddr, &value); |
| 386 | | return value; |
| 387 | | } |
| 388 | 376 | |
| 389 | 377 | if ((physaddr & 0x1e0000)==0x1e0000) |
| 390 | 378 | { |
| r10339 | r10340 | |
| 394 | 382 | return value; |
| 395 | 383 | } |
| 396 | 384 | |
| 397 | | if ((physaddr & board->sram_mask)==board->sram_val) |
| 385 | if (((physaddr & board->sram_mask)==board->sram_val) && !board->genmod) |
| 398 | 386 | { |
| 399 | 387 | // 1 100. .... .... .... .... on-board sram (128K) -+ |
| 400 | 388 | // 1 101. .... .... .... .... on-board sram (128K) -+-- maximum SRAM expansion |
| r10339 | r10340 | |
| 402 | 390 | // 1 1101 0... .... .... .... on-board sram (32K) - additional 32 KiB required for MDOS 2.50s and higher |
| 403 | 391 | // 1 1101 1... .... .... .... on-board sram (32K) - standard setup |
| 404 | 392 | // NOTE: This must be tested after the EPROM test above |
| 393 | // Also note that we assume a full Genmod which also replaces the SRAM |
| 405 | 394 | value = board->sram[physaddr & 0x00ffff]; |
| 406 | 395 | return value; |
| 407 | 396 | } |
| 408 | 397 | |
| 409 | | return 0; |
| 398 | // Route everything else to the P-Box |
| 399 | // 0x000000-0x07ffff for the stock Geneve (AMC,AMB,AMA,A0 ...,A15) |
| 400 | // 0x000000-0x1fffff for the GenMod.(AME,AMD,AMC,AMB,AMA,A0 ...,A15) |
| 401 | // Add a wait state (if not GenMod) |
| 402 | if (board->genmod) |
| 403 | { |
| 404 | physaddr = (physaddr & 0x001fffff); // 21 bit address for Genmod (with AMA..AME) |
| 405 | } |
| 406 | else |
| 407 | { |
| 408 | // Add one wait state |
| 409 | cpu_adjust_icount(board->cpu,-4); |
| 410 | physaddr = (physaddr & 0x0007ffff); // 19 bit address (with AMA..AMC) |
| 411 | } |
| 412 | ti99_peb_data_rz(board->peribox, physaddr, &value); |
| 413 | return value; |
| 410 | 414 | } |
| 411 | 415 | /* |
| 412 | 416 | Geneve mode: |
| r10339 | r10340 | |
| 504 | 508 | // speech |
| 505 | 509 | // ++++ ++-- ---- ---+ |
| 506 | 510 | // 1001 0100 0000 0000 |
| 507 | | ti99_peb_data_w(board->peribox, offset | 0x17000, data); |
| 511 | // We need to add the address prefix bits |
| 512 | ti99_peb_data_w(board->peribox, offset | ((board->genmod)? 0x170000 : 0x070000), data); |
| 508 | 513 | return; |
| 509 | 514 | } |
| 510 | 515 | if ((offset & 0xfc01)==0x9c00) |
| r10339 | r10340 | |
| 553 | 558 | |
| 554 | 559 | physaddr |= offset & 0x1fff; |
| 555 | 560 | |
| 556 | | if ((physaddr & 0x180000)==0x000000) |
| 561 | if (((physaddr & 0x180000)==0x000000) && !board->genmod) |
| 557 | 562 | { |
| 558 | | // DRAM write. One wait state. |
| 563 | // DRAM write. One wait state. (only for normal Geneve) |
| 559 | 564 | cpu_adjust_icount(board->cpu, -4); |
| 560 | 565 | board->dram[physaddr & 0x07ffff] = data; |
| 561 | 566 | return; |
| 562 | 567 | } |
| 563 | | if ((physaddr & 0x180000)==0x080000) |
| 564 | | { |
| 565 | | // Memex in PEB |
| 566 | | ti99_peb_data_w(board->peribox, physaddr, data); |
| 567 | | return; |
| 568 | | } |
| 569 | | if ((physaddr & 0x180000)==0x100000) |
| 570 | | { |
| 571 | | // Classic cards in PEB |
| 572 | | ti99_peb_data_w(board->peribox, physaddr, data); |
| 573 | | return; |
| 574 | | } |
| 575 | 568 | |
| 576 | 569 | if ((physaddr & 0x1e0000)==0x1e0000) |
| 577 | 570 | { |
| r10339 | r10340 | |
| 581 | 574 | return; |
| 582 | 575 | } |
| 583 | 576 | |
| 584 | | if ((physaddr & board->sram_mask)==board->sram_val) |
| 577 | if (((physaddr & board->sram_mask)==board->sram_val) && !board->genmod) |
| 585 | 578 | { |
| 586 | 579 | // 1 100. .... .... .... .... on-board sram (128K) -+ |
| 587 | 580 | // 1 101. .... .... .... .... on-board sram (128K) -+-- maximum SRAM expansion |
| r10339 | r10340 | |
| 592 | 585 | board->sram[physaddr & 0x00ffff] = data; |
| 593 | 586 | return; |
| 594 | 587 | } |
| 588 | |
| 589 | // Route everything else to the P-Box |
| 590 | // Add a wait state |
| 591 | if (board->genmod) |
| 592 | { |
| 593 | physaddr = (physaddr & 0x001fffff); // 21 bit address for Genmod |
| 594 | } |
| 595 | else |
| 596 | { |
| 597 | cpu_adjust_icount(board->cpu,-4); |
| 598 | // only AMA, AMB, AMC are used; AMD=0, AME=1 |
| 599 | physaddr = (physaddr & 0x0007ffff) | 0x00100000; // 19 bit address |
| 600 | } |
| 601 | ti99_peb_data_w(board->peribox, physaddr, data); |
| 595 | 602 | } |
| 596 | 603 | |
| 597 | 604 | /* |
| r10339 | r10340 | |
| 637 | 644 | 1 111. ..1. .... .... .... on-board boot2 |
| 638 | 645 | |
| 639 | 646 | |
| 647 | Mapping issues (in original hardware) |
| 648 | |
| 649 | The standard Geneve routes all accesses from 0x040000 to 0x17ffff to the P-Box. |
| 650 | The standard TI puts AMA/B/C to 1, and all cards decode these, assuming them |
| 651 | to be set to 1. |
| 652 | |
| 653 | The 2 MiB Memex occupies the whole address space, which means that some |
| 654 | portions of it must remain unaccessible. As the standard Geneve only uses the |
| 655 | AMA/B/C lines but cannot use AMD/E, the 2 MiB reduce to 512 KiB, mirrored three |
| 656 | more times. |
| 657 | |
| 658 | Pages |
| 659 | 00-3f are internal (DRAM) |
| 660 | 40-7f are 512 KiB usable for the Memex |
| 661 | 80-bf are a mirror of 40-7f |
| 662 | c0-ff are internal (SRAM, EPROM) |
| 663 | |
| 664 | However, pages 70-7f mirror to pages b0-bf which are used for the legacy cards. |
| 665 | Thus they have to be blocked. If only cards are used which occupy the address |
| 666 | space 4000-5fff, only page ba needs to be blocked (bc for the speech synthesizer). |
| 667 | |
| 668 | If there is a card in the system which does not decode AMA/B/C, all pages must |
| 669 | be blocked that mirror to ba on a 16-bit base: 4a, 5a, 6a, 7a, 8a, 9a, aa, ba. |
| 670 | |
| 640 | 671 | */ |
| 641 | 672 | |
| 642 | 673 | /**************************************************************************** |
| r10339 | r10340 | |
| 716 | 747 | } |
| 717 | 748 | } |
| 718 | 749 | else |
| 750 | { |
| 719 | 751 | ti99_peb_cru_w(board->peribox, addroff, data); |
| 752 | } |
| 720 | 753 | } |
| 721 | 754 | |
| 722 | 755 | |
| r10339 | r10340 | |
| 1230 | 1263 | { |
| 1231 | 1264 | logerror("Starting Geneve board\n"); |
| 1232 | 1265 | genboard_state *board = get_safe_token(device); |
| 1266 | |
| 1233 | 1267 | board->video = device->siblingdevice("video"); |
| 1234 | 1268 | board->tms9901 = device->siblingdevice("tms9901"); |
| 1235 | 1269 | board->peribox = device->siblingdevice("peribox"); |
| r10339 | r10340 | |
| 1294 | 1328 | board->cartridge7_writable = 0; |
| 1295 | 1329 | for (int i=0; i < 8; i++) board->map[i] = 0; |
| 1296 | 1330 | |
| 1297 | | if (input_port_read(device->machine, "BOOTROM")==0) |
| 1331 | board->genmod = FALSE; |
| 1332 | if (input_port_read(device->machine, "MODE")==0) |
| 1298 | 1333 | { |
| 1299 | | board->eprom = device->machine->region("maincpu")->base() + 0x4000; |
| 1334 | switch (input_port_read(device->machine, "BOOTROM")) |
| 1335 | { |
| 1336 | case GENEVE_098: |
| 1337 | logerror("Geneve 9640: Using 0.98 boot eprom\n"); |
| 1338 | board->eprom = device->machine->region("maincpu")->base() + 0x4000; |
| 1339 | break; |
| 1340 | case GENEVE_100: |
| 1341 | logerror("Geneve 9640: Using 1.00 boot eprom\n"); |
| 1342 | board->eprom = device->machine->region("maincpu")->base(); |
| 1343 | break; |
| 1344 | } |
| 1300 | 1345 | } |
| 1346 | else |
| 1347 | { |
| 1348 | logerror("Geneve 9640: Using GenMod modification\n"); |
| 1349 | board->eprom = device->machine->region("maincpu")->base() + 0x8000; |
| 1350 | if (board->eprom[0] != 0xf0) |
| 1351 | { |
| 1352 | fatalerror("GenMod boot rom missing.\n"); |
| 1353 | } |
| 1354 | board->genmod = TRUE; |
| 1355 | } |
| 1301 | 1356 | |
| 1302 | 1357 | switch (input_port_read(device->machine, "SRAM")) |
| 1303 | 1358 | { |
src/mess/machine/ti99/hfdc.c
| r10339 | r10340 | |
| 32 | 32 | /* When TRUE, card is accessible. Indicated by a LED. */ |
| 33 | 33 | int selected; |
| 34 | 34 | |
| 35 | /* Card select mask. Required to support Genmod. */ |
| 36 | int select_mask; |
| 37 | |
| 38 | /* Card select mask. Required to support Genmod. */ |
| 39 | int select_value; |
| 40 | |
| 35 | 41 | /* When TRUE, triggers motor monoflop. */ |
| 36 | 42 | int strobe_motor; |
| 37 | 43 | |
| r10339 | r10340 | |
| 162 | 168 | /* CRU bits */ |
| 163 | 169 | if (card->cru_select) |
| 164 | 170 | { |
| 165 | | /* DIP switches. Logic levels are inverted (on->0, off->1). CRU |
| 166 | | bit order is the reverse of DIP-switch order, too (dip 1 -> bit 7, |
| 167 | | dip 8 -> bit 0). |
| 168 | | |
| 169 | | MZ: 00 should not be used since there is a bug in the |
| 170 | | DSR of the HFDC which causes problems with SD disks |
| 171 | | (controller tries DD and then fails to fall back to SD) */ |
| 171 | // DIP switches. Logic levels are inverted (on->0, off->1). CRU |
| 172 | // bit order is the reverse of DIP-switch order, too (dip 1 -> bit 7, |
| 173 | // dip 8 -> bit 0). |
| 174 | // MZ: 00 should not be used since there is a bug in the |
| 175 | // DSR of the HFDC which causes problems with SD disks |
| 176 | // (controller tries DD and then fails to fall back to SD) */ |
| 172 | 177 | reply = ~(input_port_read(device->machine, "HFDCDIP")); |
| 173 | 178 | } |
| 174 | 179 | else |
| r10339 | r10340 | |
| 281 | 286 | { |
| 282 | 287 | ti99_hfdc_state *card = get_safe_token(device); |
| 283 | 288 | |
| 284 | | if (card->selected && (offset & 0xe000)==0x4000) |
| 289 | if (card->selected && ((offset & card->select_mask)==card->select_value)) |
| 285 | 290 | { |
| 286 | 291 | /* DSR region */ |
| 287 | 292 | if ((offset & 0x1000)==0x0000) |
| r10339 | r10340 | |
| 336 | 341 | static WRITE8_DEVICE_HANDLER( data_w ) |
| 337 | 342 | { |
| 338 | 343 | ti99_hfdc_state *card = get_safe_token(device); |
| 339 | | if (card->selected && (offset & 0xe000)==0x4000) |
| 344 | if (card->selected && ((offset & card->select_mask)==card->select_value)) |
| 340 | 345 | { |
| 341 | 346 | // Tape: 4fc0...4fcf |
| 342 | 347 | if ((offset & 0x1ff0)==TAPE_ADDR) |
| r10339 | r10340 | |
| 683 | 688 | int success = mount_card(peb, device, &hfdc_card, get_pebcard_config(device)->slot); |
| 684 | 689 | if (!success) return; |
| 685 | 690 | |
| 691 | card->select_mask = 0x7e000; |
| 692 | card->select_value = 0x74000; |
| 693 | |
| 694 | if (input_port_read(device->machine, "MODE")==GENMOD) |
| 695 | { |
| 696 | // GenMod card modification |
| 697 | logerror("HFDC: Configuring for GenMod\n"); |
| 698 | card->select_mask = 0x1fe000; |
| 699 | card->select_value = 0x174000; |
| 700 | } |
| 701 | |
| 686 | 702 | // Allocate 32 KiB for on-board buffer memory |
| 687 | 703 | if (card->ram==NULL) |
| 688 | 704 | { |
src/mess/machine/ti99/peribox.c
| r10339 | r10340 | |
| 130 | 130 | #include "hsgpl.h" |
| 131 | 131 | #include "spchsyn.h" |
| 132 | 132 | #include "evpc.h" |
| 133 | #include "memex.h" |
| 133 | 134 | |
| 134 | 135 | #include "imagedev/flopdrv.h" |
| 135 | 136 | #include "imagedev/harddriv.h" |
| r10339 | r10340 | |
| 166 | 167 | |
| 167 | 168 | int highest; |
| 168 | 169 | |
| 170 | /* Address bits that are preset to 1 (AMA/AMB/AMC) */ |
| 171 | int address_prefix; |
| 172 | |
| 169 | 173 | // Callback to the main system |
| 170 | 174 | ti99_peb_connect lines; |
| 171 | 175 | |
| r10339 | r10340 | |
| 289 | 293 | for (i=1; i <= peb->highest; i++) |
| 290 | 294 | { |
| 291 | 295 | if ((peb->slot[i].card != NULL) && (*peb->slot[i].intf->card_read_data)) |
| 292 | | (*peb->slot[i].intf->card_read_data)(peb->slot[i].card, offset, value); |
| 296 | (*peb->slot[i].intf->card_read_data)(peb->slot[i].card, peb->address_prefix | offset, value); |
| 293 | 297 | } |
| 294 | 298 | } |
| 295 | 299 | |
| r10339 | r10340 | |
| 300 | 304 | for (i=1; i <= peb->highest; i++) |
| 301 | 305 | { |
| 302 | 306 | if ((peb->slot[i].card != NULL) && (*peb->slot[i].intf->card_write_data)) |
| 303 | | (*peb->slot[i].intf->card_write_data)(peb->slot[i].card, offset, data); |
| 307 | (*peb->slot[i].intf->card_write_data)(peb->slot[i].card, peb->address_prefix | offset, data); |
| 304 | 308 | } |
| 305 | 309 | } |
| 306 | 310 | |
| r10339 | r10340 | |
| 336 | 340 | for (i=1; i <= peb->highest; i++) |
| 337 | 341 | { |
| 338 | 342 | if ((peb->slot[i].card != NULL) && (*peb->slot[i].intf->card_read_data16)) |
| 339 | | (*peb->slot[i].intf->card_read_data16)(peb->slot[i].card, offset, value); |
| 343 | (*peb->slot[i].intf->card_read_data16)(peb->slot[i].card, peb->address_prefix | offset, value); |
| 340 | 344 | } |
| 341 | 345 | } |
| 342 | 346 | |
| r10339 | r10340 | |
| 350 | 354 | for (i=1; i <= peb->highest; i++) |
| 351 | 355 | { |
| 352 | 356 | if ((peb->slot[i].card != NULL) && (*peb->slot[i].intf->card_write_data16)) |
| 353 | | (*peb->slot[i].intf->card_write_data16)(peb->slot[i].card, offset, data); |
| 357 | (*peb->slot[i].intf->card_write_data16)(peb->slot[i].card, peb->address_prefix | offset, data); |
| 354 | 358 | } |
| 355 | 359 | } |
| 356 | 360 | |
| r10339 | r10340 | |
| 401 | 405 | devcb_resolve_write_line(&peb->lines.ready, &ready, device); |
| 402 | 406 | devcb_resolve_write_line(&peb->lines.inta, &inta, device); |
| 403 | 407 | devcb_resolve_write_line(&peb->lines.intb, &intb, device); |
| 408 | |
| 409 | peb->address_prefix = (pebconf->amx << 16); |
| 404 | 410 | } |
| 405 | 411 | |
| 406 | 412 | static DEVICE_STOP( ti99_peb ) |
| r10339 | r10340 | |
| 524 | 530 | MACHINE_CONFIG_END |
| 525 | 531 | |
| 526 | 532 | static MACHINE_CONFIG_FRAGMENT( geneve_peb ) |
| 527 | | MCFG_PBOXCARD_ADD( "speech", TISPEECH, 1 ) |
| 528 | | MCFG_PBOXCARD_ADD( "usbsmart", USBSMART, 2 ) |
| 529 | | MCFG_PBOXCARD_ADD( "ide", TNIDE, 3 ) |
| 533 | MCFG_PBOXCARD_ADD( "memex", GENMEMEX, 1 ) |
| 534 | MCFG_PBOXCARD_ADD( "speech", TISPEECH, 2 ) |
| 535 | MCFG_PBOXCARD_ADD( "usbsmart", USBSMART, 3 ) |
| 536 | MCFG_PBOXCARD_ADD( "ide", TNIDE, 4 ) |
| 530 | 537 | MCFG_PBOXCARD_ADD( "rs232_card", TIRS232, 6 ) |
| 531 | 538 | MCFG_PBOXCARD_ADD( "ti_fdc", TIFDC, 7 ) |
| 532 | 539 | MCFG_PBOXCARD_ADD( "hfdc", HFDC, 7 ) |
src/mess/machine/ti99/memex.c
| r0 | r10340 | |
| 1 | /*
|
| 2 | Geneve "Memex" memory expansion
|
| 3 | Michael Zapf, February 2011
|
| 4 | */
|
| 5 | |
| 6 | #include "emu.h"
|
| 7 | #include "peribox.h"
|
| 8 | #include "memex.h"
|
| 9 | |
| 10 | typedef ti99_pebcard_config gen_memex_config;
|
| 11 | |
| 12 | typedef struct _gen_memex_state
|
| 13 | {
|
| 14 | UINT8 *memory;
|
| 15 | UINT8 dip_switch[8];
|
| 16 | int genmod;
|
| 17 | } gen_memex_state;
|
| 18 | |
| 19 | INLINE gen_memex_state *get_safe_token(device_t *device)
|
| 20 | {
|
| 21 | assert(device != NULL);
|
| 22 | assert(device->type() == GENMEMEX);
|
| 23 | |
| 24 | return (gen_memex_state *)downcast<legacy_device_base *>(device)->token();
|
| 25 | }
|
| 26 | |
| 27 | static int access_enabled(gen_memex_state *card, offs_t offset)
|
| 28 | {
|
| 29 | // 1 0111 .... .... .... .... p-box address block 0xxx ... fxxx
|
| 30 | // first two bits are AME, AMD bits available on Genmod only
|
| 31 | // if AMD, AME are not available we assume AMD=0, AME=1
|
| 32 | // must be set on the Geneve board
|
| 33 | // Some traditional cards will not decode the AMx lines, so
|
| 34 | // we may have to lock out those areas
|
| 35 | int page = (offset >> 13)&0xff;
|
| 36 | int index = 0;
|
| 37 | |
| 38 | // SW2: "off" locks
|
| 39 | // 10xxx010
|
| 40 | // 10111010 also locked when "on"
|
| 41 | if (page == 0xba) return FALSE;
|
| 42 | if ((page & 0xc7)==0x82 && card->dip_switch[1]==FALSE)
|
| 43 | return FALSE;
|
| 44 | |
| 45 | // SW3: 111010xx 0=enabled 1=locked out
|
| 46 | // SW4: 111011xx
|
| 47 | // SW5: 111100xx
|
| 48 | // SW6: 111101xx
|
| 49 | // SW7: 111110xx
|
| 50 | // SW8: 111111xx
|
| 51 | |
| 52 | index = ((page >> 2)&0x3f);
|
| 53 | if (index >= 0x3a && index <= 0x3f)
|
| 54 | {
|
| 55 | if (card->dip_switch[index - 0x38]==0) return TRUE;
|
| 56 | else
|
| 57 | {
|
| 58 | return FALSE;
|
| 59 | }
|
| 60 | }
|
| 61 | return TRUE;
|
| 62 | }
|
| 63 | |
| 64 | /*
|
| 65 | Memory read. The memory is at locations 0x000000-0x1fffff. Some of these
|
| 66 | regions are hidden by onboard devices of the Geneve. We must block some
|
| 67 | areas which would otherwise interfere with peripheral cards.
|
| 68 | |
| 69 | Note that the incomplete decoding of the standard Geneve must be
|
| 70 | considered.
|
| 71 | */
|
| 72 | static READ8Z_DEVICE_HANDLER( memex_rz )
|
| 73 | {
|
| 74 | gen_memex_state *card = get_safe_token(device);
|
| 75 | |
| 76 | /* If not Genmod, add the upper two address bits 10 */
|
| 77 | if (!card->genmod) offset |= 0x100000;
|
| 78 | |
| 79 | // The card is accessed for all addresses in the address space
|
| 80 | if (access_enabled(card, offset))
|
| 81 | {
|
| 82 | *value = card->memory[offset];
|
| 83 | }
|
| 84 | }
|
| 85 | |
| 86 | /*
|
| 87 | Memory write
|
| 88 | */
|
| 89 | static WRITE8_DEVICE_HANDLER( memex_w )
|
| 90 | {
|
| 91 | gen_memex_state *card = get_safe_token(device);
|
| 92 | |
| 93 | /* If not Genmod, add the upper two address bits 10 */
|
| 94 | if (!card->genmod) offset |= 0x100000;
|
| 95 | |
| 96 | // The card is accessed for all addresses in the address space
|
| 97 | if (access_enabled(card, offset))
|
| 98 | {
|
| 99 | card->memory[offset] = data;
|
| 100 | }
|
| 101 | }
|
| 102 | |
| 103 | /**************************************************************************/
|
| 104 | |
| 105 | static const ti99_peb_card memex_card =
|
| 106 | {
|
| 107 | memex_rz, memex_w, // memory access read/write
|
| 108 | NULL, NULL, // CRU access (none here)
|
| 109 | NULL, NULL, // SENILA/B access (none here)
|
| 110 | NULL, NULL // 16 bit access (none here)
|
| 111 | };
|
| 112 | |
| 113 | static DEVICE_START( gen_memex )
|
| 114 | {
|
| 115 | gen_memex_state *card = get_safe_token(device);
|
| 116 | card->memory=NULL;
|
| 117 | }
|
| 118 | |
| 119 | static DEVICE_STOP( gen_memex )
|
| 120 | {
|
| 121 | gen_memex_state *card = get_safe_token(device);
|
| 122 | if (card->memory) free(card->memory);
|
| 123 | }
|
| 124 | |
| 125 | static DEVICE_RESET( gen_memex )
|
| 126 | {
|
| 127 | gen_memex_state *card = get_safe_token(device);
|
| 128 | /* Register the card */
|
| 129 | device_t *peb = device->owner();
|
| 130 | |
| 131 | if (input_port_read(device->machine, "EXTRAM")==1)
|
| 132 | {
|
| 133 | int success = mount_card(peb, device, &memex_card, get_pebcard_config(device)->slot);
|
| 134 | if (!success) return;
|
| 135 | |
| 136 | if (card->memory==NULL)
|
| 137 | {
|
| 138 | // Allocate 2 MiB
|
| 139 | card->memory = (UINT8*)malloc(0x200000);
|
| 140 | }
|
| 141 | |
| 142 | UINT8 dips = input_port_read(device->machine, "MEMEXDIPS");
|
| 143 | for (int i=0; i < 8; i++)
|
| 144 | {
|
| 145 | card->dip_switch[i] = ((dips & 0x01)!=0x00);
|
| 146 | dips = dips >> 1;
|
| 147 | }
|
| 148 | |
| 149 | card->genmod = input_port_read(device->machine, "MODE");
|
| 150 | }
|
| 151 | }
|
| 152 | |
| 153 | static const char DEVTEMPLATE_SOURCE[] = __FILE__;
|
| 154 | |
| 155 | #define DEVTEMPLATE_ID(p,s) p##gen_memex##s
|
| 156 | #define DEVTEMPLATE_FEATURES DT_HAS_START | DT_HAS_STOP | DT_HAS_RESET | DT_HAS_INLINE_CONFIG
|
| 157 | #define DEVTEMPLATE_NAME "Geneve Memex Memory Expansion Card"
|
| 158 | #define DEVTEMPLATE_FAMILY "Peripheral expansion"
|
| 159 | #include "devtempl.h"
|
| 160 | |
| 161 | DEFINE_LEGACY_DEVICE( GENMEMEX, gen_memex );
|
| 162 | |
src/mess/machine/ti99/peribox.h
| r10339 | r10340 | |
| 13 | 13 | inta: callback called when the state of INTA changes (may be NULL) |
| 14 | 14 | intb: callback called when the state of INTB changes (may be NULL) |
| 15 | 15 | ready: callback called when the state of INTB changes (may be NULL) |
| 16 | amx: Determines whether the AMA, AMB, and AMC address bus extension lines |
| 17 | must be preset to some value. The standard TI Flex Cable Interface |
| 18 | locks these valuies to 1. The Geneve, however, can drive these lines. |
| 16 | 19 | */ |
| 17 | 20 | |
| 18 | 21 | typedef struct _ti99_peb_config |
| 19 | 22 | { |
| 20 | | write_line_device_func inta; |
| 21 | | write_line_device_func intb; |
| 22 | | write_line_device_func ready; |
| 23 | write_line_device_func inta; |
| 24 | write_line_device_func intb; |
| 25 | write_line_device_func ready; |
| 26 | int amx; |
| 23 | 27 | } ti99_peb_config; |
| 24 | 28 | |
| 25 | 29 | /* |
| r10339 | r10340 | |
| 128 | 132 | MCFG_DEVICE_ADD(_tag, PBOX4, 0) \ |
| 129 | 133 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, inta, _inta) \ |
| 130 | 134 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, intb, _intb) \ |
| 131 | | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) |
| 135 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) \ |
| 136 | MCFG_DEVICE_CONFIG_DATA32(ti99_peb_config, amx, 0x07) |
| 132 | 137 | |
| 133 | 138 | #define MCFG_PBOX4A_ADD(_tag, _inta, _intb, _ready) \ |
| 134 | 139 | MCFG_DEVICE_ADD(_tag, PBOX4A, 0) \ |
| 135 | 140 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, inta, _inta) \ |
| 136 | 141 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, intb, _intb) \ |
| 137 | | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) |
| 142 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) \ |
| 143 | MCFG_DEVICE_CONFIG_DATA32(ti99_peb_config, amx, 0x07) |
| 138 | 144 | |
| 139 | 145 | #define MCFG_PBOXEV_ADD(_tag, _inta, _intb, _ready) \ |
| 140 | 146 | MCFG_DEVICE_ADD(_tag, PBOXEV, 0) \ |
| 141 | 147 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, inta, _inta) \ |
| 142 | 148 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, intb, _intb) \ |
| 143 | | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) |
| 149 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) \ |
| 150 | MCFG_DEVICE_CONFIG_DATA32(ti99_peb_config, amx, 0x07) |
| 144 | 151 | |
| 145 | 152 | #define MCFG_PBOX8_ADD(_tag, _inta, _intb, _ready) \ |
| 146 | 153 | MCFG_DEVICE_ADD(_tag, PBOX8, 0) \ |
| 147 | 154 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, inta, _inta) \ |
| 148 | 155 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, intb, _intb) \ |
| 149 | | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) |
| 156 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) \ |
| 157 | MCFG_DEVICE_CONFIG_DATA32(ti99_peb_config, amx, 0x07) |
| 150 | 158 | |
| 151 | 159 | #define MCFG_PBOXSG_ADD(_tag, _inta, _intb, _ready) \ |
| 152 | 160 | MCFG_DEVICE_ADD(_tag, PBOXSG, 0) \ |
| 153 | 161 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, inta, _inta) \ |
| 154 | 162 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, intb, _intb) \ |
| 155 | | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) |
| 163 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) \ |
| 164 | MCFG_DEVICE_CONFIG_DATA32(ti99_peb_config, amx, 0x07) |
| 156 | 165 | |
| 157 | 166 | #define MCFG_PBOXGEN_ADD(_tag, _inta, _intb, _ready) \ |
| 158 | 167 | MCFG_DEVICE_ADD(_tag, PBOXGEN, 0) \ |
| 159 | 168 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, inta, _inta) \ |
| 160 | 169 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, intb, _intb) \ |
| 161 | | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) |
| 170 | MCFG_DEVICE_CONFIG_DATAPTR(ti99_peb_config, ready, _ready) \ |
| 171 | MCFG_DEVICE_CONFIG_DATA32(ti99_peb_config, amx, 0x00) |
| 162 | 172 | |
| 163 | 173 | #endif /* __PBOX__ */ |
src/mess/drivers/geneve.c
| r10339 | r10340 | |
| 241 | 241 | |
| 242 | 242 | /* 101-key PC XT keyboard + TI joysticks */ |
| 243 | 243 | static INPUT_PORTS_START(geneve) |
| 244 | | PORT_START( "BOOTROM" ) /* config */ |
| 245 | | PORT_CONFNAME( 0x01, 0x00, "Boot ROM" ) |
| 246 | | PORT_CONFSETTING( 0x00, "Version 0.9" ) |
| 247 | | PORT_CONFSETTING( 0x01, "Version 1.0" ) |
| 248 | 244 | |
| 245 | PORT_START( "MODE" ) |
| 246 | PORT_CONFNAME( 0x01, 0x00, "Operating mode" ) |
| 247 | PORT_CONFSETTING( 0x00, "Standard" ) |
| 248 | PORT_CONFSETTING( GENMOD, "GenMod" ) |
| 249 | |
| 250 | PORT_START( "BOOTROM" ) |
| 251 | PORT_CONFNAME( 0x01, 0x00, "Boot ROM" ) PORT_CONDITION( "MODE", 0x01, PORTCOND_EQUALS, 0x00 ) |
| 252 | PORT_CONFSETTING( 0x00, "Version 0.98" ) |
| 253 | PORT_CONFSETTING( 0x01, "Version 1.00" ) |
| 254 | |
| 249 | 255 | PORT_START( "SPEECH" ) |
| 250 | 256 | PORT_CONFNAME( 0x01, 0x00, "Speech synthesizer" ) |
| 251 | 257 | PORT_CONFSETTING( 0x00, DEF_STR( Off ) ) |
| 252 | 258 | PORT_CONFSETTING( 0x01, DEF_STR( On ) ) |
| 253 | 259 | |
| 254 | 260 | PORT_START( "SRAM" ) |
| 255 | | PORT_CONFNAME( 0x03, 0x01, "Onboard SRAM" ) |
| 261 | PORT_CONFNAME( 0x03, 0x01, "Onboard SRAM" ) PORT_CONDITION( "MODE", 0x01, PORTCOND_EQUALS, 0x00 ) |
| 256 | 262 | PORT_CONFSETTING( 0x00, "32 KiB" ) |
| 257 | 263 | PORT_CONFSETTING( 0x01, "64 KiB" ) |
| 258 | 264 | PORT_CONFSETTING( 0x02, "384 KiB" ) |
| 259 | 265 | |
| 266 | PORT_START( "EXTRAM" ) |
| 267 | PORT_CONFNAME( 0x01, 0x01, "Memory expansion" ) |
| 268 | PORT_CONFSETTING( 0x00, DEF_STR( None ) ) |
| 269 | PORT_CONFSETTING( 0x01, "Memex 2 MiB" ) |
| 270 | |
| 260 | 271 | PORT_START( "DISKCTRL" ) |
| 261 | 272 | PORT_CONFNAME( 0x07, 0x03, "Disk controller" ) |
| 262 | 273 | PORT_CONFSETTING( 0x00, DEF_STR( None ) ) |
| r10339 | r10340 | |
| 279 | 290 | PORT_CONFSETTING( 0x00, DEF_STR( None ) ) |
| 280 | 291 | PORT_CONFSETTING( 0x01, "TI RS-232 card" ) |
| 281 | 292 | |
| 293 | PORT_START( "MEMEXDIPS" ) |
| 294 | PORT_DIPNAME( MDIP1, MDIP1, "MEMEX SW1" ) PORT_CONDITION( "EXTRAM", 0x01, PORTCOND_EQUALS, 0x01 ) |
| 295 | PORT_DIPSETTING( 0x00, "LED half-bright for 0 WS") |
| 296 | PORT_DIPSETTING( MDIP1, "LED full-bright") |
| 297 | PORT_DIPNAME( MDIP2, 0x00, "MEMEX SW2" ) PORT_CONDITION( "EXTRAM", 0x01, PORTCOND_EQUALS, 0x01 ) |
| 298 | PORT_DIPSETTING( 0x00, "Lock out all BA mirrors") |
| 299 | PORT_DIPSETTING( MDIP2, "Lock out page BA only") |
| 300 | PORT_DIPNAME( MDIP3, 0x00, "MEMEX SW3" ) PORT_CONDITION( "EXTRAM", 0x01, PORTCOND_EQUALS, 0x01 ) |
| 301 | PORT_DIPSETTING( 0x00, "Enable pages E8-EB") |
| 302 | PORT_DIPSETTING( MDIP3, "Lock out pages E8-EB") |
| 303 | PORT_DIPNAME( MDIP4, 0x00, "MEMEX SW4" ) PORT_CONDITION( "EXTRAM", 0x01, PORTCOND_EQUALS, 0x01 ) |
| 304 | PORT_DIPSETTING( 0x00, "Enable pages EC-EF") |
| 305 | PORT_DIPSETTING( MDIP4, "Lock out pages EC-EF") |
| 306 | PORT_DIPNAME( MDIP5, 0x00, "MEMEX SW5" ) PORT_CONDITION( "EXTRAM", 0x01, PORTCOND_EQUALS, 0x01 ) |
| 307 | PORT_DIPSETTING( 0x00, "Enable pages F0-F3") |
| 308 | PORT_DIPSETTING( MDIP5, "Lock out pages F0-F3") |
| 309 | PORT_DIPNAME( MDIP6, 0x00, "MEMEX SW6" ) PORT_CONDITION( "EXTRAM", 0x01, PORTCOND_EQUALS, 0x01 ) |
| 310 | PORT_DIPSETTING( 0x00, "Enable pages F4-F7") |
| 311 | PORT_DIPSETTING( MDIP6, "Lock out pages F4-F7") |
| 312 | PORT_DIPNAME( MDIP7, 0x00, "MEMEX SW7" ) PORT_CONDITION( "EXTRAM", 0x01, PORTCOND_EQUALS, 0x01 ) |
| 313 | PORT_DIPSETTING( 0x00, "Enable pages F8-FB") |
| 314 | PORT_DIPSETTING( MDIP7, "Lock out pages F8-FB") |
| 315 | PORT_DIPNAME( MDIP8, 0x00, "MEMEX SW8" ) PORT_CONDITION( "EXTRAM", 0x01, PORTCOND_EQUALS, 0x01 ) |
| 316 | PORT_DIPSETTING( 0x00, "Enable pages FC-FF") |
| 317 | PORT_DIPSETTING( MDIP8, "Lock out pages FC-FF") |
| 318 | |
| 282 | 319 | PORT_START( "HFDCDIP" ) |
| 283 | 320 | PORT_DIPNAME( 0xff, 0x55, "HFDC drive config" ) PORT_CONDITION( "DISKCTRL", 0x07, PORTCOND_EQUALS, 0x03 ) |
| 284 | 321 | PORT_DIPSETTING( 0x00, "40 track, 16 ms") |
| r10339 | r10340 | |
| 455 | 492 | |
| 456 | 493 | INPUT_PORTS_END |
| 457 | 494 | |
| 458 | | static DRIVER_INIT( genmod ) |
| 459 | | { |
| 460 | | /*has_genmod = TRUE;*/ |
| 461 | | } |
| 462 | | |
| 463 | 495 | static DRIVER_INIT( geneve ) |
| 464 | 496 | { |
| 465 | | /*has_genmod = FALSE;*/ |
| 466 | 497 | } |
| 467 | 498 | |
| 468 | 499 | static MACHINE_START( geneve ) |
| r10339 | r10340 | |
| 495 | 526 | MCFG_SOUND_ADD("soundgen", SN76496, 3579545) /* 3.579545 MHz */ |
| 496 | 527 | MCFG_SOUND_ROUTE(ALL_OUTPUTS, "mono", 0.75) |
| 497 | 528 | |
| 498 | | /* Peripheral Box. Take the same as the TI-99/4A. */ |
| 529 | /* Peripheral Box. Take the Geneve combo. */ |
| 499 | 530 | MCFG_PBOXGEN_ADD( "peribox", board_inta, board_intb, board_ready ) |
| 500 | 531 | |
| 532 | /* tms9901 */ |
| 501 | 533 | MCFG_TMS9901_ADD("tms9901", tms9901_wiring_geneve) |
| 502 | 534 | |
| 503 | | /* tms9901 */ |
| 535 | /* Main board. Slight mods for the GenMod system. */ |
| 504 | 536 | MCFG_GENEVE_BOARD_ADD("geneve_board") |
| 505 | 537 | MACHINE_CONFIG_END |
| 506 | 538 | |
| r10339 | r10340 | |
| 512 | 544 | |
| 513 | 545 | ROM_START(geneve) |
| 514 | 546 | /*CPU memory space*/ |
| 515 | | ROM_REGION(0x8000, "maincpu", 0) |
| 547 | ROM_REGION(0xc000, "maincpu", 0) |
| 516 | 548 | ROM_LOAD("genbt100.bin", 0x0000, 0x4000, CRC(8001e386) SHA1(b44618b54dabac3882543e18555d482b299e0109)) /* CPU ROMs */ |
| 517 | 549 | ROM_LOAD_OPTIONAL("genbt090.bin", 0x4000, 0x4000, CRC(b2e20df9) SHA1(2d5d09177afe97d63ceb3ad59b498b1c9e2153f7)) /* CPU ROMs */ |
| 550 | ROM_LOAD_OPTIONAL("gnmbt100.bin", 0x8000, 0x4000, CRC(19b89479) SHA1(6ef297eda78dc705946f6494e9d7e95e5216ec47)) /* CPU ROMs */ |
| 518 | 551 | ROM_END |
| 519 | 552 | |
| 520 | | ROM_START(genmod) |
| 521 | | /*CPU memory space*/ |
| 522 | | ROM_REGION(0x8000, "maincpu", 0) |
| 523 | | ROM_LOAD("gnmbt100.bin", 0x0000, 0x4000, CRC(19b89479) SHA1(6ef297eda78dc705946f6494e9d7e95e5216ec47)) /* CPU ROMs */ |
| 524 | | ROM_LOAD_OPTIONAL("genbt090.bin", 0x4000, 0x4000, CRC(b2e20df9) SHA1(2d5d09177afe97d63ceb3ad59b498b1c9e2153f7)) /* CPU ROMs */ |
| 553 | /*ROM_START(genmod) |
| 554 | ROM_REGION(0x8000, "maincpu", 0) |
| 555 | ROM_LOAD("gnmbt100.bin", 0x0000, 0x4000, CRC(19b89479) SHA1(6ef297eda78dc705946f6494e9d7e95e5216ec47)) |
| 556 | ROM_LOAD_OPTIONAL("genbt090.bin", 0x4000, 0x4000, CRC(b2e20df9) SHA1(2d5d09177afe97d63ceb3ad59b498b1c9e2153f7)) |
| 525 | 557 | ROM_END |
| 526 | | |
| 558 | */ |
| 527 | 559 | /* YEAR NAME PARENT COMPAT MACHINE INPUT INIT COMPANY FULLNAME */ |
| 528 | 560 | COMP( 1987,geneve, 0, 0, geneve_60hz, geneve, geneve, "Myarc", "Geneve 9640" , 0) |
| 529 | | COMP( 1990,genmod, geneve, 0, geneve_60hz, geneve, genmod, "Myarc", "Geneve 9640 (with Genmod modification)" , 0) |
| 561 | //COMP( 1990,genmod, geneve, 0, genmod_60hz, geneve, geneve, "Myarc", "Geneve 9640 (with Genmod modification)" , 0) |
| 530 | 562 | |
src/mess/drivers/ti99_4x.c
| r10339 | r10340 | |
| 99 | 99 | PORT_CONFNAME( 0x07, 0x01, "RAM extension" ) |
| 100 | 100 | PORT_CONFSETTING( 0x00, DEF_STR( None ) ) |
| 101 | 101 | PORT_CONFSETTING( 0x01, "Console 32 KiB (16 bit)" ) |
| 102 | | PORT_CONFSETTING( 0x02, "TI Memexp card 32 KiB" ) |
| 102 | PORT_CONFSETTING( 0x02, "TI 32 KiB card" ) |
| 103 | 103 | PORT_CONFSETTING( 0x03, "Super AMS 1MiB" ) |
| 104 | 104 | PORT_CONFSETTING( 0x07, "Myarc 512 KiB" ) |
| 105 | 105 | |
| r10339 | r10340 | |
| 144 | 144 | PORT_CONFSETTING( 0x00, DEF_STR( Off ) ) |
| 145 | 145 | PORT_CONFSETTING( 0x01, "Mechatronics Mouse" ) |
| 146 | 146 | |
| 147 | // We do not want to show this setting; makes only sense for Geneve |
| 148 | PORT_START( "MODE" ) |
| 149 | PORT_CONFNAME( 0x01, 0x00, "Ext. cards modification" ) PORT_CONDITION( "HFDCDIP", 0x0f, PORTCOND_EQUALS, GM_NEVER ) |
| 150 | PORT_CONFSETTING( 0x00, "Standard" ) |
| 151 | PORT_CONFSETTING( GENMOD, "GenMod" ) |
| 152 | |
| 147 | 153 | PORT_START( "CARTSLOT" ) |
| 148 | 154 | PORT_DIPNAME( 0x0f, CART_AUTO, "Cartridge slot" ) |
| 149 | 155 | PORT_DIPSETTING( CART_AUTO, "Auto" ) |
| r10339 | r10340 | |
| 327 | 333 | PORT_DIPNAME( 0x01, 0x00, "EVPC Configuration" ) |
| 328 | 334 | PORT_DIPSETTING( 0x00, "DIP" ) |
| 329 | 335 | PORT_DIPSETTING( 0x01, "NOVRAM" ) |
| 330 | | |
| 336 | |
| 331 | 337 | PORT_START( "V9938-MEM" ) |
| 332 | 338 | PORT_CONFNAME( 0x01, 0x00, "V9938 RAM size" ) |
| 333 | 339 | PORT_CONFSETTING( 0x00, "128 KiB" ) |
| 334 | | PORT_CONFSETTING( 0x01, "192 KiB" ) |
| 340 | PORT_CONFSETTING( 0x01, "192 KiB" ) |
| 335 | 341 | |
| 336 | 342 | INPUT_PORTS_END |
| 337 | 343 | |
| r10339 | r10340 | |
| 343 | 349 | |
| 344 | 350 | PORT_START( "RAM" ) /* config */ |
| 345 | 351 | PORT_CONFNAME( 0x07, 0x01, "RAM extension" ) |
| 352 | PORT_CONFSETTING( 0x00, DEF_STR( None ) ) |
| 346 | 353 | PORT_CONFSETTING( 0x01, "Console 32 KiB (16 bit)" ) |
| 347 | | PORT_CONFSETTING( 0x02, "Texas Instruments 32 KiB" ) |
| 354 | PORT_CONFSETTING( 0x02, "TI 32 KiB card" ) |
| 348 | 355 | PORT_CONFSETTING( 0x03, "Super AMS 1MiB" ) |
| 349 | | PORT_CONFSETTING( 0x04, "Foundation 128 KiB" ) |
| 350 | | PORT_CONFSETTING( 0x05, "Foundation 512 KiB" ) |
| 351 | | PORT_CONFSETTING( 0x06, "Myarc 128 KiB" ) |
| 352 | 356 | PORT_CONFSETTING( 0x07, "Myarc 512 KiB" ) |
| 353 | 357 | |
| 354 | 358 | PORT_START( "SPEECH" ) |
| r10339 | r10340 | |
| 435 | 439 | PORT_DIPSETTING( 0x55, "80 track, 2 ms") |
| 436 | 440 | PORT_DIPSETTING( 0xff, "80 track HD, 2 ms") |
| 437 | 441 | |
| 442 | // We do not want to show this setting; makes only sense for Geneve |
| 443 | PORT_START( "MODE" ) |
| 444 | PORT_CONFNAME( 0x01, 0x00, "Ext. cards modification" ) PORT_CONDITION( "HFDCDIP", 0x0f, PORTCOND_EQUALS, GM_NEVER ) |
| 445 | PORT_CONFSETTING( 0x00, "Standard" ) |
| 446 | PORT_CONFSETTING( GENMOD, "GenMod" ) |
| 447 | |
| 438 | 448 | PORT_START( "DRVSPD" ) |
| 439 | 449 | PORT_CONFNAME( 0x01, 0x01, "Floppy and HD speed" ) PORT_CONDITION( "DISKCTRL", 0x07, PORTCOND_EQUALS, 0x03 ) |
| 440 | 450 | PORT_CONFSETTING( 0x00, "No delay") |