source/src/vm/scsi_dev.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2016.03.01-
   6
   7         [ SCSI base device ]
   8 */
   9
  10 #include "scsi_dev.h"
  11 #include "../fifo.h"
  12
  13 #define EVENT_SEL       0
  14 #define EVENT_PHASE     1
  15 #define EVENT_REQ       2
  16 //#define _SCSI_DEBUG_LOG
  17
  18 void SCSI_DEV::initialize()
  19 {
  20         DEVICE::initialize();
  21         buffer = new FIFO(SCSI_BUFFER_SIZE);
  22         phase = SCSI_PHASE_BUS_FREE;
  23         _SCSI_DEV_IMMEDIATE_SELECT = osd->check_feature(_T("SCSI_DEV_IMMEDIATE_SELECT"));
  24         __SCSI_DEBUG_LOG = osd->check_feature(_T("_SCSI_DEBUG_LOG"));
  25         _SCSI_HOST_WIDE = osd->check_feature(_T("SCSI_HOST_WIDE"));
  26         _OUT_DEBUG_LOG = false; // Temporally.
  27         if(_SCSI_HOST_WIDE) {
  28                 update_signal_mask(&outputs_dat, NULL, 0xffff); // Update to 16bit wide.
  29         }
  30 }
  31
  32 void SCSI_DEV::out_debug_log(const _TCHAR *format, ...)
  33 {
  34         if(!(__SCSI_DEBUG_LOG) && !(_OUT_DEBUG_LOG)) return;
  35         va_list args;
  36         _TCHAR _tmps[4096] = {0};
  37         _TCHAR _domain[256] = {0};
  38         my_sprintf_s(_domain, sizeof(_domain) / sizeof(_TCHAR), _T("[SCSI_DEV:ID=%d]"), scsi_id);
  39         va_start(args, format);
  40         vsnprintf(_tmps, sizeof(_tmps) / sizeof(_TCHAR), format, args);
  41         va_end(args);
  42         DEVICE::out_debug_log(_T("%s %s"), _domain, _tmps);
  43 }
  44
  45 void SCSI_DEV::release()
  46 {
  47         buffer->release();
  48         delete buffer;
  49 }
  50
  51 void SCSI_DEV::reset()
  52 {
  53         data_bus = 0;
  54         sel_status = atn_status = ack_status = rst_status = false;
  55         selected = atn_pending = false;
  56
  57         event_sel = event_phase = event_req = -1;
  58         set_phase(SCSI_PHASE_BUS_FREE);
  59         set_sense_code(SCSI_SENSE_NOSENSE);
  60 }
  61
  62 void SCSI_DEV::write_signal(int id, uint32_t data, uint32_t mask)
  63 {
  64         switch(id) {
  65         case SIG_SCSI_DAT:
  66                 data_bus = data & mask;
  67 //              out_debug_log(_T("DATA=%04X"), data_bus);
  68                 break;
  69
  70         case SIG_SCSI_SEL:
  71                 {
  72                         bool prev_status = sel_status;
  73                         sel_status = ((data & mask) != 0);
  74
  75                         if(phase != SCSI_PHASE_BUS_FREE) {
  76                                 // this device is already selected
  77                         } else if(!prev_status && sel_status) {
  78                                 // L -> H
  79                                 if(_SCSI_DEV_IMMEDIATE_SELECT) {
  80                                         event_callback(EVENT_SEL, 0);
  81                                 } else {
  82                                         if(event_sel != -1) {
  83                                                 cancel_event(this, event_sel);
  84                                         }
  85                                         register_event(this, EVENT_SEL, 20.0, false, &event_sel);
  86                                 }
  87                         } else if(prev_status && !sel_status) {
  88                                 // H -> L
  89                                 if(event_sel != -1) {
  90                                         cancel_event(this, event_sel);
  91                                         event_sel = -1;
  92                                 }
  93                                 if(selected) {
  94                                         if(atn_status) {
  95                                                 // change to message out phase
  96                                                 buffer->clear();
  97                                                 set_phase_delay(SCSI_PHASE_MESSAGE_OUT, 10.0);
  98 //                                              set_phase(SCSI_PHASE_MESSAGE_OUT);
  99                                         } else {
 100                                                 // change to command phase
 101                                                 memset(command, 0, sizeof(command));
 102                                                 command_index = 0;
 103                                                 set_phase_delay(SCSI_PHASE_COMMAND, 10.0);
 104 //                                              set_phase(SCSI_PHASE_COMMAND);
 105                                         }
 106                                 }
 107                         }
 108                 }
 109                 break;
 110
 111         case SIG_SCSI_ATN:
 112                 {
 113                         bool prev_status = atn_status;
 114                         atn_status = ((data & mask) != 0);
 115
 116                         if(phase == SCSI_PHASE_BUS_FREE) {
 117                                 // this device is not selected
 118                         } else if(!prev_status && atn_status) {
 119                                 // L -> H
 120                                 out_debug_log(_T("ATN signal raised\n"));
 121                                 if(ack_status) {
 122                                         // wait until ack=off
 123                                         atn_pending = true;
 124                                 } else {
 125                                         // change to message out phase
 126                                         atn_pending = false;
 127                                         buffer->clear();
 128                                         set_phase_delay(SCSI_PHASE_MESSAGE_OUT, 10.0);
 129                                 }
 130                         }
 131                 }
 132                 break;
 133
 134         case SIG_SCSI_ACK:
 135                 {
 136 /*
 137                         initiator --->  device
 138
 139                         wait req=on
 140                                         set req=on
 141                                         wait ack=on
 142                         write data
 143                         set ack=on
 144                         wait req=off
 145                                         read data
 146                                         set req=off
 147                                         wait ack=off
 148                         set ack=off
 149
 150                         initiator <---  device
 151
 152                         wait req=on
 153                                         write data
 154                                         set req=on
 155                                         wait ack=on
 156                         read data
 157                         set ack=on
 158                         wait req=off
 159                                         set req=off
 160                                         wait ack=off
 161                         set ack=off
 162 */
 163                         bool prev_status = ack_status;
 164                         ack_status = ((data & mask) != 0);
 165 //                      out_debug_log(_T("ACK=%s"), (ack_status) ? _T("ON") : _T("OFF"));
 166                         if(phase == SCSI_PHASE_BUS_FREE) {
 167                                 // this device is not selected
 168                         } else if(!prev_status & ack_status) {
 169                                 // L -> H
 170                                 switch(phase) {
 171                                 case SCSI_PHASE_DATA_OUT:
 172                                         buffer->write(data_bus);
 173
 174                                         // check defect list length in format unit data
 175                                         if(command[0] == SCSI_CMD_FORMAT) {
 176                                                 if(buffer->count() == 4) {
 177                                                         remain += buffer->read_not_remove(2) * 256 + buffer->read_not_remove(3);
 178                                                 }
 179                                         }
 180                                         break;
 181
 182                                 case SCSI_PHASE_COMMAND:
 183                                         command[command_index++] = data_bus;
 184                                         break;
 185
 186                                 case SCSI_PHASE_MESSAGE_OUT:
 187                                         buffer->write(data_bus);
 188                                         break;
 189                                 }
 190                                 if(phase == SCSI_PHASE_DATA_OUT || phase == SCSI_PHASE_DATA_IN) {
 191                                         set_req_delay(0, data_req_delay); // thanks Mr.Sato
 192                                 } else {
 193                                         set_req_delay(0, 0.1);
 194                                 }
 195                         } else if(prev_status && !ack_status) {
 196                                 // H -> L
 197                                 if(atn_pending) {
 198                                         // change to message out phase
 199                                         atn_pending = false;
 200                                         buffer->clear();
 201                                         set_phase_delay(SCSI_PHASE_MESSAGE_OUT, 10.0);
 202                                 } else {
 203                                         switch(phase) {
 204                                         case SCSI_PHASE_DATA_OUT:
 205                                                 if(--remain > 0) {
 206                                                         // flush buffer
 207                                                         if(buffer->full()) {
 208                                                                 if(!write_buffer(buffer->count())) {
 209                                                                         // change to status phase
 210                                                                         set_dat(SCSI_STATUS_CHKCOND);
 211                                                                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 212                                                                         break;
 213                                                                 }
 214                                                                 buffer->clear(); // just in case
 215                                                         }
 216                                                         switch(command[0]) {
 217                                                         case SCSI_CMD_WRITE6:
 218                                                         case SCSI_CMD_WRITE10:
 219                                                         case SCSI_CMD_WRITE12:
 220                                                                 // request to write next data
 221                                                                 {
 222                                                                         next_req_usec += 1000000.0 / bytes_per_sec;
 223                                                                         double usec = next_req_usec - get_passed_usec(first_req_clock);
 224                                                                         set_req_delay(1, (usec > 0.2) ? usec : 0.2);
 225                                                                         if(logical_block_size() > 0) {
 226                                                                                 local_data_pos = (local_data_pos + 1) % logical_block_size();
 227                                                                                 if(local_data_pos == 0) {
 228                                                                                         write_signals(&outputs_next_sector, 0xffffffff);
 229                                                                                 }
 230                                                                         }
 231                                                                 }
 232                                                                 break;
 233                                                         default:
 234                                                                 // request to write next data
 235                                                                 set_req_delay(1, 1.0);
 236                                                                 break;
 237                                                         }
 238                                                 } else {
 239                                                         // flush buffer
 240                                                         if(!buffer->empty()) {
 241                                                                 if(!write_buffer(buffer->count())) {
 242                                                                         // change to status phase
 243                                                                         set_dat(SCSI_STATUS_CHKCOND);
 244                                                                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 245                                                                         break;
 246                                                                 }
 247                                                                 buffer->clear(); // just in case
 248                                                         }
 249                                                         // change to status phase
 250                                                         switch(command[0]) {
 251                                                         case SCSI_CMD_WRITE6:
 252                                                         case SCSI_CMD_WRITE10:
 253                                                         case SCSI_CMD_WRITE12:
 254                                                                 write_signals(&outputs_completed, 0xffffffff);
 255                                                                 break;
 256                                                         }
 257                                                         set_dat(SCSI_STATUS_GOOD);
 258                                                         set_sense_code(SCSI_SENSE_NOSENSE);
 259                                                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 260                                                 }
 261                                                 break;
 262
 263                                         case SCSI_PHASE_DATA_IN:
 264                                                 if(--remain > 0) {
 265                                                         // update buffer
 266                                                         if(buffer->count() == 0) {
 267                                                                 int length = remain > SCSI_BUFFER_SIZE ? SCSI_BUFFER_SIZE : (int)remain;
 268                                                                 out_debug_log(_T("LOAD BUFFER to %d bytes"), length);
 269                                                                 if(!read_buffer(length)) {
 270                                                                         // change to status phase
 271                                                                         set_dat(SCSI_STATUS_CHKCOND);
 272                                                                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 273                                                                         break;
 274                                                                 }
 275                                                         }
 276                                                         // request to read next data
 277                                                         set_dat(buffer->read());
 278                                                         switch(command[0]) {
 279                                                         case SCSI_CMD_READ6:
 280                                                         case SCSI_CMD_READ10:
 281                                                         case SCSI_CMD_READ12:
 282                                                                 {
 283                                                                         next_req_usec += 1000000.0 / bytes_per_sec;
 284                                                                         double usec = next_req_usec - get_passed_usec(first_req_clock);
 285                                                                         set_req_delay(1, (usec > 0.2) ? usec : 0.2);
 286                                                                         //set_req_delay(1, usec);
 287                                                                         if(logical_block_size() > 0) {
 288                                                                                 local_data_pos = (local_data_pos + 1) % logical_block_size();
 289                                                                                 if(local_data_pos == 0) {
 290                                                                                         write_signals(&outputs_next_sector, 0xffffffff);
 291                                                                                 }
 292                                                                         }
 293                                                                 }
 294                                                                 break;
 295                                                         default:
 296                                                                 set_req_delay(1, 10.0);
 297                                                                 break;
 298                                                         }
 299                                                 } else {
 300                                                         // change to status phase
 301                                                         switch(command[0]) {
 302                                                         case SCSI_CMD_READ6:
 303                                                         case SCSI_CMD_READ10:
 304                                                         case SCSI_CMD_READ12:
 305                                                         case SCSI_CMD_INQUIRY:
 306                                                                 write_signals(&outputs_completed, 0xffffffff);
 307                                                                 break;
 308                                                         }
 309                                                         set_dat(SCSI_STATUS_GOOD);
 310                                                         set_sense_code(SCSI_SENSE_NOSENSE);
 311                                                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 312                                                 }
 313                                                 break;
 314
 315                                         case SCSI_PHASE_COMMAND:
 316                                                 if(command_index < get_command_length(command[0])) {
 317                                                         // request next command
 318 //                                                      set_req_delay(1, 1.0);
 319                                                         // Q:Command wait may be longet than 1.0us? 20200316 K.O
 320                                                         set_req_delay(1, 10.0);
 321                                                 } else {
 322                                                         // start command
 323                                                         start_command();
 324                                                 }
 325                                                 break;
 326
 327                                         case SCSI_PHASE_STATUS:
 328                                                 // create message data table
 329                                                 remain = 1;
 330                                                 buffer->clear();
 331                                                 buffer->write(0x00); // command complete message
 332                                                 // change to message in phase
 333                                                 set_dat(buffer->read());
 334                                                 set_phase_delay(SCSI_PHASE_MESSAGE_IN, 1.0);
 335                                                 break;
 336
 337                                         case SCSI_PHASE_MESSAGE_OUT:
 338                                                 if((buffer->read() & 0xb8) == 0x80) {
 339                                                         // identify, change to command phase
 340                                                         memset(command, 0, sizeof(command));
 341                                                         command_index = 0;
 342                                                         set_phase_delay(SCSI_PHASE_COMMAND, 10.0);
 343                                                 } else {
 344                                                         // abort, change to bus free phase
 345                                                         set_phase_delay(SCSI_PHASE_BUS_FREE, 10.0);
 346                                                 }
 347                                                 break;
 348
 349                                         case SCSI_PHASE_MESSAGE_IN:
 350                                                 if(--remain > 0) {
 351                                                         // request to read next data
 352                                                         set_dat(buffer->read());
 353                                                         set_req_delay(1, 1.0);
 354                                                 } else {
 355                                                         // change to bus free phase
 356                                                         set_phase_delay(SCSI_PHASE_BUS_FREE, 1.0);
 357                                                 }
 358                                                 break;
 359                                         }
 360                                 }
 361                         }
 362                 }
 363                 break;
 364
 365         case SIG_SCSI_RST:
 366                 {
 367                         bool prev_status = rst_status;
 368                         rst_status = ((data & mask) != 0);
 369
 370                         if(!prev_status & rst_status) {
 371                                 // L -> H
 372                                 out_debug_log(_T("RST signal raised\n"));
 373                                 local_data_pos = 0;
 374                                 reset_device();
 375                                 set_phase(SCSI_PHASE_BUS_FREE);
 376                         }
 377                 }
 378                 break;
 379         }
 380 }
 381
 382 void SCSI_DEV::event_callback(int event_id, int err)
 383 {
 384         switch(event_id) {
 385         case EVENT_SEL:
 386                 event_sel = -1;
 387                 if((data_bus & 0x7f) == (1 << scsi_id)) {
 388                         if(is_device_existing()) {
 389                                 // this device is selected!
 390                                 out_debug_log(_T("This device is selected\n"));
 391                                 set_bsy(true);
 392                                 selected = true;
 393                         }
 394                 }
 395                 break;
 396         case EVENT_PHASE:
 397                 event_phase = -1;
 398                 set_phase(next_phase);
 399                 break;
 400
 401         case EVENT_REQ:
 402                 event_req = -1;
 403                 set_req(next_req);
 404                 break;
 405         }
 406 }
 407
 408 void SCSI_DEV::set_phase(int value)
 409 {
 410         out_debug_log(_T("Phase %s -> %s\n"), scsi_phase_name[phase], scsi_phase_name[value]);
 411         if(event_phase != -1) {
 412                 cancel_event(this, event_phase);
 413                 event_phase = -1;
 414         }
 415         set_io (value & 1);
 416         set_msg(value & 2);
 417         set_cd (value & 4);
 418
 419         if(value == SCSI_PHASE_BUS_FREE) {
 420                 if(phase != value) {
 421                         write_signals(&outputs_clrq, 0xffffffff);
 422                 }
 423                 set_bsy(false);
 424                 set_req(0);
 425                 selected = false;
 426         } else {
 427                 if(phase != value) {
 428                         write_signals(&outputs_clrq, 0xffffffff);
 429                 }
 430                 first_req_clock = 0;
 431 //              set_bsy(true);
 432                 set_req_delay(1, 10.0);
 433
 434         }
 435         phase = value;
 436 }
 437
 438 void SCSI_DEV::set_phase_delay(int value, double usec)
 439 {
 440         if(usec <= 0.0) {
 441                 set_phase(value);
 442         } else {
 443                 if(event_phase != -1) {
 444                         cancel_event(this, event_phase);
 445                         event_phase = -1;
 446                 }
 447                 register_event(this, EVENT_PHASE, usec, false, &event_phase);
 448                 next_phase = value;
 449         }
 450 }
 451
 452 void SCSI_DEV::set_dat(int value)
 453 {
 454         if(__SCSI_DEBUG_LOG) {
 455 //              emu->force_out_debug_log(_T("[SCSI_DEV:ID=%d] DATA = %02x\n"), scsi_id, value);
 456         }
 457         write_signals(&outputs_dat, value);
 458 }
 459
 460 void SCSI_DEV::set_bsy(int value)
 461 {
 462 //      out_debug_log(_T("BUSY = %d\n"), value ? 1 : 0);
 463         write_signals(&outputs_bsy, value ? 0xffffffff : 0);
 464 }
 465
 466 void SCSI_DEV::set_cd(int value)
 467 {
 468 //      out_debug_log(_T("C/D = %d\n"), value ? 1 : 0);
 469         write_signals(&outputs_cd,  value ? 0xffffffff : 0);
 470 }
 471
 472 void SCSI_DEV::set_io(int value)
 473 {
 474 //      out_debug_log(_T("I/O = %d\n"), value ? 1 : 0);
 475         write_signals(&outputs_io,  value ? 0xffffffff : 0);
 476 }
 477
 478 void SCSI_DEV::set_msg(int value)
 479 {
 480 //      out_debug_log(_T("MSG = %d\n"), value ? 1 : 0);
 481         write_signals(&outputs_msg, value ? 0xffffffff : 0);
 482 }
 483
 484 void SCSI_DEV::set_req(int value)
 485 {
 486 //      out_debug_log(_T("REQ = %d\n"), value ? 1 : 0);
 487         if(event_req != -1) {
 488                 cancel_event(this, event_req);
 489                 event_req = -1;
 490         }
 491         if(value && first_req_clock == 0) {
 492                 first_req_clock = get_current_clock();
 493                 next_req_usec = 0.0;
 494         }
 495         write_signals(&outputs_req, value ? 0xffffffff : 0);
 496 }
 497
 498 void SCSI_DEV::set_req_delay(int value, double usec)
 499 {
 500         if(usec <= 0.0) {
 501                 set_req(value);
 502         } else {
 503                 if(event_req != -1) {
 504                         cancel_event(this, event_req);
 505                         event_req = -1;
 506                 }
 507                 register_event(this, EVENT_REQ, usec, false, &event_req);
 508                 next_req = value;
 509         }
 510 }
 511
 512 int SCSI_DEV::get_command_length(int value)
 513 {
 514         switch((value >> 5) & 7) {
 515         case 0:
 516         case 3:
 517         case 6:
 518         case 7:
 519                 return 6;
 520         case 1:
 521         case 2:
 522                 return 10;
 523         case 5:
 524                 return 12;
 525         }
 526         return 6;
 527 }
 528
 529 void SCSI_DEV::start_command()
 530 {
 531         local_data_pos = 0;
 532         double delay;
 533         switch(command[0]) {
 534         case SCSI_CMD_TST_U_RDY:
 535                 out_debug_log(_T("Command: Test Unit Ready\n"));
 536                 // change to status phase
 537                 if(!is_device_ready()) {
 538                         set_dat(SCSI_STATUS_CHKCOND);
 539                         set_sense_code(SCSI_SENSE_NOTREADY);
 540                 } else {
 541                         set_dat(SCSI_STATUS_GOOD);
 542                         set_sense_code(SCSI_SENSE_NOSENSE);
 543                 }
 544                 set_phase_delay(SCSI_PHASE_STATUS, 1000.0);
 545                 break;
 546
 547         case SCSI_CMD_REQ_SENSE:
 548                 out_debug_log(_T("Command: Request Sense\n"));
 549                 // start position
 550                 position = (command[1] & 0x1f) * 0x10000 + command[2] * 0x100 + command[3];
 551                 position *= physical_block_size();
 552                 // transfer length
 553 //              remain = 16;
 554                 remain = command[4];
 555                 // create sense data table
 556                 buffer->clear();
 557                 for(int i = 0; i < remain; i++) {
 558                         int value = 0;
 559                         switch(i) {
 560                         case 0: value = SCSI_SERROR_CURRENT; break;
 561                         case 2: value = is_device_ready() ? SCSI_KEY_NOSENSE : SCSI_KEY_UNITATT; break;
 562                         case 7: value = 0x08; break;
 563                         }
 564                         buffer->write(value);
 565                 }
 566                 // change to data in phase
 567                 set_dat(buffer->read());
 568                 set_phase_delay(SCSI_PHASE_DATA_IN, 1000.0);
 569                 break;
 570
 571         case SCSI_CMD_INQUIRY:
 572                 out_debug_log(_T("Command: Inquiry\n"));
 573                 // start position
 574                 position = (command[1] & 0x1f) * 0x10000 + command[2] * 0x100 + command[3];
 575                 position *= physical_block_size();
 576                 // transfer length
 577                 remain = 36;
 578                 // create inquiry data table
 579                 buffer->clear();
 580                 buffer->write(device_type);
 581                 buffer->write(is_removable ? 0x80 : 0x00);
 582                 buffer->write(0x02); // ANSI SCSI2
 583                 buffer->write(0x01); // ANSI-CCS
 584                 buffer->write(0x10);
 585                 buffer->write(0x00);
 586                 buffer->write(0x00);
 587                 buffer->write(0x18);
 588                 for(int i = 0; i < (int)strlen(vendor_id) && i < 8; i++) {
 589                         buffer->write(vendor_id[i]);
 590                 }
 591                 for(int i = (int)strlen(vendor_id); i < 8; i++) {
 592                         buffer->write(0x20);
 593                 }
 594                 for(int i = 0; i < (int)strlen(product_id) && i < 16; i++) {
 595                         buffer->write(vendor_id[i]);
 596                 }
 597                 for(int i = (int)strlen(product_id); i < 16; i++) {
 598                         buffer->write(0x20);
 599                 }
 600                 for(int i = 0; i < (int)strlen(product_rev) && i < 4; i++) {
 601                         buffer->write(product_rev[i]);
 602                 }
 603                 for(int i = (int)strlen(product_rev); i < 4; i++) {
 604                         buffer->write(0x20);
 605                 }
 606                 // change to data in phase
 607                 set_dat(buffer->read());
 608 //              remain = buffer->count();
 609                 set_phase_delay(SCSI_PHASE_DATA_IN, 1000.0);
 610                 break;
 611
 612         case SCSI_CMD_RD_CAPAC:
 613                 out_debug_log(_T("Command: Read Capacity\n"));
 614                 // start position
 615                 position = command[2] * 0x1000000 + command[3] * 0x10000 + command[4] * 0x100 + command[5];
 616                 position *= physical_block_size();
 617                 // transfer length
 618                 remain = 8;
 619                 // create capacity data table
 620                 buffer->clear();
 621                 buffer->write((max_logical_block_addr() >> 24) & 0xff);
 622                 buffer->write((max_logical_block_addr() >> 16) & 0xff);
 623                 buffer->write((max_logical_block_addr() >>  8) & 0xff);
 624                 buffer->write((max_logical_block_addr() >>  0) & 0xff);
 625                 buffer->write((    logical_block_size() >> 24) & 0xff);
 626                 buffer->write((    logical_block_size() >> 16) & 0xff);
 627                 buffer->write((    logical_block_size() >>  8) & 0xff);
 628                 buffer->write((    logical_block_size() >>  0) & 0xff);
 629                 // change to data in phase
 630                 set_dat(buffer->read());
 631 //              set_phase_delay(SCSI_PHASE_DATA_IN, 10.0);
 632                 set_phase_delay(SCSI_PHASE_DATA_IN, 1000.0);
 633                 break;
 634
 635         case SCSI_CMD_FORMAT:
 636                 out_debug_log(_T("Command: Format Unit\n"));
 637                 if(command[1] & 0x10) {
 638                         // change to data out phase for extra bytes
 639                         remain = 4;
 640                         set_phase_delay(SCSI_PHASE_DATA_OUT, 10.0);
 641                 } else {
 642                         // no extra bytes, change to status phase
 643                         set_dat(SCSI_STATUS_GOOD);
 644                         set_phase_delay(SCSI_PHASE_STATUS, 1000.0);
 645                 }
 646                 break;
 647
 648         case SCSI_CMD_RD_DEFECT:
 649                 out_debug_log(_T("Command: Read Defect Data\n"));
 650                 // transfer length
 651                 remain = 4;
 652                 // create detect data table
 653                 buffer->clear();
 654                 buffer->write(0x00);
 655                 buffer->write(command[2]);
 656                 buffer->write(0x00); // msb of defect list length
 657                 buffer->write(0x00); // lsb of defect list length
 658                 // change to data in phase
 659                 set_dat(buffer->read());
 660                 set_phase_delay(SCSI_PHASE_DATA_IN, 1000.0);
 661                 break;
 662
 663         case SCSI_CMD_READ6:
 664                 // start position
 665                 position = (command[1] & 0x1f) * 0x10000 + command[2] * 0x100 + command[3];
 666                 out_debug_log(_T("Command: Read 6-byte LBA=%d BLOCKS=%d\n"), position, command[4]);
 667                 position *= physical_block_size();
 668                 // transfer length
 669                 remain = (command[4] > 0 ? command[4] : 0x100) * logical_block_size(); // thanks Mr.Sato
 670                 // seek time
 671                 delay = get_seek_time(position, remain);
 672                 if(remain != 0) {
 673                         // read data buffer
 674                         buffer->clear();
 675                         int length = remain > SCSI_BUFFER_SIZE ? SCSI_BUFFER_SIZE : (int)remain;
 676                         if(!read_buffer(length)) {
 677                                 // change to status phase
 678                                 set_dat(SCSI_STATUS_CHKCOND);
 679                                 set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 680                                 break;
 681                         }
 682                         // change to data in phase
 683                         set_dat(buffer->read());
 684                         set_phase_delay(SCSI_PHASE_DATA_IN, delay);
 685                 } else {
 686                         // transfer length is zero, change to status phase
 687                         set_dat(SCSI_STATUS_GOOD);
 688                         set_sense_code(SCSI_SENSE_NOSENSE);
 689                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 690                 }
 691                 break;
 692
 693         case SCSI_CMD_WRITE6:
 694                 // start position
 695                 position = (command[1] & 0x1f) * 0x10000 + command[2] * 0x100 + command[3];
 696                 out_debug_log(_T("Command: Write 6-byte LBA=%d BLOCKS=%d\n"), position, command[4]);
 697                 position *= physical_block_size();
 698                 // transfer length
 699                 remain = (command[4] > 0 ? command[4] : 0x100) * logical_block_size(); // thanks Mr.Sato
 700                 // seek time
 701                 delay = get_seek_time(position, remain);
 702                 if(remain != 0) {
 703                         // clear data buffer
 704                         buffer->clear();
 705                         // change to data in phase
 706                         set_phase_delay(SCSI_PHASE_DATA_OUT, delay);
 707                 } else {
 708                         // transfer length is zero, change to status phase
 709                         set_dat(SCSI_STATUS_GOOD);
 710                         set_sense_code(SCSI_SENSE_NOSENSE);
 711                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 712                 }
 713                 break;
 714
 715         case SCSI_CMD_READ10:
 716                 // start position
 717                 position = command[2] * 0x1000000 + command[3] * 0x10000 + command[4] * 0x100 + command[5];
 718                 out_debug_log(_T("Command: Read 10-byte LBA=%d BLOCKS=%d\n"), position, command[7] * 0x100 + command[8]);
 719                 position *= physical_block_size();
 720                 // transfer length
 721                 remain = command[7] * 0x100 + command[8];
 722                 remain *= logical_block_size();
 723                 // seek time
 724                 delay = get_seek_time(position, remain);
 725                 if(remain != 0) {
 726                         // read data buffer
 727                         buffer->clear();
 728                         int length = remain > SCSI_BUFFER_SIZE ? SCSI_BUFFER_SIZE : (int)remain;
 729                         if(!read_buffer(length)) {
 730                                 // change to status phase
 731                                 set_dat(SCSI_STATUS_CHKCOND);
 732                                 set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 733                                 break;
 734                         }
 735                         // change to data in phase
 736                         set_dat(buffer->read());
 737                         set_phase_delay(SCSI_PHASE_DATA_IN, delay);
 738                 } else {
 739                         // transfer length is zero, change to status phase
 740                         set_dat(SCSI_STATUS_GOOD);
 741                         set_sense_code(SCSI_SENSE_NOSENSE);
 742                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 743                 }
 744                 break;
 745
 746         case SCSI_CMD_WRITE10:
 747                 goto WRITE10;
 748         case SCSI_CMD_WRT_VERIFY:
 749         WRITE10:
 750                 // start position
 751                 position = command[2] * 0x1000000 + command[3] * 0x10000 + command[4] * 0x100 + command[5];
 752                 out_debug_log(_T("Command: %s LBA=%d BLOCKS=%d\n"), (command[0] == SCSI_CMD_WRT_VERIFY) ? _T("Write and Verify") : _T("Write 10-byte"), position, command[7] * 0x100 + command[8]);
 753                 position *= physical_block_size();
 754                 // transfer length
 755                 remain = command[7] * 0x100 + command[8];
 756                 remain *= logical_block_size();
 757                 // seek time
 758                 delay = get_seek_time(position, remain);
 759                 if(remain != 0) {
 760                         // clear data buffer
 761                         buffer->clear();
 762                         // change to data in phase
 763                         set_phase_delay(SCSI_PHASE_DATA_OUT, delay);
 764                 } else {
 765                         // transfer length is zero, change to status phase
 766                         set_dat(SCSI_STATUS_GOOD);
 767                         set_sense_code(SCSI_SENSE_NOSENSE);
 768                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 769                 }
 770                 break;
 771
 772         case SCSI_CMD_READ12:
 773                 // start position
 774                 position = command[2] * 0x1000000 + command[3] * 0x10000 + command[4] * 0x100 + command[5];
 775                 // transfer length
 776                 remain = command[6] * 0x1000000 + command[7] * 0x10000 + command[8] * 0x100 + command[9];
 777                 out_debug_log(_T("Command: Read 12-byte LBA=%d BLOCKS=%d PBS=%d LBS=%d\n"), position, remain, physical_block_size(), logical_block_size());
 778                 position *= physical_block_size();
 779                 remain *= logical_block_size();
 780                 // seek time
 781                 delay = get_seek_time(position, remain);
 782                 if(remain != 0) {
 783                         // read data buffer
 784                         buffer->clear();
 785                         int length = remain > SCSI_BUFFER_SIZE ? SCSI_BUFFER_SIZE : (int)remain;
 786                         out_debug_log(_T("LOAD BUFFER to %d bytes"), length);
 787                         if(!read_buffer(length)) {
 788                                 // change to status phase
 789                                 set_dat(SCSI_STATUS_CHKCOND);
 790                                 set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 791                                 break;
 792                         }
 793                         // change to data in phase
 794                         set_dat(buffer->read());
 795                         set_phase_delay(SCSI_PHASE_DATA_IN, delay);
 796                 } else {
 797                         // transfer length is zero, change to status phase
 798                         set_dat(SCSI_STATUS_GOOD);
 799                         set_sense_code(SCSI_SENSE_NOSENSE);
 800                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 801                 }
 802                 break;
 803
 804         case SCSI_CMD_WRITE12:
 805                 // start position
 806                 position = command[2] * 0x1000000 + command[3] * 0x10000 + command[4] * 0x100 + command[5];
 807                 out_debug_log(_T("Command: Write 12-byte LBA=%d BLOCKS=%d\n"), position, command[6] * 0x1000000 + command[7] * 0x10000 + command[8] * 0x100 + command[9]);
 808                 position *= physical_block_size();
 809                 // transfer length
 810                 remain = command[6] * 0x1000000 + command[7] * 0x10000 + command[8] * 0x100 + command[9];
 811                 remain *= logical_block_size();
 812                 // seek time
 813                 delay = get_seek_time(position, remain);
 814                 if(remain != 0) {
 815                         // clear data buffer
 816                         buffer->clear();
 817                         // change to data in phase
 818                         set_phase_delay(SCSI_PHASE_DATA_OUT, delay);
 819                 } else {
 820                         // transfer length is zero, change to status phase
 821                         set_dat(SCSI_STATUS_GOOD);
 822                         set_sense_code(SCSI_SENSE_NOSENSE);
 823                         set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 824                 }
 825                 break;
 826
 827         default:
 828                 out_debug_log(_T("Command: Unknown %02X\n"), command[0]);
 829                 set_dat(SCSI_STATUS_GOOD);
 830                 set_phase_delay(SCSI_PHASE_STATUS, 10.0);
 831         }
 832 }
 833
 834 bool SCSI_DEV::read_buffer(int length)
 835 {
 836         for(int i = 0; i < length; i++) {
 837                 buffer->write(0);
 838                 position++;
 839         }
 840         set_sense_code(SCSI_SENSE_NOSENSE);
 841         return true;
 842 }
 843
 844 bool SCSI_DEV::write_buffer(int length)
 845 {
 846         for(int i = 0; i < length; i++) {
 847                 buffer->read();
 848                 position++;
 849         }
 850         set_sense_code(SCSI_SENSE_NOSENSE);
 851         return true;
 852 }
 853
 854 #define STATE_VERSION   3
 855
 856 bool SCSI_DEV::process_state(FILEIO* state_fio, bool loading)
 857 {
 858         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 859                 return false;
 860         }
 861         if(!state_fio->StateCheckInt32(this_device_id)) {
 862                 return false;
 863         }
 864         state_fio->StateValue(data_bus);
 865         state_fio->StateValue(sel_status);
 866         state_fio->StateValue(atn_status);
 867         state_fio->StateValue(ack_status);
 868         state_fio->StateValue(rst_status);
 869         state_fio->StateValue(selected);
 870         state_fio->StateValue(atn_pending);
 871         state_fio->StateValue(phase);
 872         state_fio->StateValue(next_phase);
 873         state_fio->StateValue(next_req);
 874         state_fio->StateValue(event_sel);
 875         state_fio->StateValue(event_phase);
 876         state_fio->StateValue(event_req);
 877         state_fio->StateValue(first_req_clock);
 878         state_fio->StateValue(next_req_usec);
 879         state_fio->StateArray(command, sizeof(command), 1);
 880         state_fio->StateValue(command_index);
 881         if(!buffer->process_state((void *)state_fio, loading)) {
 882                 return false;
 883         }
 884         state_fio->StateValue(position);
 885         state_fio->StateValue(remain);
 886         state_fio->StateValue(local_data_pos);
 887         state_fio->StateValue(sense_code);
 888         return true;
 889 }