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