trunk/src/emu/machine/idectrl.c
| r23642 | r23643 | |
| 268 | 268 | |
| 269 | 269 | void ide_controller_device::read_buffer_empty() |
| 270 | 270 | { |
| 271 | ide_device_interface *dev = slot[cur_drive]->dev(); |
| 272 | |
| 271 | 273 | /* reset the totals */ |
| 272 | | buffer_offset = 0; |
| 274 | dev->buffer_offset = 0; |
| 273 | 275 | |
| 274 | 276 | /* clear the buffer ready and busy flag */ |
| 275 | 277 | status &= ~IDE_STATUS_BUFFER_READY; |
| r23642 | r23643 | |
| 305 | 307 | status &= ~IDE_STATUS_BUSY; |
| 306 | 308 | return; |
| 307 | 309 | } |
| 310 | |
| 308 | 311 | /* now do the read */ |
| 309 | | count = dev->read_sector(lba, buffer); |
| 312 | count = dev->read_sector(lba, dev->buffer); |
| 310 | 313 | |
| 311 | 314 | /* by default, mark the buffer ready and the seek complete */ |
| 312 | 315 | if (!verify_only) |
| r23642 | r23643 | |
| 413 | 416 | |
| 414 | 417 | void ide_controller_device::continue_write() |
| 415 | 418 | { |
| 419 | ide_device_interface *dev = slot[cur_drive]->dev(); |
| 420 | |
| 416 | 421 | /* reset the totals */ |
| 417 | | buffer_offset = 0; |
| 422 | dev->buffer_offset = 0; |
| 418 | 423 | |
| 419 | 424 | /* clear the buffer ready flag */ |
| 420 | 425 | status &= ~IDE_STATUS_BUFFER_READY; |
| r23642 | r23643 | |
| 448 | 453 | set_dmarq(0); |
| 449 | 454 | if (command == IDE_COMMAND_SECURITY_UNLOCK) |
| 450 | 455 | { |
| 451 | | if (user_password_enable && memcmp(buffer, user_password, 2 + 32) == 0) |
| 456 | if (user_password_enable && memcmp(dev->buffer, user_password, 2 + 32) == 0) |
| 452 | 457 | { |
| 453 | 458 | LOGPRINT(("IDE Unlocked user password\n")); |
| 454 | 459 | user_password_enable = 0; |
| 455 | 460 | } |
| 456 | | if (master_password_enable && memcmp(buffer, master_password, 2 + 32) == 0) |
| 461 | if (master_password_enable && memcmp(dev->buffer, master_password, 2 + 32) == 0) |
| 457 | 462 | { |
| 458 | 463 | LOGPRINT(("IDE Unlocked master password\n")); |
| 459 | 464 | master_password_enable = 0; |
| r23642 | r23643 | |
| 467 | 472 | if (i % 8 == 2) |
| 468 | 473 | mame_printf_debug("\n"); |
| 469 | 474 | |
| 470 | | mame_printf_debug("0x%02x, 0x%02x, ", buffer[i], buffer[i + 1]); |
| 471 | | //mame_printf_debug("0x%02x%02x, ", buffer[i], buffer[i + 1]); |
| 475 | mame_printf_debug("0x%02x, 0x%02x, ", dev->buffer[i], dev->buffer[i + 1]); |
| 476 | //mame_printf_debug("0x%02x%02x, ", dev->buffer[i], dev->buffer[i + 1]); |
| 472 | 477 | } |
| 473 | 478 | mame_printf_debug("\n"); |
| 474 | 479 | } |
| r23642 | r23643 | |
| 490 | 495 | dev->read_key(key); |
| 491 | 496 | |
| 492 | 497 | for (i=0; !bad && i<512; i++) |
| 493 | | bad = ((i < 2 || i >= 7) && buffer[i]) || ((i >= 2 && i < 7) && buffer[i] != key[i-2]); |
| 498 | bad = ((i < 2 || i >= 7) && dev->buffer[i]) || ((i >= 2 && i < 7) && dev->buffer[i] != key[i-2]); |
| 494 | 499 | |
| 495 | 500 | status &= ~IDE_STATUS_BUSY; |
| 496 | 501 | status &= ~IDE_STATUS_BUFFER_READY; |
| r23642 | r23643 | |
| 514 | 519 | int lba = dev->lba_address(), count = 0; |
| 515 | 520 | |
| 516 | 521 | /* now do the write */ |
| 517 | | count = dev->write_sector(lba, buffer); |
| 522 | count = dev->write_sector(lba, dev->buffer); |
| 518 | 523 | |
| 519 | 524 | /* by default, mark the buffer ready and the seek complete */ |
| 520 | 525 | status |= IDE_STATUS_BUFFER_READY; |
| r23642 | r23643 | |
| 592 | 597 | dev->cur_cylinder, dev->cur_head, dev->cur_sector, dev->lba_address(), sector_count)); |
| 593 | 598 | |
| 594 | 599 | /* reset the buffer */ |
| 595 | | buffer_offset = 0; |
| 600 | dev->buffer_offset = 0; |
| 596 | 601 | sectors_until_int = 1; |
| 597 | 602 | dma_active = 0; |
| 598 | 603 | verify_only = 0; |
| r23642 | r23643 | |
| 606 | 611 | dev->cur_cylinder, dev->cur_head, dev->cur_sector, dev->lba_address(), sector_count)); |
| 607 | 612 | |
| 608 | 613 | /* reset the buffer */ |
| 609 | | buffer_offset = 0; |
| 614 | dev->buffer_offset = 0; |
| 610 | 615 | sectors_until_int = 1; |
| 611 | 616 | dma_active = 0; |
| 612 | 617 | verify_only = 0; |
| r23642 | r23643 | |
| 621 | 626 | dev->cur_cylinder, dev->cur_head, dev->cur_sector, dev->lba_address(), sector_count)); |
| 622 | 627 | |
| 623 | 628 | /* reset the buffer */ |
| 624 | | buffer_offset = 0; |
| 629 | dev->buffer_offset = 0; |
| 625 | 630 | sectors_until_int = 1; |
| 626 | 631 | dma_active = 0; |
| 627 | 632 | verify_only = 1; |
| r23642 | r23643 | |
| 635 | 640 | dev->cur_cylinder, dev->cur_head, dev->cur_sector, dev->lba_address(), sector_count)); |
| 636 | 641 | |
| 637 | 642 | /* reset the buffer */ |
| 638 | | buffer_offset = 0; |
| 643 | dev->buffer_offset = 0; |
| 639 | 644 | sectors_until_int = sector_count; |
| 640 | 645 | dma_active = 1; |
| 641 | 646 | verify_only = 0; |
| r23642 | r23643 | |
| 650 | 655 | dev->cur_cylinder, dev->cur_head, dev->cur_sector, dev->lba_address(), sector_count)); |
| 651 | 656 | |
| 652 | 657 | /* reset the buffer */ |
| 653 | | buffer_offset = 0; |
| 658 | dev->buffer_offset = 0; |
| 654 | 659 | sectors_until_int = 1; |
| 655 | 660 | dma_active = 0; |
| 656 | 661 | |
| r23642 | r23643 | |
| 663 | 668 | dev->cur_cylinder, dev->cur_head, dev->cur_sector, dev->lba_address(), sector_count)); |
| 664 | 669 | |
| 665 | 670 | /* reset the buffer */ |
| 666 | | buffer_offset = 0; |
| 671 | dev->buffer_offset = 0; |
| 667 | 672 | sectors_until_int = 1; |
| 668 | 673 | dma_active = 0; |
| 669 | 674 | |
| r23642 | r23643 | |
| 676 | 681 | dev->cur_cylinder, dev->cur_head, dev->cur_sector, dev->lba_address(), sector_count)); |
| 677 | 682 | |
| 678 | 683 | /* reset the buffer */ |
| 679 | | buffer_offset = 0; |
| 684 | dev->buffer_offset = 0; |
| 680 | 685 | sectors_until_int = sector_count; |
| 681 | 686 | dma_active = 1; |
| 682 | 687 | |
| r23642 | r23643 | |
| 688 | 693 | LOGPRINT(("IDE Security Unlock\n")); |
| 689 | 694 | |
| 690 | 695 | /* reset the buffer */ |
| 691 | | buffer_offset = 0; |
| 696 | dev->buffer_offset = 0; |
| 692 | 697 | sectors_until_int = 0; |
| 693 | 698 | dma_active = 0; |
| 694 | 699 | |
| r23642 | r23643 | |
| 701 | 706 | LOGPRINT(("IDE Read features\n")); |
| 702 | 707 | |
| 703 | 708 | /* reset the buffer */ |
| 704 | | buffer_offset = 0; |
| 709 | dev->buffer_offset = 0; |
| 705 | 710 | sector_count = 1; |
| 706 | 711 | |
| 707 | 712 | /* build the features page */ |
| 708 | | memcpy(buffer, slot[cur_drive]->dev()->get_features(), sizeof(buffer)); |
| 713 | memcpy(dev->buffer, slot[cur_drive]->dev()->get_features(), sizeof(dev->buffer)); |
| 709 | 714 | |
| 710 | 715 | /* indicate everything is ready */ |
| 711 | 716 | status |= IDE_STATUS_BUFFER_READY; |
| r23642 | r23643 | |
| 796 | 801 | LOGPRINT(("IDE GNET Unlock 2\n")); |
| 797 | 802 | |
| 798 | 803 | /* reset the buffer */ |
| 799 | | buffer_offset = 0; |
| 804 | dev->buffer_offset = 0; |
| 800 | 805 | sectors_until_int = 0; |
| 801 | 806 | dma_active = 0; |
| 802 | 807 | |
| r23642 | r23643 | |
| 909 | 914 | if (dev == NULL) |
| 910 | 915 | return 0; |
| 911 | 916 | |
| 912 | | UINT16 result = buffer[buffer_offset++]; |
| 913 | | result |= buffer[buffer_offset++] << 8; |
| 917 | UINT16 result = dev->buffer[dev->buffer_offset++]; |
| 918 | result |= dev->buffer[dev->buffer_offset++] << 8; |
| 914 | 919 | |
| 915 | | if (buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| 920 | if (dev->buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| 916 | 921 | { |
| 917 | 922 | LOG(("%s:IDE completed DMA read\n", machine().describe_context())); |
| 918 | 923 | read_buffer_empty(); |
| r23642 | r23643 | |
| 950 | 955 | if (status & IDE_STATUS_BUFFER_READY) |
| 951 | 956 | { |
| 952 | 957 | /* fetch the correct amount of data */ |
| 953 | | result = buffer[buffer_offset++]; |
| 958 | result = dev->buffer[dev->buffer_offset++]; |
| 954 | 959 | if (mem_mask == 0xffff) |
| 955 | | result |= buffer[buffer_offset++] << 8; |
| 960 | result |= dev->buffer[dev->buffer_offset++] << 8; |
| 956 | 961 | |
| 957 | 962 | /* if we're at the end of the buffer, handle it */ |
| 958 | | if (buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| 963 | if (dev->buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| 959 | 964 | { |
| 960 | 965 | LOG(("%s:IDE completed PIO read\n", machine().describe_context())); |
| 961 | 966 | read_buffer_empty(); |
| r23642 | r23643 | |
| 1125 | 1130 | |
| 1126 | 1131 | void ide_controller_device::write_dma( UINT16 data ) |
| 1127 | 1132 | { |
| 1128 | | buffer[buffer_offset++] = data; |
| 1129 | | buffer[buffer_offset++] = data >> 8; |
| 1133 | ide_device_interface *dev = slot[cur_drive]->dev(); |
| 1130 | 1134 | |
| 1135 | dev->buffer[dev->buffer_offset++] = data; |
| 1136 | dev->buffer[dev->buffer_offset++] = data >> 8; |
| 1137 | |
| 1131 | 1138 | /* if we're at the end of the buffer, handle it */ |
| 1132 | | if (buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| 1139 | if (dev->buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| 1133 | 1140 | { |
| 1134 | 1141 | LOG(("%s:IDE completed DMA write\n", machine().describe_context())); |
| 1135 | 1142 | write_buffer_full(); |
| r23642 | r23643 | |
| 1162 | 1169 | if (status & IDE_STATUS_BUFFER_READY) |
| 1163 | 1170 | { |
| 1164 | 1171 | /* store the correct amount of data */ |
| 1165 | | buffer[buffer_offset++] = data; |
| 1172 | dev->buffer[dev->buffer_offset++] = data; |
| 1166 | 1173 | if (mem_mask == 0xffff) |
| 1167 | | buffer[buffer_offset++] = data >> 8; |
| 1174 | dev->buffer[dev->buffer_offset++] = data >> 8; |
| 1168 | 1175 | |
| 1169 | 1176 | /* if we're at the end of the buffer, handle it */ |
| 1170 | | if (buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| 1177 | if (dev->buffer_offset >= IDE_DISK_SECTOR_SIZE) |
| 1171 | 1178 | { |
| 1172 | 1179 | LOG(("%s:IDE completed PIO write\n", machine().describe_context())); |
| 1173 | 1180 | write_buffer_full(); |
| r23642 | r23643 | |
| 1264 | 1271 | command(0), |
| 1265 | 1272 | interrupt_pending(0), |
| 1266 | 1273 | precomp_offset(0), |
| 1267 | | buffer_offset(0), |
| 1268 | 1274 | sector_count(0), |
| 1269 | 1275 | block_count(0), |
| 1270 | 1276 | sectors_until_int(0), |
| r23642 | r23643 | |
| 1291 | 1297 | command(0), |
| 1292 | 1298 | interrupt_pending(0), |
| 1293 | 1299 | precomp_offset(0), |
| 1294 | | buffer_offset(0), |
| 1295 | 1300 | sector_count(0), |
| 1296 | 1301 | block_count(0), |
| 1297 | 1302 | sectors_until_int(0), |
| r23642 | r23643 | |
| 1332 | 1337 | save_item(NAME(interrupt_pending)); |
| 1333 | 1338 | save_item(NAME(precomp_offset)); |
| 1334 | 1339 | |
| 1335 | | save_item(NAME(buffer)); |
| 1336 | | save_item(NAME(buffer_offset)); |
| 1337 | 1340 | save_item(NAME(sector_count)); |
| 1338 | 1341 | |
| 1339 | 1342 | save_item(NAME(block_count)); |
| r23642 | r23643 | |
| 1357 | 1360 | |
| 1358 | 1361 | void ide_controller_device::device_reset() |
| 1359 | 1362 | { |
| 1363 | ide_device_interface *dev = slot[cur_drive]->dev(); |
| 1364 | |
| 1360 | 1365 | LOG(("IDE controller reset performed\n")); |
| 1361 | 1366 | /* reset the drive state */ |
| 1362 | 1367 | cur_drive = 0; |
| 1363 | 1368 | status = IDE_STATUS_DRIVE_READY | IDE_STATUS_SEEK_COMPLETE; |
| 1364 | 1369 | error = IDE_ERROR_DEFAULT; |
| 1365 | | buffer_offset = 0; |
| 1370 | dev->buffer_offset = 0; |
| 1366 | 1371 | gnetreadlock = 0; |
| 1367 | 1372 | master_password_enable = (master_password != NULL); |
| 1368 | 1373 | user_password_enable = (user_password != NULL); |