palacios/src/devices/ramdisk.c

   1 /*
   2  *
   3  *   Copyright (C) 2002  MandrakeSoft S.A.
   4  *
   5  *     MandrakeSoft S.A.
   6  *     43, rue d'Aboukir
   7  *     75002 Paris - France
   8  *     http://www.linux-mandrake.com/
   9  *     http://www.mandrakesoft.com/
  10  *
  11  *   This library is free software; you can redistribute it and/or
  12  *   modify it under the terms of the GNU Lesser General Public
  13  *   License as published by the Free Software Foundation; either
  14  *   version 2 of the License, or (at your option) any later version.
  15  *
  16  *   This library is distributed in the hope that it will be useful,
  17  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  *   Lesser General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU Lesser General Public
  22  *  License along with this library; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  *
  25  * Major modifications made for the V3VEE project
  26  *
  27  * The V3VEE Project is a joint project between Northwestern University
  28  * and the University of New Mexico.  You can find out more at
  29  * http://www.v3vee.org
  30  *
  31  * Copyright (c) 2008, Zheng Cui <cuizheng@cs.unm.edu>
  32  * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
  33  * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
  34  * All rights reserved for original changes
  35  *
  36  */
  37
  38
  39 #include <devices/ramdisk.h>
  40 #include <palacios/vmm.h>
  41 #include <devices/cdrom.h>
  42 #include <devices/ide.h>
  43
  44
  45 #ifndef DEBUG_RAMDISK
  46 #undef PrintDebug
  47 #define PrintDebug(_f, _a...)
  48 #endif
  49
  50
  51 /*
  52  * Data type definitions
  53  *
  54  */
  55 #define INDEX_PULSE_CYCLE 10
  56
  57
  58
  59
  60 #define INTR_REASON_BIT_ERR           0x01
  61 #define UNABLE_FIND_TAT_CHANNEL_ERR   0x02
  62 #define DRQ_ERR                       0x03
  63 #define READ_BUF_GT_512               0x04
  64
  65
  66
  67 #define PRI_DATA_PORT         0x1f0
  68 #define PRI_FEATURES_PORT     0x1f1
  69 #define PRI_SECT_CNT_PORT     0x1f2
  70 #define PRI_SECT_ADDR1_PORT   0x1f3
  71 #define PRI_SECT_ADDR2_PORT   0x1f4
  72 #define PRI_SECT_ADDR3_PORT   0x1f5
  73 #define PRI_DRV_SEL_PORT      0x1f6
  74 #define PRI_CMD_PORT          0x1f7
  75 #define PRI_CTRL_PORT         0x3f6
  76 #define PRI_ADDR_REG_PORT     0x3f7
  77
  78 #define SEC_DATA_PORT         0x170
  79 #define SEC_FEATURES_PORT     0x171
  80 #define SEC_SECT_CNT_PORT     0x172
  81 #define SEC_SECT_ADDR1_PORT   0x173
  82 #define SEC_SECT_ADDR2_PORT   0x174
  83 #define SEC_SECT_ADDR3_PORT   0x175
  84 #define SEC_DRV_SEL_PORT      0x176
  85 #define SEC_CMD_PORT          0x177
  86 #define SEC_CTRL_PORT         0x376
  87 #define SEC_ADDR_REG_PORT     0x377
  88
  89
  90
  91
  92
  93 #define PACKET_SIZE 12
  94
  95
  96 /*
  97  * Debug facilities
  98  */
  99
 100 #define ATA_DETECT                     0xf0 //0X3E8
 101 #define ATA_RESET                      0xf1 //0X3E9
 102 #define ATA_CMD_DATA_IN                0xf2 //0X3EA
 103 #define ATA_CMD_DATA_OUT               0xf3 //0X3EB
 104 #define ATA_CMD_PACKET                 0xf4 //0X3EC
 105 #define ATAPI_GET_SENSE                0xf5 //0X3ED
 106 #define ATAPI_IS_READY                 0xf6 //0X3EE
 107 #define ATAPI_IS_CDROM                 0xf7 //0X3EF
 108
 109 #define CDEMU_INIT                     0xf8 //0X2E8
 110 #define CDEMU_ISACTIVE                 0xf9 //0X2E9
 111 #define CDEMU_EMULATED_DRIVE           0xfa //0X2EA
 112 #define CDROM_BOOT                     0xfb //0X2EB
 113
 114
 115 #define HARD_DRIVE_POST                0xfc //0X2EC
 116
 117
 118 #define ATA_DEVICE_NO                  0xfd //0X2ED
 119 #define ATA_DEVICE_TYPE                0xfe //0X2ED
 120
 121 #define INT13_HARDDISK                 0xff //0x2ef
 122 #define INT13_CDROM                    0xe0 //0x2f8
 123 #define INT13_CDEMU                    0xe1 //0x2f9
 124 #define INT13_ELTORITO                 0xe2 //0x2fa
 125 #define INT13_DISKETTE_FUNCTION        0xe3 //0x2fb
 126
 127
 128
 129
 130 static const char cdrom_str[] = "CD-ROM";
 131 static const char harddisk_str[] = "HARDDISK";
 132 static const char none_str[] = "NONE";
 133
 134
 135 static inline const char * device_type_to_str(device_type_t type) {
 136   switch (type) {
 137   case IDE_DISK:
 138     return harddisk_str;
 139   case IDE_CDROM:
 140     return cdrom_str;
 141   case IDE_NONE:
 142     return none_str;
 143   default:
 144     return NULL;
 145   }
 146 }
 147
 148
 149 static inline void write_features(struct channel_t * channel, uchar_t value) {
 150   channel->drives[0].controller.features = value;
 151   channel->drives[1].controller.features = value;
 152 }
 153
 154
 155 static inline void write_sector_count(struct channel_t * channel, uchar_t value) {
 156   channel->drives[0].controller.sector_count = value;
 157   channel->drives[1].controller.sector_count = value;
 158 }
 159
 160 static inline void write_sector_number(struct channel_t * channel, uchar_t value) {
 161   channel->drives[0].controller.sector_no = value;
 162   channel->drives[1].controller.sector_no = value;
 163 }
 164
 165
 166 static inline void write_cylinder_low(struct channel_t * channel, uchar_t value) {
 167   channel->drives[0].controller.cylinder_no &= 0xff00;
 168   channel->drives[0].controller.cylinder_no |= value;
 169   channel->drives[1].controller.cylinder_no &= 0xff00;
 170   channel->drives[1].controller.cylinder_no |= value;
 171 }
 172
 173 static inline void write_cylinder_high(struct channel_t * channel, uchar_t value) {
 174   ushort_t val2 = value;
 175   val2 = val2 << 8;
 176   channel->drives[0].controller.cylinder_no &= 0x00ff;
 177   channel->drives[0].controller.cylinder_no |= (val2 & 0xff00);
 178
 179   channel->drives[1].controller.cylinder_no &= 0x00ff;
 180   channel->drives[1].controller.cylinder_no |= (val2 & 0xff00);
 181 }
 182
 183 static inline void write_head_no(struct channel_t * channel, uchar_t value) {
 184   channel->drives[0].controller.head_no = value;
 185   channel->drives[1].controller.head_no = value;
 186 }
 187
 188 static inline void write_lba_mode(struct channel_t * channel, uchar_t value) {
 189   channel->drives[0].controller.lba_mode = value;
 190   channel->drives[1].controller.lba_mode = value;
 191 }
 192
 193
 194 static inline uint_t get_channel_no(struct ramdisk_t * ramdisk, struct channel_t * channel) {
 195   return (((uchar_t *)channel - (uchar_t *)(ramdisk->channels)) / sizeof(struct channel_t));
 196 }
 197
 198 static inline uint_t get_drive_no(struct channel_t * channel, struct drive_t * drive) {
 199   return (((uchar_t *)drive - (uchar_t*)(channel->drives)) /  sizeof(struct drive_t));
 200 }
 201
 202 static inline struct drive_t * get_selected_drive(struct channel_t * channel) {
 203   return &(channel->drives[channel->drive_select]);
 204 }
 205
 206
 207 static inline int is_primary_port(struct ramdisk_t * ramdisk, ushort_t port) {
 208   switch(port)
 209     {
 210     case PRI_DATA_PORT:
 211     case PRI_FEATURES_PORT:
 212     case PRI_SECT_CNT_PORT:
 213     case PRI_SECT_ADDR1_PORT:
 214     case PRI_SECT_ADDR2_PORT:
 215     case PRI_SECT_ADDR3_PORT:
 216     case PRI_DRV_SEL_PORT:
 217     case PRI_CMD_PORT:
 218     case PRI_CTRL_PORT:
 219       return 1;
 220     default:
 221       return 0;
 222     }
 223 }
 224
 225
 226
 227 static inline int is_secondary_port(struct ramdisk_t * ramdisk, ushort_t port) {
 228   switch(port)
 229     {
 230     case SEC_DATA_PORT:
 231     case SEC_FEATURES_PORT:
 232     case SEC_SECT_CNT_PORT:
 233     case SEC_SECT_ADDR1_PORT:
 234     case SEC_SECT_ADDR2_PORT:
 235     case SEC_SECT_ADDR3_PORT:
 236     case SEC_DRV_SEL_PORT:
 237     case SEC_CMD_PORT:
 238     case SEC_CTRL_PORT:
 239       return 1;
 240     default:
 241       return 0;
 242     }
 243 }
 244
 245 static inline int num_drives_on_channel(struct channel_t * channel) {
 246   if ((channel->drives[0].device_type == IDE_NONE) &&
 247       (channel->drives[1].device_type == IDE_NONE)) {
 248     return 0;
 249   } else if ((channel->drives[0].device_type != IDE_NONE) &&
 250              (channel->drives[1].device_type != IDE_NONE)) {
 251     return 2;
 252   } else {
 253     return 1;
 254   }
 255 }
 256
 257
 258
 259 static inline uchar_t extract_bits(uchar_t * buf, uint_t buf_offset, uint_t bit_offset, uint_t num_bits) {
 260   uchar_t val = buf[buf_offset];
 261   val = val >> bit_offset;
 262   val &= ((1 << num_bits) -1);
 263   return val;
 264 }
 265
 266
 267 static inline uchar_t get_packet_field(struct channel_t * channel, uint_t packet_offset, uint_t bit_offset, uint_t num_bits) {
 268   struct drive_t * drive = get_selected_drive(channel);
 269   return extract_bits(drive->controller.buffer, packet_offset, bit_offset, num_bits);
 270 }
 271
 272
 273 static inline uchar_t get_packet_byte(struct channel_t * channel, uint_t offset) {
 274   struct drive_t * drive = get_selected_drive(channel);
 275   return drive->controller.buffer[offset];
 276 }
 277
 278 static inline uint16_t get_packet_word(struct channel_t * channel, uint_t offset) {
 279   struct drive_t * drive = get_selected_drive(channel);
 280   uint16_t val = drive->controller.buffer[offset];
 281   val = val << 8;
 282   val |= drive->controller.buffer[offset + 1];
 283   return val;
 284 }
 285
 286
 287 static inline uint16_t rd_read_16bit(const uint8_t* buf) {
 288   return (buf[0] << 8) | buf[1];
 289 }
 290
 291
 292
 293 static inline uint32_t rd_read_32bit(const uint8_t* buf) {
 294   return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 295 }
 296
 297 ////////////////////////////////////////////////////////////////////////////
 298
 299
 300 /*
 301  * ATAPI routines
 302  */
 303
 304
 305 static void rd_init_mode_sense_single(struct vm_device * dev, struct channel_t * channel, const void * src, int size);
 306
 307 static void rd_command_aborted(struct vm_device * dev, struct channel_t * channel, unsigned value);
 308
 309
 310
 311
 312 static int handle_atapi_packet_command(struct vm_device * dev,
 313                                        struct channel_t * channel,
 314                                        ushort_t val);
 315
 316 static int rd_init_send_atapi_command(struct vm_device * dev,
 317                                       struct channel_t * channel,
 318                                       Bit8u command, int req_length,
 319                                       int alloc_length, bool lazy);
 320
 321 static void rd_ready_to_send_atapi(struct vm_device * dev,
 322                                    struct channel_t * channel);
 323
 324 static void rd_atapi_cmd_error(struct vm_device * dev,
 325                                struct channel_t * channel,
 326                                sense_t sense_key, asc_t asc);
 327
 328 static void rd_atapi_cmd_nop(struct vm_device * dev, struct channel_t * channel);
 329 static void rd_identify_ATAPI_drive(struct vm_device * dev, struct channel_t * channel);
 330
 331
 332
 333 /*
 334  * Interrupt handling
 335  */
 336 static void rd_raise_interrupt(struct vm_device * dev, struct channel_t * channel);
 337 static void rd_lower_irq(struct vm_device *dev, Bit32u irq);
 338
 339
 340
 341 /*
 342  * Helper routines
 343  */
 344
 345
 346
 347 #ifdef DEBUG_RAMDISK
 348 static void rd_print_state(struct ramdisk_t *ramdisk);
 349 static int check_bit_fields(struct controller_t * controller);
 350 #endif
 351 ////////////////////////////////////////////////////////////////////
 352
 353
 354
 355
 356
 357 int v3_ramdisk_register_cdrom(struct vm_device * dev, uint_t busID, uint_t driveID, struct cdrom_ops* cd, void * private_data) {
 358   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
 359   struct channel_t * channel = &(ramdisk->channels[busID]);
 360   struct drive_t * drive = &(channel->drives[driveID]);
 361   struct controller_t * controller = &(drive->controller);
 362
 363
 364
 365   if (drive->device_type != IDE_NONE) {
 366     PrintError("Device already registered at this location\n");
 367     return -1;
 368   }
 369
 370
 371   channel->irq =  15;
 372
 373   // Make model string
 374   strncpy((char*)(drive->model_no), "V3VEE Ramdisk", 40);
 375
 376   while (strlen((char *)(drive->model_no)) < 40) {
 377     strcat ((char*)(drive->model_no), " ");
 378   }
 379
 380   PrintDebug("CDROM on target %d/%d\n", busID, driveID);
 381
 382   drive->device_type = IDE_CDROM;
 383   drive->cdrom.locked = 0;
 384   drive->sense.sense_key = SENSE_NONE;
 385   drive->sense.asc = 0;
 386   drive->sense.ascq = 0;
 387
 388   drive->private_data = private_data;
 389
 390 #ifdef DEBUG_RAMDISK
 391   if (check_bit_fields(controller) == INTR_REASON_BIT_ERR) {
 392     PrintDebug("interrupt reason: bit field error\n");
 393     return INTR_REASON_BIT_ERR;
 394   }
 395 #endif
 396
 397   controller->sector_count = 0;
 398
 399   drive->cdrom.cd = cd;
 400
 401   PrintDebug("\t\tCD on ata%d-%d: '%s'\n",
 402              busID,
 403              driveID, "");
 404
 405   if(drive->cdrom.cd->insert_cdrom(drive->private_data)) {
 406     PrintDebug("\t\tMedia present in CD-ROM drive\n");
 407     drive->cdrom.ready = 1;
 408     drive->cdrom.capacity = drive->cdrom.cd->capacity(drive->private_data);
 409     PrintDebug("\t\tCDROM capacity is %d\n", drive->cdrom.capacity);
 410   } else {
 411     PrintDebug("\t\tCould not locate CD-ROM, continuing with media not present\n");
 412     drive->cdrom.ready = 0;
 413   }
 414
 415   return 0;
 416 }
 417
 418
 419 static Bit32u rd_init_hardware(struct ramdisk_t *ramdisk) {
 420   uint_t channel_num;
 421   uint_t device;
 422   struct channel_t *channels = (struct channel_t *)(&(ramdisk->channels));
 423
 424   PrintDebug("[rd_init_harddrive]\n");
 425
 426   for (channel_num = 0; channel_num < MAX_ATA_CHANNEL; channel_num++) {
 427     memset((char *)(channels + channel_num), 0, sizeof(struct channel_t));
 428   }
 429
 430   for (channel_num = 0; channel_num < MAX_ATA_CHANNEL; channel_num++){
 431     struct channel_t * channel = &(channels[channel_num]);
 432
 433     channel->ioaddr1 = 0x0;
 434     channel->ioaddr2 = 0x0;
 435     channel->irq = 0;
 436
 437     for (device = 0; device < 2; device++){
 438       struct drive_t * drive = &(channel->drives[device]);
 439       struct controller_t * controller = &(drive->controller);
 440
 441       controller->status.busy = 0;
 442       controller->status.drive_ready = 1;
 443       controller->status.write_fault = 0;
 444       controller->status.seek_complete = 1;
 445       controller->status.drq = 0;
 446       controller->status.corrected_data = 0;
 447       controller->status.index_pulse = 0;
 448       controller->status.index_pulse_count = 0;
 449       controller->status.err = 0;
 450
 451       controller->error_register = 0x01; // diagnostic code: no error
 452       controller->head_no = 0;
 453       controller->sector_count = 1;
 454       controller->sector_no = 1;
 455       controller->cylinder_no = 0;
 456       controller->current_command = 0x00;
 457       controller->buffer_index = 0;
 458
 459       controller->control.reset = 0;
 460       controller->control.disable_irq = 0;
 461       controller->reset_in_progress = 0;
 462
 463       controller->sectors_per_block = 0x80;
 464       controller->lba_mode = 0;
 465
 466
 467       controller->features = 0;
 468
 469       // If not present
 470       drive->device_type = IDE_NONE;
 471
 472       // Make model string
 473       strncpy((char*)(drive->model_no), "", 40);
 474       while(strlen((char *)(drive->model_no)) < 40) {
 475         strcat ((char*)(drive->model_no), " ");
 476       }
 477
 478     }//for device
 479   }//for channel
 480
 481 #ifdef DEBUG_RAMDISK
 482   rd_print_state(ramdisk);
 483 #endif
 484   return 0;
 485 }
 486
 487
 488 /*
 489   static void rd_reset_harddrive(struct ramdisk_t *ramdisk, unsigned type) {
 490   return;
 491   }
 492
 493 */
 494 static void rd_close_harddrive(struct ramdisk_t *ramdisk) {
 495   return;
 496 }
 497
 498
 499 ////////////////////////////////////////////////////////////////////
 500
 501
 502
 503 static int read_data_port(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
 504   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
 505   struct channel_t * channel = NULL;
 506   struct drive_t * drive = NULL;
 507   struct controller_t * controller = NULL;
 508
 509
 510
 511   if (is_primary_port(ramdisk, port)) {
 512     channel = &(ramdisk->channels[0]);
 513   } else if (is_secondary_port(ramdisk, port)) {
 514     channel = &(ramdisk->channels[1]);
 515   } else {
 516     PrintError("Invalid Port: %d\n", port);
 517     return -1;
 518   }
 519
 520   drive = get_selected_drive(channel);
 521   controller = &(drive->controller);
 522
 523
 524   PrintDebug("[read_data_handler] IO Read at 0x%x, on drive %d/%d (current_cmd = 0x%02x)\n",
 525              port,
 526              get_channel_no(ramdisk, channel),
 527              get_drive_no(channel, drive),
 528              controller->current_command);
 529
 530   switch (controller->current_command) {
 531   case 0xec:    // IDENTIFY DEVICE
 532   case 0xa1:
 533     {
 534
 535
 536       controller->status.busy = 0;
 537       controller->status.drive_ready = 1;
 538       controller->status.write_fault = 0;
 539       controller->status.seek_complete = 1;
 540       controller->status.corrected_data = 0;
 541       controller->status.err = 0;
 542
 543       /*
 544         value32 = controller->buffer[index];
 545         index++;
 546
 547         if (io_len >= 2) {
 548         value32 |= (controller->buffer[index] << 8);
 549         index++;
 550         }
 551
 552         if (io_len == 4) {
 553         value32 |= (controller->buffer[index] << 16);
 554         value32 |= (controller->buffer[index+1] << 24);
 555         index += 2;
 556         }
 557
 558         controller->buffer_index = index;
 559       */
 560       /* JRL */
 561       memcpy(dst, controller->buffer + controller->buffer_index, length);
 562       controller->buffer_index += length;
 563
 564       if (controller->buffer_index >= 512) {
 565         controller->status.drq = 0;
 566       }
 567
 568       return length;
 569     }
 570   case 0xa0: //send packet cmd
 571     {
 572       uint_t index = controller->buffer_index;
 573
 574
 575       PrintDebug("\t\tatapi.command(%02x), index(%d), cdrom.remaining_blocks(%d)\n",
 576                     drive->atapi.command,
 577                     index,
 578                     drive->cdrom.remaining_blocks);
 579
 580       // Load block if necessary
 581       if (index >= 2048) {
 582
 583         if (index > 2048) {
 584           PrintError("\t\tindex > 2048 : 0x%x\n", index);
 585           return -1;
 586         }
 587
 588         switch (drive->atapi.command) {
 589         case 0x28: // read (10)
 590         case 0xa8: // read (12)
 591           {
 592
 593             if (!(drive->cdrom.ready)) {
 594               PrintError("\t\tRead with CDROM not ready\n");
 595               return -1;
 596             }
 597
 598             drive->cdrom.cd->read_block(drive->private_data, controller->buffer,
 599                                         drive->cdrom.next_lba);
 600             drive->cdrom.next_lba++;
 601             drive->cdrom.remaining_blocks--;
 602
 603
 604             if (!(drive->cdrom.remaining_blocks)) {
 605               PrintDebug("\t\tLast READ block loaded {CDROM}\n");
 606             } else {
 607               PrintDebug("\t\tREAD block loaded (%d remaining) {CDROM}\n",
 608                          drive->cdrom.remaining_blocks);
 609             }
 610
 611             // one block transfered, start at beginning
 612             index = 0;
 613             break;
 614           }
 615         default: // no need to load a new block
 616           break;
 617         }
 618       }
 619
 620
 621       /*
 622         increment = 0;
 623         value32 = controller->buffer[index + increment];
 624         increment++;
 625
 626         if (io_len >= 2) {
 627         value32 |= (controller->buffer[index + increment] << 8);
 628         increment++;
 629         }
 630
 631         if (io_len == 4) {
 632         value32 |= (controller->buffer[index + increment] << 16);
 633         value32 |= (controller->buffer[index + increment + 1] << 24);
 634         increment += 2;
 635         }
 636
 637         controller->buffer_index = index + increment;
 638         controller->drq_index += increment;
 639
 640       */
 641       /* JRL: CHECK THAT there is enough data in the buffer to copy.... */
 642       {
 643         memcpy(dst, controller->buffer + index, length);
 644
 645         controller->buffer_index  = index + length;
 646         controller->drq_index += length;
 647       }
 648
 649       /* *** */
 650
 651       if (controller->drq_index >= (unsigned)drive->atapi.drq_bytes) {
 652         controller->status.drq = 0;
 653         controller->drq_index = 0;
 654
 655         drive->atapi.total_bytes_remaining -= drive->atapi.drq_bytes;
 656
 657         if (drive->atapi.total_bytes_remaining > 0) {
 658           // one or more blocks remaining (works only for single block commands)
 659
 660           PrintDebug("\t\tPACKET drq bytes read\n");
 661           controller->interrupt_reason.i_o = 1;
 662           controller->status.busy = 0;
 663           controller->status.drq = 1;
 664           controller->interrupt_reason.c_d = 0;
 665
 666           // set new byte count if last block
 667           if (drive->atapi.total_bytes_remaining < controller->byte_count) {
 668             controller->byte_count = drive->atapi.total_bytes_remaining;
 669           }
 670           drive->atapi.drq_bytes = controller->byte_count;
 671
 672           rd_raise_interrupt(dev, channel);
 673         } else {
 674           // all bytes read
 675           PrintDebug("\t\tPACKET all bytes read\n");
 676
 677           controller->interrupt_reason.i_o = 1;
 678           controller->interrupt_reason.c_d = 1;
 679           controller->status.drive_ready = 1;
 680           controller->interrupt_reason.rel = 0;
 681           controller->status.busy = 0;
 682           controller->status.drq = 0;
 683           controller->status.err = 0;
 684
 685           rd_raise_interrupt(dev, channel);
 686         }
 687       }
 688       return length;
 689       break;
 690     }
 691
 692   default:
 693     PrintDebug("\t\tread need support more command: %02x\n", controller->current_command);
 694     break;
 695   }
 696
 697   return -1;
 698 }
 699
 700
 701
 702
 703 static int write_data_port(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
 704   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
 705   struct channel_t * channel = NULL;
 706   struct drive_t * drive = NULL;
 707   struct controller_t * controller = NULL;
 708
 709   if (is_primary_port(ramdisk, port)) {
 710     channel = &(ramdisk->channels[0]);
 711   } else if (is_secondary_port(ramdisk, port)) {
 712     channel = &(ramdisk->channels[1]);
 713   } else {
 714     PrintError("Invalid Port: %d\n", port);
 715     return -1;
 716   }
 717
 718   drive = get_selected_drive(channel);
 719   controller = &(drive->controller);
 720
 721   PrintDebug("[write_data_handler] IO write at 0x%x, current_cmd = 0x%02x\n",
 722              port, controller->current_command);
 723
 724   switch (controller->current_command) {
 725   case 0x30: // WRITE SECTORS
 726     PrintError("\t\tneed to implement 0x30(write sector) to port 0x%x\n", port);
 727     return -1;
 728
 729   case 0xa0: // PACKET
 730
 731     if (handle_atapi_packet_command(dev, channel, *(ushort_t *)src) == -1) {
 732       return -1;
 733     }
 734
 735     return length;
 736
 737   default:
 738     PrintError("\t\tIO write(0x%x): current command is %02xh\n",
 739                port, controller->current_command);
 740
 741     return -1;
 742   }
 743 }
 744
 745
 746
 747
 748
 749
 750
 751 static int read_status_port(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
 752   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
 753   struct channel_t * channel = NULL;
 754   struct drive_t * drive = NULL;
 755   struct controller_t * controller = NULL;
 756
 757
 758   if (length != 1) {
 759     PrintError("Invalid Status port read length: %d (port=%d)\n", length, port);
 760     return -1;
 761   }
 762
 763   if (is_primary_port(ramdisk, port)) {
 764     channel = &(ramdisk->channels[0]);
 765   } else if (is_secondary_port(ramdisk, port)) {
 766     channel = &(ramdisk->channels[1]);
 767   } else {
 768     PrintError("Invalid Port: %d\n", port);
 769     return -1;
 770   }
 771
 772   drive = get_selected_drive(channel);
 773   controller = &(drive->controller);
 774
 775   PrintDebug("[read_status_handler] IO read at 0x%x, on drive %d/%d\n",
 776              port, get_channel_no(ramdisk, channel),
 777              channel->drive_select);
 778
 779
 780   if (num_drives_on_channel(channel) == 0) {
 781     // (mch) Just return zero for these registers
 782     memset(dst, 0, length);
 783
 784   } else {
 785     uchar_t val = (
 786                    (controller->status.busy << 7)            |
 787                    (controller->status.drive_ready << 6)     |
 788                    (controller->status.write_fault << 5)     |
 789                    (controller->status.seek_complete << 4)   |
 790                    (controller->status.drq << 3)             |
 791                    (controller->status.corrected_data << 2)  |
 792                    (controller->status.index_pulse << 1)     |
 793                    (controller->status.err) );
 794
 795     memcpy(dst, &val, length);
 796
 797     controller->status.index_pulse_count++;
 798     controller->status.index_pulse = 0;
 799
 800     if (controller->status.index_pulse_count >= INDEX_PULSE_CYCLE) {
 801       controller->status.index_pulse = 1;
 802       controller->status.index_pulse_count = 0;
 803     }
 804   }
 805
 806   if ((port == SEC_CMD_PORT) || (port == PRI_CMD_PORT)) {
 807     rd_lower_irq(dev, channel->irq);
 808   }
 809
 810   return length;
 811
 812 }
 813
 814
 815 static int write_cmd_port(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
 816   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
 817   struct channel_t * channel = NULL;
 818   struct drive_t * drive = NULL;
 819   struct controller_t * controller = NULL;
 820   uchar_t value = *(uchar_t *)src;
 821
 822   if (length != 1) {
 823     PrintError("Invalid Command port write length: %d (port=%d)\n", length, port);
 824     return -1;
 825   }
 826
 827   if (is_primary_port(ramdisk, port)) {
 828     channel = &(ramdisk->channels[0]);
 829   } else if (is_secondary_port(ramdisk, port)) {
 830     channel = &(ramdisk->channels[1]);
 831   } else {
 832     PrintError("Invalid Port: %d\n", port);
 833     return -1;
 834   }
 835
 836   drive = get_selected_drive(channel);
 837   controller = &(drive->controller);
 838
 839
 840   PrintDebug("[write_command_handler] IO write at 0x%x, on drive %d/%d (val = 0x%x)\n",
 841              port, get_channel_no(ramdisk, channel),
 842              channel->drive_select,
 843              value);
 844
 845   switch (value) {
 846     // ATAPI commands
 847   case 0xa1: // IDENTIFY PACKET DEVICE
 848     {
 849       if (drive->device_type == IDE_CDROM) {
 850         controller->current_command = value;
 851         controller->error_register = 0;
 852
 853         controller->status.busy = 0;
 854         controller->status.drive_ready = 1;
 855         controller->status.write_fault = 0;
 856         controller->status.drq   = 1;
 857         controller->status.err   = 0;
 858
 859         controller->status.seek_complete = 1;
 860         controller->status.corrected_data = 0;
 861
 862         controller->buffer_index = 0;
 863         rd_raise_interrupt(dev, channel);
 864         rd_identify_ATAPI_drive(dev, channel);
 865       } else {
 866         rd_command_aborted(dev, channel, 0xa1);
 867       }
 868       break;
 869     }
 870   case 0xa0: // SEND PACKET (atapi)
 871     {
 872       if (drive->device_type == IDE_CDROM) {
 873         // PACKET
 874
 875         if (controller->features & (1 << 0)) {
 876           PrintError("\t\tPACKET-DMA not supported");
 877           return -1;
 878         }
 879
 880         if (controller->features & (1 << 1)) {
 881           PrintError("\t\tPACKET-overlapped not supported");
 882           return -1;
 883         }
 884
 885         // We're already ready!
 886         controller->sector_count = 1;
 887         controller->status.busy = 0;
 888         controller->status.write_fault = 0;
 889
 890         // serv bit??
 891         controller->status.drq = 1;
 892         controller->status.err = 0;
 893
 894         // NOTE: no interrupt here
 895         controller->current_command = value;
 896         controller->buffer_index = 0;
 897       } else {
 898         rd_command_aborted (dev, channel, 0xa0);
 899       }
 900       break;
 901     }
 902   default:
 903     PrintError("\t\tneed translate command %2x\n", value);
 904     //return -1;
 905     /* JRL THIS NEEDS TO CHANGE */
 906     return length;
 907
 908   }
 909   return length;
 910 }
 911
 912
 913 static int write_ctrl_port(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
 914   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
 915   struct channel_t * channel = NULL;
 916   struct drive_t * master_drive = NULL;
 917   struct drive_t * slave_drive = NULL;
 918   struct controller_t * controller = NULL;
 919   uchar_t value = *(uchar_t *)src;
 920   rd_bool prev_control_reset;
 921
 922   if (length != 1) {
 923     PrintError("Invalid Status port read length: %d (port=%d)\n", length, port);
 924     return -1;
 925   }
 926
 927   if (is_primary_port(ramdisk, port)) {
 928     channel = &(ramdisk->channels[0]);
 929   } else if (is_secondary_port(ramdisk, port)) {
 930     channel = &(ramdisk->channels[1]);
 931   } else {
 932     PrintError("Invalid Port: %d\n", port);
 933     return -1;
 934   }
 935
 936   master_drive = &(channel->drives[0]);
 937   slave_drive = &(channel->drives[1]);
 938
 939   controller = &(get_selected_drive(channel)->controller);
 940
 941
 942   PrintDebug("[write_control_handler] IO write at 0x%x, on drive %d/%d (val = 0x%x)\n",
 943              port, get_channel_no(ramdisk, channel),
 944              channel->drive_select,
 945              value);
 946
 947   // (mch) Even if device 1 was selected, a write to this register
 948   // goes to device 0 (if device 1 is absent)
 949
 950   prev_control_reset = controller->control.reset;
 951
 952   master_drive->controller.control.reset         = value & 0x04;
 953   slave_drive->controller.control.reset         = value & 0x04;
 954
 955   // CGS: was: SELECTED_CONTROLLER(channel).control.disable_irq    = value & 0x02;
 956   master_drive->controller.control.disable_irq = value & 0x02;
 957   slave_drive->controller.control.disable_irq = value & 0x02;
 958
 959   PrintDebug("\t\tadpater control reg: reset controller = %d\n",
 960                 (unsigned) (controller->control.reset) ? 1 : 0);
 961   PrintDebug("\t\tadpater control reg: disable_irq(X) = %d\n",
 962                 (unsigned) (controller->control.disable_irq) ? 1 : 0);
 963
 964   if ((!prev_control_reset) && (controller->control.reset)) {
 965     uint_t id = 0;
 966
 967     // transition from 0 to 1 causes all drives to reset
 968     PrintDebug("\t\thard drive: RESET\n");
 969
 970     // (mch) Set BSY, drive not ready
 971     for (id = 0; id < 2; id++) {
 972       struct controller_t * ctrl = NULL;
 973
 974       if (id == 0) {
 975         ctrl = &(master_drive->controller);
 976       } else if (id == 1) {
 977         ctrl = &(slave_drive->controller);
 978       }
 979
 980       ctrl->status.busy           = 1;
 981       ctrl->status.drive_ready    = 0;
 982       ctrl->reset_in_progress     = 1;
 983
 984       ctrl->status.write_fault    = 0;
 985       ctrl->status.seek_complete  = 1;
 986       ctrl->status.drq            = 0;
 987       ctrl->status.corrected_data = 0;
 988       ctrl->status.err            = 0;
 989
 990       ctrl->error_register = 0x01; // diagnostic code: no error
 991
 992       ctrl->current_command = 0x00;
 993       ctrl->buffer_index = 0;
 994
 995       ctrl->sectors_per_block = 0x80;
 996       ctrl->lba_mode          = 0;
 997
 998       ctrl->control.disable_irq = 0;
 999     }
1000
1001     rd_lower_irq(dev, channel->irq);
1002
1003   } else if ((controller->reset_in_progress) &&
1004              (!controller->control.reset)) {
1005     uint_t id;
1006     // Clear BSY and DRDY
1007     PrintDebug("\t\tReset complete {%s}\n", device_type_to_str(get_selected_drive(channel)->device_type));
1008
1009     for (id = 0; id < 2; id++) {
1010       struct controller_t * ctrl = NULL;
1011       struct drive_t * drv = NULL;
1012
1013       if (id == 0) {
1014         ctrl = &(master_drive->controller);
1015         drv = master_drive;
1016       } else if (id == 1) {
1017         ctrl = &(slave_drive->controller);
1018         drv = slave_drive;
1019       }
1020
1021       ctrl->status.busy           = 0;
1022       ctrl->status.drive_ready    = 1;
1023       ctrl->reset_in_progress     = 0;
1024
1025       // Device signature
1026       if (drv->device_type == IDE_DISK) {
1027         PrintDebug("\t\tdrive %d/%d is harddrive\n", get_channel_no(ramdisk, channel), id);
1028         ctrl->head_no        = 0;
1029         ctrl->sector_count   = 1;
1030         ctrl->sector_no      = 1;
1031         ctrl->cylinder_no    = 0;
1032       } else {
1033         ctrl->head_no        = 0;
1034         ctrl->sector_count   = 1;
1035         ctrl->sector_no      = 1;
1036         ctrl->cylinder_no    = 0xeb14;
1037       }
1038     }
1039   }
1040
1041   PrintDebug("\t\ts[0].controller.control.disable_irq = %02x\n",
1042              master_drive->controller.control.disable_irq);
1043   PrintDebug("\t\ts[1].controller.control.disable_irq = %02x\n",
1044              slave_drive->controller.control.disable_irq);
1045   return length;
1046 }
1047
1048
1049 static int read_general_port(ushort_t port, void * dst, uint_t length, struct vm_device * dev) {
1050   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
1051   struct channel_t * channel = NULL;
1052   struct drive_t * drive = NULL;
1053   struct controller_t * controller = NULL;
1054
1055
1056   if (length != 1) {
1057     PrintError("Invalid Status port read length: %d (port=%d)\n", length, port);
1058     return -1;
1059   }
1060
1061   if (is_primary_port(ramdisk, port)) {
1062     channel = &(ramdisk->channels[0]);
1063   } else if (is_secondary_port(ramdisk, port)) {
1064     channel = &(ramdisk->channels[1]);
1065   } else {
1066     PrintError("Invalid Port: %d\n", port);
1067     return -1;
1068   }
1069
1070   drive = get_selected_drive(channel);
1071   controller = &(drive->controller);
1072
1073
1074   PrintDebug("[read_general_handler] IO read addr at %x, on drive %d/%d, curcmd = %02x\n",
1075              port, get_channel_no(ramdisk, channel),
1076              channel->drive_select,
1077              controller->current_command);
1078
1079
1080   switch (port) {
1081   case PRI_FEATURES_PORT:
1082   case SEC_FEATURES_PORT: // hard disk error register 0x1f1
1083     {
1084       uchar_t val = (drive->device_type == IDE_NONE) ? 0 : controller->error_register;
1085
1086       controller->status.err = 0;
1087
1088       *(uchar_t *)dst = val;
1089       return length;
1090
1091       break;
1092     }
1093
1094   case PRI_SECT_CNT_PORT:
1095   case SEC_SECT_CNT_PORT:  // hard disk sector count / interrupt reason 0x1f2
1096     {
1097       uchar_t val = (drive->device_type == IDE_NONE) ? 0 : controller->sector_count;
1098
1099       *(uchar_t *)dst = val;
1100       return length;
1101
1102       break;
1103     }
1104   case PRI_SECT_ADDR1_PORT:
1105   case SEC_SECT_ADDR1_PORT: // sector number 0x1f3
1106     {
1107       uchar_t val = (drive->device_type == IDE_NONE) ? 0 : controller->sector_no;
1108
1109       *(uchar_t *)dst = val;
1110       return length;
1111
1112       break;
1113     }
1114
1115   case PRI_SECT_ADDR2_PORT:
1116   case SEC_SECT_ADDR2_PORT:  // cylinder low 0x1f4
1117     {
1118       // -- WARNING : On real hardware the controller registers are shared between drives.
1119       // So we must respond even if the select device is not present. Some OS uses this fact
1120       // to detect the disks.... minix2 for example
1121       uchar_t val = (num_drives_on_channel(channel) == 0) ? 0 : (controller->cylinder_no & 0x00ff);
1122
1123       *(uchar_t *)dst = val;
1124       return length;
1125
1126       break;
1127   }
1128
1129   case PRI_SECT_ADDR3_PORT:
1130   case SEC_SECT_ADDR3_PORT: // cylinder high 0x1f5
1131     {
1132       // -- WARNING : On real hardware the controller registers are shared between drives.
1133       // So we must respond even if the select device is not present. Some OS uses this fact
1134       // to detect the disks.... minix2 for example
1135       uchar_t val = (num_drives_on_channel(channel) == 0) ? 0 : (controller->cylinder_no >> 8);
1136
1137       *(uchar_t *)dst = val;
1138       return length;
1139
1140       break;
1141     }
1142   case PRI_DRV_SEL_PORT:
1143   case SEC_DRV_SEL_PORT:  // hard disk drive and head register 0x1f6
1144     {
1145       // b7 Extended data field for ECC
1146       // b6/b5: Used to be sector size.  00=256,01=512,10=1024,11=128
1147       //   Since 512 was always used, bit 6 was taken to mean LBA mode:
1148       //     b6 1=LBA mode, 0=CHS mode
1149       //     b5 1
1150       // b4: DRV
1151       // b3..0 HD3..HD0
1152       uchar_t val = ((1 << 7)                          |
1153                      ((controller->lba_mode > 0) << 6) |
1154                      (1 << 5)                          |            // 01b = 512 sector size
1155                      (channel->drive_select << 4)      |
1156                      (controller->head_no << 0));
1157
1158       *(uchar_t *)dst = val;
1159       return length;
1160
1161       break;
1162     }
1163  case PRI_ADDR_REG_PORT:
1164  case SEC_ADDR_REG_PORT: // Hard Disk Address Register 0x3f7
1165    {
1166      // Obsolete and unsupported register.  Not driven by hard
1167      // disk controller.  Report all 1's.  If floppy controller
1168      // is handling this address, it will call this function
1169      // set/clear D7 (the only bit it handles), then return
1170      // the combined value
1171      *(uchar_t *)dst = 0xff;
1172      return length;
1173     }
1174
1175   default:
1176     PrintError("Invalid Port: %d\n", port);
1177     return -1;
1178   }
1179 }
1180
1181
1182
1183
1184 static int write_general_port(ushort_t port, void * src, uint_t length, struct vm_device * dev) {
1185   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
1186   struct channel_t * channel = NULL;
1187   struct drive_t * drive = NULL;
1188   struct controller_t * controller = NULL;
1189   uchar_t value = *(uchar_t *)src;
1190
1191   if (length != 1) {
1192     PrintError("Invalid Status port read length: %d (port=%d)\n", length, port);
1193     return -1;
1194   }
1195
1196   if (is_primary_port(ramdisk, port)) {
1197     channel = &(ramdisk->channels[0]);
1198   } else if (is_secondary_port(ramdisk, port)) {
1199     channel = &(ramdisk->channels[1]);
1200   } else {
1201     PrintError("Invalid Port: %d\n", port);
1202     return -1;
1203   }
1204
1205   drive = get_selected_drive(channel);
1206   controller = &(drive->controller);
1207
1208
1209   PrintDebug("[write_general_handler] IO write to port %x (val=0x%02x), channel = %d\n",
1210              port,  value, get_channel_no(ramdisk, channel));
1211
1212   switch (port) {
1213
1214   case PRI_FEATURES_PORT:
1215   case SEC_FEATURES_PORT: // hard disk write precompensation 0x1f1
1216     {
1217       write_features(channel, value);
1218       break;
1219     }
1220   case PRI_SECT_CNT_PORT:
1221   case SEC_SECT_CNT_PORT: // hard disk sector count 0x1f2
1222     {
1223       write_sector_count(channel, value);
1224       break;
1225     }
1226   case PRI_SECT_ADDR1_PORT:
1227   case SEC_SECT_ADDR1_PORT: // hard disk sector number 0x1f3
1228     {
1229       write_sector_number(channel, value);
1230       break;
1231     }
1232   case PRI_SECT_ADDR2_PORT:
1233   case SEC_SECT_ADDR2_PORT: // hard disk cylinder low 0x1f4
1234     {
1235       write_cylinder_low(channel, value);
1236       break;
1237     }
1238   case PRI_SECT_ADDR3_PORT:
1239   case SEC_SECT_ADDR3_PORT: // hard disk cylinder high 0x1f5
1240     {
1241       write_cylinder_high(channel, value);
1242       break;
1243     }
1244   case PRI_DRV_SEL_PORT:
1245   case SEC_DRV_SEL_PORT: // hard disk drive and head register 0x1f6
1246     {
1247       // b7 Extended data field for ECC
1248       // b6/b5: Used to be sector size.  00=256,01=512,10=1024,11=128
1249       //   Since 512 was always used, bit 6 was taken to mean LBA mode:
1250       //     b6 1=LBA mode, 0=CHS mode
1251       //     b5 1
1252       // b4: DRV
1253       // b3..0 HD3..HD0
1254
1255       // 1x1xxxxx
1256
1257       PrintDebug("\tDrive Select value=%x\n", value);
1258
1259       if ((value & 0xa0) != 0xa0) {
1260         PrintDebug("\t\tIO write 0x%x (%02x): not 1x1xxxxxb\n", port, (unsigned) value);
1261       }
1262
1263       write_head_no(channel, value & 0xf);
1264       if ((controller->lba_mode == 0) && (((value >> 6) & 1) == 1)) {
1265         PrintDebug("\t\tenabling LBA mode\n");
1266       }
1267
1268       write_lba_mode(channel, (value >> 6) & 1);
1269
1270
1271
1272       if (drive->cdrom.cd) {
1273         PrintDebug("\t\tSetting LBA on CDROM: %d\n", (value >> 6) & 1);
1274         drive->cdrom.cd->set_LBA(drive->private_data, (value >> 6) & 1);
1275       }
1276
1277
1278       channel->drive_select = (value >> 4) & 0x01;
1279       drive = get_selected_drive(channel);
1280
1281       if (drive->device_type == IDE_NONE) {
1282         PrintDebug("\t\tError: device set to %d which does not exist! channel = 0x%x\n",
1283                    channel->drive_select, get_channel_no(ramdisk, channel));
1284
1285         controller->error_register = 0x04; // aborted
1286         controller->status.err = 1;
1287       }
1288
1289       break;
1290     }
1291   default:
1292     PrintError("\t\thard drive: io write to unhandled port 0x%x  (value = %c)\n", port, value);
1293     //return -1;
1294   }
1295
1296   return length;
1297 }
1298
1299
1300
1301
1302
1303 static void rd_raise_interrupt(struct vm_device * dev, struct channel_t * channel) {
1304   Bit32u irq;
1305   //  struct ramdisk_t * ramdisk = (struct ramdisk_t *)(dev->private_data);
1306   struct drive_t * drive = get_selected_drive(channel);
1307   struct controller_t * controller = &(drive->controller);
1308
1309   PrintDebug("[raise_interrupt] disable_irq = %02x\n", controller->control.disable_irq);
1310
1311   if (!(controller->control.disable_irq)) {
1312     irq = channel->irq;
1313
1314     PrintDebug("\t\tRaising interrupt %d {%s}\n\n", irq, device_type_to_str(drive->device_type));
1315
1316     dev->vm->vm_ops.raise_irq(dev->vm, irq);
1317   } else {
1318     PrintDebug("\t\tirq is disabled\n");
1319   }
1320
1321   return;
1322 }
1323
1324 static void rd_lower_irq(struct vm_device *dev, Bit32u irq)  // __attribute__(regparm(1))
1325 {
1326   PrintDebug("[lower_irq] irq = %d\n", irq);
1327   dev->vm->vm_ops.lower_irq(dev->vm, irq);
1328 }
1329
1330
1331
1332
1333
1334
1335
1336 //////////////////////////////////////////////////////////////////////////
1337
1338 /*
1339  * ATAPI subroutines
1340  */
1341
1342
1343
1344 int handle_atapi_packet_command(struct vm_device * dev, struct channel_t * channel, ushort_t value) {
1345   struct ramdisk_t * ramdisk  = (struct ramdisk_t *)(dev->private_data);
1346   struct drive_t * drive = get_selected_drive(channel);
1347   struct controller_t * controller = &(drive->controller);
1348
1349   if (controller->buffer_index >= PACKET_SIZE) {
1350     PrintError("ATAPI packet exceeded maximum length: buffer_index (%d) >= PACKET_SIZE\n",
1351                controller->buffer_index);
1352     return -1;
1353   }
1354
1355   controller->buffer[controller->buffer_index] = value;
1356   controller->buffer[controller->buffer_index + 1] = (value >> 8);
1357   controller->buffer_index += 2;
1358
1359
1360   /* if packet completely writtten */
1361   if (controller->buffer_index >= PACKET_SIZE) {
1362     // complete command received
1363     Bit8u atapi_command = controller->buffer[0];
1364
1365     PrintDebug("\t\tcdrom: ATAPI command 0x%x started\n", atapi_command);
1366
1367     switch (atapi_command) {
1368     case 0x00: // test unit ready
1369       {
1370         if (drive->cdrom.ready) {
1371           rd_atapi_cmd_nop(dev, channel);
1372         } else {
1373           rd_atapi_cmd_error(dev, channel, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1374         }
1375
1376         rd_raise_interrupt(dev, channel);
1377
1378         break;
1379       }
1380     case 0x03:  // request sense
1381       {
1382         int alloc_length = controller->buffer[4];
1383
1384         if (rd_init_send_atapi_command(dev, channel, atapi_command, 18, alloc_length, false) == -1) {
1385           return -1;
1386         }
1387
1388         // sense data
1389         controller->buffer[0] = 0x70 | (1 << 7);
1390         controller->buffer[1] = 0;
1391         controller->buffer[2] = drive->sense.sense_key;
1392         controller->buffer[3] = drive->sense.information.arr[0];
1393         controller->buffer[4] = drive->sense.information.arr[1];
1394         controller->buffer[5] = drive->sense.information.arr[2];
1395         controller->buffer[6] = drive->sense.information.arr[3];
1396         controller->buffer[7] = 17 - 7;
1397         controller->buffer[8] = drive->sense.specific_inf.arr[0];
1398         controller->buffer[9] = drive->sense.specific_inf.arr[1];
1399         controller->buffer[10] = drive->sense.specific_inf.arr[2];
1400         controller->buffer[11] = drive->sense.specific_inf.arr[3];
1401         controller->buffer[12] = drive->sense.asc;
1402         controller->buffer[13] = drive->sense.ascq;
1403         controller->buffer[14] = drive->sense.fruc;
1404         controller->buffer[15] = drive->sense.key_spec.arr[0];
1405         controller->buffer[16] = drive->sense.key_spec.arr[1];
1406         controller->buffer[17] = drive->sense.key_spec.arr[2];
1407
1408         rd_ready_to_send_atapi(dev, channel);
1409         break;
1410       }
1411     case 0x1b:  // start stop unit
1412       {
1413         //bx_bool Immed = (controller->buffer[1] >> 0) & 1;
1414         rd_bool LoEj = (controller->buffer[4] >> 1) & 1;
1415         rd_bool Start = (controller->buffer[4] >> 0) & 1;
1416
1417         // stop the disc
1418         if ((!LoEj) && (!Start)) {
1419           PrintError("FIXME: Stop disc not implemented\n");
1420
1421           rd_atapi_cmd_nop(dev, channel);
1422           rd_raise_interrupt(dev, channel);
1423         } else if (!LoEj && Start) { // start (spin up) the disc
1424
1425           drive->cdrom.cd->start_cdrom(drive->private_data);
1426
1427           PrintError("FIXME: ATAPI start disc not reading TOC\n");
1428           rd_atapi_cmd_nop(dev, channel);
1429           rd_raise_interrupt(dev, channel);
1430         } else if (LoEj && !Start) { // Eject the disc
1431           rd_atapi_cmd_nop(dev, channel);
1432
1433           if (drive->cdrom.ready) {
1434
1435             drive->cdrom.cd->eject_cdrom(drive->private_data);
1436
1437             drive->cdrom.ready = 0;
1438             //bx_options.atadevice[channel][SLAVE_SELECTED(channel)].Ostatus->set(EJECTED);
1439             //bx_gui->update_drive_status_buttons();
1440           }
1441           rd_raise_interrupt(dev, channel);
1442         } else { // Load the disc
1443           // My guess is that this command only closes the tray, that's a no-op for us
1444           rd_atapi_cmd_nop(dev, channel);
1445           rd_raise_interrupt(dev, channel);
1446         }
1447         break;
1448       }
1449     case 0xbd: // mechanism status
1450       {
1451         uint16_t alloc_length = rd_read_16bit(controller->buffer + 8);
1452
1453         if (alloc_length == 0) {
1454           PrintError("Zero allocation length to MECHANISM STATUS not impl.\n");
1455           return -1;
1456         }
1457
1458         if (rd_init_send_atapi_command(dev, channel, atapi_command, 8, alloc_length, false) == -1) {
1459           return -1;
1460         }
1461
1462         controller->buffer[0] = 0; // reserved for non changers
1463         controller->buffer[1] = 0; // reserved for non changers
1464
1465         controller->buffer[2] = 0; // Current LBA (TODO!)
1466         controller->buffer[3] = 0; // Current LBA (TODO!)
1467         controller->buffer[4] = 0; // Current LBA (TODO!)
1468
1469         controller->buffer[5] = 1; // one slot
1470
1471         controller->buffer[6] = 0; // slot table length
1472         controller->buffer[7] = 0; // slot table length
1473
1474         rd_ready_to_send_atapi(dev, channel);
1475         break;
1476       }
1477     case 0x5a:  // mode sense
1478       {
1479         uint16_t alloc_length = rd_read_16bit(controller->buffer + 7);
1480
1481         Bit8u PC = controller->buffer[2] >> 6;
1482         Bit8u PageCode = controller->buffer[2] & 0x3f;
1483
1484         switch (PC) {
1485         case 0x0: // current values
1486           {
1487             switch (PageCode) {
1488             case 0x01: // error recovery
1489               {
1490
1491                 if (rd_init_send_atapi_command(dev, channel, atapi_command, sizeof(struct error_recovery_t) + 8, alloc_length, false) == -1) {
1492                   return -1;
1493                 }
1494
1495                 rd_init_mode_sense_single(dev, channel, &(drive->cdrom.current.error_recovery),
1496                                           sizeof(struct error_recovery_t));
1497                 rd_ready_to_send_atapi(dev, channel);
1498                 break;
1499               }
1500             case 0x2a: // CD-ROM capabilities & mech. status
1501               {
1502
1503                 if (rd_init_send_atapi_command(dev, channel, atapi_command, 28, alloc_length, false) == -1) {
1504                   return -1;
1505                 }
1506
1507                 rd_init_mode_sense_single(dev, channel, &(controller->buffer[8]), 28);
1508
1509                 controller->buffer[8] = 0x2a;
1510                 controller->buffer[9] = 0x12;
1511                 controller->buffer[10] = 0x00;
1512                 controller->buffer[11] = 0x00;
1513                 // Multisession, Mode 2 Form 2, Mode 2 Form 1
1514                 controller->buffer[12] = 0x70;
1515                 controller->buffer[13] = (3 << 5);
1516                 controller->buffer[14] = (unsigned char) (1 |
1517                                                           (drive->cdrom.locked ? (1 << 1) : 0) |
1518                                                           (1 << 3) |
1519                                                           (1 << 5));
1520                 controller->buffer[15] = 0x00;
1521                 controller->buffer[16] = (706 >> 8) & 0xff;
1522                 controller->buffer[17] = 706 & 0xff;
1523                 controller->buffer[18] = 0;
1524                 controller->buffer[19] = 2;
1525                 controller->buffer[20] = (512 >> 8) & 0xff;
1526                 controller->buffer[21] = 512 & 0xff;
1527                 controller->buffer[22] = (706 >> 8) & 0xff;
1528                 controller->buffer[23] = 706 & 0xff;
1529                 controller->buffer[24] = 0;
1530                 controller->buffer[25] = 0;
1531                 controller->buffer[26] = 0;
1532                 controller->buffer[27] = 0;
1533                 rd_ready_to_send_atapi(dev, channel);
1534                 break;
1535               }
1536             case 0x0d: // CD-ROM
1537             case 0x0e: // CD-ROM audio control
1538             case 0x3f: // all
1539               {
1540                 PrintError("Ramdisk: cdrom: MODE SENSE (curr), code=%x not implemented yet\n",
1541                          PageCode);
1542                 rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST,
1543                                    ASC_INV_FIELD_IN_CMD_PACKET);
1544                 rd_raise_interrupt(dev, channel);
1545                 break;
1546               }
1547             default:
1548               {
1549                 // not implemeted by this device
1550                 PrintDebug("\t\tcdrom: MODE SENSE PC=%x, PageCode=%x, not implemented by device\n",
1551                               PC, PageCode);
1552                 rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST,
1553                                    ASC_INV_FIELD_IN_CMD_PACKET);
1554                 rd_raise_interrupt(dev, channel);
1555                 break;
1556               }
1557             }
1558             break;
1559           }
1560         case 0x1: // changeable values
1561           {
1562             switch (PageCode) {
1563             case 0x01: // error recovery
1564             case 0x0d: // CD-ROM
1565             case 0x0e: // CD-ROM audio control
1566             case 0x2a: // CD-ROM capabilities & mech. status
1567             case 0x3f: // all
1568               {
1569                 PrintError("cdrom: MODE SENSE (chg), code=%x not implemented yet\n",
1570                            PageCode);
1571                 rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST,
1572                                    ASC_INV_FIELD_IN_CMD_PACKET);
1573                 rd_raise_interrupt(dev, channel);
1574                 break;
1575               }
1576             default:
1577               {
1578                 // not implemeted by this device
1579                 PrintDebug("\t\tcdrom: MODE SENSE PC=%x, PageCode=%x, not implemented by device\n",
1580                            PC, PageCode);
1581                 rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST,
1582                                    ASC_INV_FIELD_IN_CMD_PACKET);
1583                 rd_raise_interrupt(dev, channel);
1584                 break;
1585               }
1586             }
1587             break;
1588           }
1589         case 0x2: // default values
1590           {
1591             switch (PageCode) {
1592             case 0x01: // error recovery
1593             case 0x0d: // CD-ROM
1594             case 0x0e: // CD-ROM audio control
1595             case 0x2a: // CD-ROM capabilities & mech. status
1596             case 0x3f: // all
1597               PrintError("cdrom: MODE SENSE (dflt), code=%x\n",
1598                        PageCode);
1599               return -1;
1600
1601             default:
1602               {
1603                 // not implemeted by this device
1604                 PrintDebug("\t\tcdrom: MODE SENSE PC=%x, PageCode=%x, not implemented by device\n",
1605                               PC, PageCode);
1606                 rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST,
1607                                    ASC_INV_FIELD_IN_CMD_PACKET);
1608                 rd_raise_interrupt(dev, channel);
1609                 break;
1610               }
1611             }
1612             break;
1613           }
1614         case 0x3: // saved values not implemented
1615           {
1616             rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST, ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
1617             rd_raise_interrupt(dev, channel);
1618             break;
1619           }
1620         default:
1621           {
1622             PrintError("Should not get here!\n");
1623             return -1;
1624             break;
1625           }
1626         }
1627         break;
1628       }
1629     case 0x12: // inquiry
1630       {
1631         uint8_t alloc_length = controller->buffer[4];
1632
1633         if (rd_init_send_atapi_command(dev, channel, atapi_command, 36, alloc_length, false) == -1) {
1634           return -1;
1635         }
1636
1637         controller->buffer[0] = 0x05; // CD-ROM
1638         controller->buffer[1] = 0x80; // Removable
1639         controller->buffer[2] = 0x00; // ISO, ECMA, ANSI version
1640         controller->buffer[3] = 0x21; // ATAPI-2, as specified
1641         controller->buffer[4] = 31; // additional length (total 36)
1642         controller->buffer[5] = 0x00; // reserved
1643         controller->buffer[6] = 0x00; // reserved
1644         controller->buffer[7] = 0x00; // reserved
1645
1646         // Vendor ID
1647         const char* vendor_id = "VTAB    ";
1648         int i;
1649         for (i = 0; i < 8; i++) {
1650           controller->buffer[8+i] = vendor_id[i];
1651         }
1652
1653         // Product ID
1654         const char* product_id = "Turbo CD-ROM    ";
1655         for (i = 0; i < 16; i++) {
1656           controller->buffer[16+i] = product_id[i];
1657         }
1658
1659         // Product Revision level
1660         const char* rev_level = "1.0 ";
1661         for (i = 0; i < 4; i++) {
1662           controller->buffer[32 + i] = rev_level[i];
1663         }
1664
1665         rd_ready_to_send_atapi(dev, channel);
1666         break;
1667       }
1668     case 0x25:  // read cd-rom capacity
1669       {
1670         // no allocation length???
1671         if (rd_init_send_atapi_command(dev, channel, atapi_command, 8, 8, false) == -1) {
1672           return -1;
1673         }
1674
1675         if (drive->cdrom.ready) {
1676           uint32_t capacity = drive->cdrom.capacity;
1677
1678           PrintDebug("\t\tCapacity is %d sectors (%d bytes)\n", capacity, capacity * 2048);
1679
1680           controller->buffer[0] = (capacity >> 24) & 0xff;
1681           controller->buffer[1] = (capacity >> 16) & 0xff;
1682           controller->buffer[2] = (capacity >> 8) & 0xff;
1683           controller->buffer[3] = (capacity >> 0) & 0xff;
1684           controller->buffer[4] = (2048 >> 24) & 0xff;
1685           controller->buffer[5] = (2048 >> 16) & 0xff;
1686           controller->buffer[6] = (2048 >> 8) & 0xff;
1687           controller->buffer[7] = (2048 >> 0) & 0xff;
1688
1689           rd_ready_to_send_atapi(dev, channel);
1690         } else {
1691           rd_atapi_cmd_error(dev, channel, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1692           rd_raise_interrupt(dev, channel);
1693         }
1694         break;
1695       }
1696
1697
1698     case 0xbe:  // read cd
1699       {
1700         if (drive->cdrom.ready) {
1701           PrintError("Read CD with CD present not implemented\n");
1702           rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST, ASC_INV_FIELD_IN_CMD_PACKET);
1703           rd_raise_interrupt(dev, channel);
1704         } else {
1705           rd_atapi_cmd_error(dev, channel, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1706           rd_raise_interrupt(dev, channel);
1707         }
1708         break;
1709       }
1710     case 0x43: // read toc
1711       {
1712         if (drive->cdrom.ready) {
1713           int toc_length;
1714           bool msf = (controller->buffer[1] >> 1) & 1;
1715           uint8_t starting_track = controller->buffer[6];
1716
1717           uint16_t alloc_length = rd_read_16bit(controller->buffer + 7);
1718
1719           uint8_t format = (controller->buffer[9] >> 6);
1720           int i;
1721           switch (format) {
1722           case 0:
1723
1724             if (!(drive->cdrom.cd->read_toc(drive->private_data, controller->buffer,
1725                                             &toc_length, msf, starting_track))) {
1726               PrintDebug("CDROM: Reading Table of Contents Failed\n");
1727               rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST,
1728                                  ASC_INV_FIELD_IN_CMD_PACKET);
1729               rd_raise_interrupt(dev, channel);
1730             } else {
1731               if (rd_init_send_atapi_command(dev, channel, atapi_command, toc_length, alloc_length, false) == -1) {
1732                 return -1;
1733               }
1734               rd_ready_to_send_atapi(dev, channel);
1735             }
1736             break;
1737
1738           case 1:
1739             // multi session stuff. we ignore this and emulate a single session only
1740             if (rd_init_send_atapi_command(dev, channel, atapi_command, 12, alloc_length, false) == -1) {
1741               return -1;
1742             }
1743
1744             controller->buffer[0] = 0;
1745             controller->buffer[1] = 0x0a;
1746             controller->buffer[2] = 1;
1747             controller->buffer[3] = 1;
1748
1749             for (i = 0; i < 8; i++) {
1750               controller->buffer[4 + i] = 0;
1751             }
1752
1753             rd_ready_to_send_atapi(dev, channel);
1754             break;
1755
1756           case 2:
1757           default:
1758             PrintError("(READ TOC) Format %d not supported\n", format);
1759             return -1;
1760           }
1761         } else {
1762           rd_atapi_cmd_error(dev, channel, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1763           rd_raise_interrupt(dev, channel);
1764         }
1765         break;
1766       }
1767     case 0x28: // read (10)
1768     case 0xa8: // read (12)
1769       {
1770
1771         uint32_t transfer_length;
1772         if (atapi_command == 0x28) {
1773           transfer_length = rd_read_16bit(controller->buffer + 7);
1774         } else {
1775           transfer_length = rd_read_32bit(controller->buffer + 6);
1776         }
1777
1778         uint32_t lba = rd_read_32bit(controller->buffer + 2);
1779
1780         if (!(drive->cdrom.ready)) {
1781           PrintError("CDROM Error: Not Ready (ATA%d/%d)\n",
1782                      get_channel_no(ramdisk, channel), get_drive_no(channel, drive));
1783           rd_atapi_cmd_error(dev, channel, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1784           rd_raise_interrupt(dev, channel);
1785           break;
1786         }
1787
1788         if (transfer_length == 0) {
1789           rd_atapi_cmd_nop(dev, channel);
1790           rd_raise_interrupt(dev, channel);
1791           PrintError("READ(%d) with transfer length 0, ok\n",
1792                      (atapi_command == 0x28) ? 10 : 12);
1793           break;
1794         }
1795
1796         if (lba + transfer_length > drive->cdrom.capacity) {
1797           PrintError("CDROM Error: Capacity exceeded [capacity=%d] (ATA%d/%d)\n",
1798                      drive->cdrom.capacity,
1799                      get_channel_no(ramdisk, channel), get_drive_no(channel, drive));
1800           rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST, ASC_LOGICAL_BLOCK_OOR);
1801           rd_raise_interrupt(dev, channel);
1802           break;
1803         }
1804
1805         PrintDebug("\t\tcdrom: READ (%d) LBA=%d LEN=%d\n",
1806                    (atapi_command == 0x28) ? 10 : 12,
1807                    lba, transfer_length);
1808
1809         // handle command
1810         if (rd_init_send_atapi_command(dev, channel, atapi_command, transfer_length * 2048,
1811                                        transfer_length * 2048, true) == -1) {
1812           PrintError("CDROM Error: Atapi command send error\n");
1813           return -1;
1814         }
1815
1816         drive->cdrom.remaining_blocks = transfer_length;
1817         drive->cdrom.next_lba = lba;
1818         rd_ready_to_send_atapi(dev, channel);
1819         break;
1820       }
1821     case 0x2b:  // seek
1822       {
1823         uint32_t lba = rd_read_32bit(controller->buffer + 2);
1824
1825         if (!(drive->cdrom.ready)) {
1826           rd_atapi_cmd_error(dev, channel, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1827           rd_raise_interrupt(dev, channel);
1828           break;
1829         }
1830
1831         if (lba > drive->cdrom.capacity) {
1832           rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST, ASC_LOGICAL_BLOCK_OOR);
1833           rd_raise_interrupt(dev, channel);
1834           break;
1835         }
1836
1837         PrintDebug("\t\tcdrom: SEEK (ignored)\n");
1838
1839         rd_atapi_cmd_nop(dev, channel);
1840         rd_raise_interrupt(dev, channel);
1841
1842         break;
1843       }
1844     case 0x1e:  // prevent/allow medium removal
1845       {
1846
1847         if (drive->cdrom.ready) {
1848           drive->cdrom.locked = controller->buffer[4] & 1;
1849           rd_atapi_cmd_nop(dev, channel);
1850         } else {
1851           rd_atapi_cmd_error(dev, channel, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1852         }
1853
1854         rd_raise_interrupt(dev, channel);
1855
1856         break;
1857       }
1858     case 0x42:  // read sub-channel
1859       {
1860         //bool msf = get_packet_field(channel,1, 1, 1);
1861         bool sub_q = get_packet_field(channel,2, 6, 1);
1862         //uint8_t data_format = get_packet_byte(channel,3);
1863         //uint8_t track_number = get_packet_byte(channel,6);
1864         uint16_t alloc_length = get_packet_word(channel,7);
1865
1866
1867         /*
1868           UNUSED(msf);
1869           UNUSED(data_format);
1870           UNUSED(track_number);
1871         */
1872         if (!(drive->cdrom.ready)) {
1873           rd_atapi_cmd_error(dev, channel, SENSE_NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1874           rd_raise_interrupt(dev, channel);
1875         } else {
1876           controller->buffer[0] = 0;
1877           controller->buffer[1] = 0; // audio not supported
1878           controller->buffer[2] = 0;
1879           controller->buffer[3] = 0;
1880
1881           int ret_len = 4; // header size
1882
1883           if (sub_q) { // !sub_q == header only
1884             PrintError("Read sub-channel with SubQ not implemented\n");
1885             rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST,
1886                                ASC_INV_FIELD_IN_CMD_PACKET);
1887             rd_raise_interrupt(dev, channel);
1888           }
1889
1890           if (rd_init_send_atapi_command(dev, channel, atapi_command, ret_len, alloc_length, false) == -1) {
1891             return -1;
1892           }
1893           rd_ready_to_send_atapi(dev, channel);
1894         }
1895         break;
1896       }
1897     case 0x51:  // read disc info
1898       {
1899         // no-op to keep the Linux CD-ROM driver happy
1900         rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST, ASC_INV_FIELD_IN_CMD_PACKET);
1901         rd_raise_interrupt(dev, channel);
1902         break;
1903       }
1904     case 0x55: // mode select
1905     case 0xa6: // load/unload cd
1906     case 0x4b: // pause/resume
1907     case 0x45: // play audio
1908     case 0x47: // play audio msf
1909     case 0xbc: // play cd
1910     case 0xb9: // read cd msf
1911     case 0x44: // read header
1912     case 0xba: // scan
1913     case 0xbb: // set cd speed
1914     case 0x4e: // stop play/scan
1915     case 0x46: // ???
1916     case 0x4a: // ???
1917       PrintError("ATAPI command 0x%x not implemented yet\n",
1918                atapi_command);
1919       rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST, ASC_INV_FIELD_IN_CMD_PACKET);
1920       rd_raise_interrupt(dev, channel);
1921       break;
1922     default:
1923       PrintError("Unknown ATAPI command 0x%x (%d)\n",
1924                  atapi_command, atapi_command);
1925       // We'd better signal the error if the user chose to continue
1926       rd_atapi_cmd_error(dev, channel, SENSE_ILLEGAL_REQUEST, ASC_INV_FIELD_IN_CMD_PACKET);
1927       rd_raise_interrupt(dev, channel);
1928       break;
1929     }
1930   }
1931   return 0;
1932 }
1933
1934
1935
1936
1937 int rd_init_send_atapi_command(struct vm_device * dev, struct channel_t * channel, Bit8u command, int req_length, int alloc_length, bool lazy)
1938 {
1939   struct drive_t * drive = &(channel->drives[channel->drive_select]);
1940   struct controller_t * controller = &(drive->controller);
1941
1942   // controller->byte_count is a union of controller->cylinder_no;
1943   // lazy is used to force a data read in the buffer at the next read.
1944
1945   PrintDebug("[rd_init_send_atapi_cmd]\n");
1946
1947   if (controller->byte_count == 0xffff) {
1948     controller->byte_count = 0xfffe;
1949   }
1950
1951   if ((controller->byte_count & 1) &&
1952       !(alloc_length <= controller->byte_count)) {
1953
1954     PrintDebug("\t\tOdd byte count (0x%04x) to ATAPI command 0x%02x, using 0x%x\n",
1955                   controller->byte_count,
1956                   command,
1957                   controller->byte_count - 1);
1958
1959     controller->byte_count -= 1;
1960   }
1961
1962   if (controller->byte_count == 0) {
1963     PrintError("\t\tATAPI command with zero byte count\n");
1964     return -1;
1965   }
1966
1967   if (alloc_length < 0) {
1968     PrintError("\t\tAllocation length < 0\n");
1969     return -1;
1970   }
1971
1972   if (alloc_length == 0) {
1973     alloc_length = controller->byte_count;
1974   }
1975
1976   controller->interrupt_reason.i_o = 1;
1977   controller->interrupt_reason.c_d = 0;
1978   controller->status.busy = 0;
1979   controller->status.drq = 1;
1980   controller->status.err = 0;
1981
1982   // no bytes transfered yet
1983   if (lazy) {
1984     controller->buffer_index = 2048;
1985   } else {
1986     controller->buffer_index = 0;
1987   }
1988
1989   controller->drq_index = 0;
1990
1991   if (controller->byte_count > req_length) {
1992     controller->byte_count = req_length;
1993   }
1994
1995   if (controller->byte_count > alloc_length) {
1996     controller->byte_count = alloc_length;
1997   }
1998
1999   drive->atapi.command = command;
2000   drive->atapi.drq_bytes = controller->byte_count;
2001   drive->atapi.total_bytes_remaining = (req_length < alloc_length) ? req_length : alloc_length;
2002
2003   // if (lazy) {
2004   // // bias drq_bytes and total_bytes_remaining
2005   // SELECTED_DRIVE(channel).atapi.drq_bytes += 2048;
2006   // SELECTED_DRIVE(channel).atapi.total_bytes_remaining += 2048;
2007   // }
2008
2009   return 0;
2010 }
2011
2012
2013
2014  void rd_ready_to_send_atapi(struct vm_device * dev, struct channel_t * channel) {
2015   PrintDebug("[rd_ready_to_send_atapi]\n");
2016
2017   rd_raise_interrupt(dev, channel);
2018 }
2019
2020
2021
2022
2023
2024 void rd_atapi_cmd_error(struct vm_device * dev, struct channel_t * channel, sense_t sense_key, asc_t asc)
2025 {
2026   struct drive_t * drive = &(channel->drives[channel->drive_select]);
2027   struct controller_t * controller = &(drive->controller);
2028
2029 #ifdef DEBUG_RAMDISK
2030   {
2031     struct ramdisk_t *ramdisk = (struct ramdisk_t *)(dev->private_data);
2032     PrintDebug("[rd_atapi_cmd_error]\n");
2033     PrintDebug("Error: atapi_cmd_error channel=%02x key=%02x asc=%02x\n",
2034                get_channel_no(ramdisk, channel), sense_key, asc);
2035   }
2036 #endif
2037
2038   controller->error_register = sense_key << 4;
2039   controller->interrupt_reason.i_o = 1;
2040   controller->interrupt_reason.c_d = 1;
2041   controller->interrupt_reason.rel = 0;
2042   controller->status.busy = 0;
2043   controller->status.drive_ready = 1;
2044   controller->status.write_fault = 0;
2045   controller->status.drq = 0;
2046   controller->status.err = 1;
2047
2048   drive->sense.sense_key = sense_key;
2049   drive->sense.asc = asc;
2050   drive->sense.ascq = 0;
2051 }
2052
2053
2054
2055 void rd_atapi_cmd_nop(struct vm_device * dev, struct channel_t * channel)
2056 {
2057   struct drive_t * drive = &(channel->drives[channel->drive_select]);
2058   struct controller_t * controller = &(drive->controller);
2059
2060   PrintDebug("[rd_atapi_cmd_nop]\n");
2061   controller->interrupt_reason.i_o = 1;
2062   controller->interrupt_reason.c_d = 1;
2063   controller->interrupt_reason.rel = 0;
2064   controller->status.busy = 0;
2065   controller->status.drive_ready = 1;
2066   controller->status.drq = 0;
2067   controller->status.err = 0;
2068 }
2069
2070
2071
2072
2073 void rd_identify_ATAPI_drive(struct vm_device * dev, struct channel_t * channel)
2074 {
2075   struct drive_t * drive = &(channel->drives[channel->drive_select]);
2076   struct controller_t * controller = &(drive->controller);
2077
2078
2079   uint_t i;
2080   const char* serial_number = " VT00001\0\0\0\0\0\0\0\0\0\0\0\0";
2081   const char* firmware = "ALPHA1  ";
2082
2083   drive->id_drive[0] = (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0); // Removable CDROM, 50us response, 12 byte packets
2084
2085   for (i = 1; i <= 9; i++) {
2086     drive->id_drive[i] = 0;
2087   }
2088
2089   for (i = 0; i < 10; i++) {
2090     drive->id_drive[10 + i] = ((serial_number[i * 2] << 8) |
2091                                (serial_number[(i * 2) + 1]));
2092   }
2093
2094   for (i = 20; i <= 22; i++) {
2095     drive->id_drive[i] = 0;
2096   }
2097
2098   for (i = 0; i < strlen(firmware)/2; i++) {
2099     drive->id_drive[23 + i] = ((firmware[i * 2] << 8) |
2100                                (firmware[(i * 2) + 1]));
2101   }
2102   V3_ASSERT((23 + i) == 27);
2103
2104   for (i = 0; i < strlen((char *)(drive->model_no)) / 2; i++) {
2105     drive->id_drive[27 + i] = ((drive->model_no[i * 2] << 8) |
2106                                (drive->model_no[(i * 2) + 1]));
2107   }
2108   V3_ASSERT((27 + i) == 47);
2109
2110   drive->id_drive[47] = 0;
2111   drive->id_drive[48] = 1; // 32 bits access
2112
2113   drive->id_drive[49] = (1 << 9); // LBA supported
2114
2115   drive->id_drive[50] = 0;
2116   drive->id_drive[51] = 0;
2117   drive->id_drive[52] = 0;
2118
2119   drive->id_drive[53] = 3; // words 64-70, 54-58 valid
2120
2121   for (i = 54; i <= 62; i++) {
2122     drive->id_drive[i] = 0;
2123   }
2124
2125   // copied from CFA540A
2126   drive->id_drive[63] = 0x0103; // variable (DMA stuff)
2127   drive->id_drive[64] = 0x0001; // PIO
2128   drive->id_drive[65] = 0x00b4;
2129   drive->id_drive[66] = 0x00b4;
2130   drive->id_drive[67] = 0x012c;
2131   drive->id_drive[68] = 0x00b4;
2132
2133   drive->id_drive[69] = 0;
2134   drive->id_drive[70] = 0;
2135   drive->id_drive[71] = 30; // faked
2136   drive->id_drive[72] = 30; // faked
2137   drive->id_drive[73] = 0;
2138   drive->id_drive[74] = 0;
2139
2140   drive->id_drive[75] = 0;
2141
2142   for (i = 76; i <= 79; i++) {
2143     drive->id_drive[i] = 0;
2144   }
2145
2146   drive->id_drive[80] = 0x1e; // supports up to ATA/ATAPI-4
2147   drive->id_drive[81] = 0;
2148   drive->id_drive[82] = 0;
2149   drive->id_drive[83] = 0;
2150   drive->id_drive[84] = 0;
2151   drive->id_drive[85] = 0;
2152   drive->id_drive[86] = 0;
2153   drive->id_drive[87] = 0;
2154   drive->id_drive[88] = 0;
2155
2156   for (i = 89; i <= 126; i++) {
2157     drive->id_drive[i] = 0;
2158   }
2159
2160   drive->id_drive[127] = 0;
2161   drive->id_drive[128] = 0;
2162
2163   for (i = 129; i <= 159; i++) {
2164     drive->id_drive[i] = 0;
2165   }
2166
2167   for (i = 160; i <= 255; i++) {
2168     drive->id_drive[i] = 0;
2169   }
2170
2171   // now convert the id_drive array (native 256 word format) to
2172   // the controller buffer (512 bytes)
2173   Bit16u temp16;
2174   for (i = 0; i <= 255; i++) {
2175     temp16 = drive->id_drive[i];
2176     controller->buffer[i * 2] = temp16 & 0x00ff;
2177     controller->buffer[i * 2 + 1] = temp16 >> 8;
2178   }
2179
2180   return;
2181 }
2182
2183
2184
2185
2186
2187
2188
2189 static
2190 void rd_init_mode_sense_single(struct vm_device * dev,
2191                                struct channel_t * channel, const void* src, int size)
2192 {
2193   struct drive_t * drive = &(channel->drives[channel->drive_select]);
2194   struct controller_t * controller = &(drive->controller);
2195
2196   PrintDebug("[rd_init_mode_sense_single]\n");
2197
2198   // Header
2199   controller->buffer[0] = (size + 6) >> 8;
2200   controller->buffer[1] = (size + 6) & 0xff;
2201   controller->buffer[2] = 0x70; // no media present
2202   controller->buffer[3] = 0; // reserved
2203   controller->buffer[4] = 0; // reserved
2204   controller->buffer[5] = 0; // reserved
2205   controller->buffer[6] = 0; // reserved
2206   controller->buffer[7] = 0; // reserved
2207
2208   // Data
2209   memcpy(controller->buffer + 8, src, size);
2210 }
2211
2212
2213
2214 static void rd_command_aborted(struct vm_device * dev,
2215                                struct channel_t * channel, unsigned value) {
2216   struct drive_t * drive = &(channel->drives[channel->drive_select]);
2217   struct controller_t * controller = &(drive->controller);
2218
2219   PrintDebug("[rd_command_aborted]\n");
2220   PrintDebug("\t\taborting on command 0x%02x {%s}\n", value, device_type_to_str(drive->device_type));
2221
2222   controller->current_command = 0;
2223   controller->status.busy = 0;
2224   controller->status.drive_ready = 1;
2225   controller->status.err = 1;
2226   controller->error_register = 0x04; // command ABORTED
2227   controller->status.drq = 0;
2228   controller->status.seek_complete = 0;
2229   controller->status.corrected_data = 0;
2230   controller->buffer_index = 0;
2231
2232   rd_raise_interrupt(dev, channel);
2233 }
2234
2235
2236 static int ramdisk_init_device(struct vm_device *dev) {
2237   struct ramdisk_t *ramdisk= (struct ramdisk_t *)dev->private_data;
2238
2239   PrintDebug("Initializing Ramdisk\n");
2240
2241
2242   rd_init_hardware(ramdisk);
2243
2244
2245   dev_hook_io(dev, PRI_CTRL_PORT,
2246               &read_status_port, &write_ctrl_port);
2247
2248   dev_hook_io(dev, PRI_DATA_PORT,
2249               &read_data_port, &write_data_port);
2250   dev_hook_io(dev, PRI_FEATURES_PORT,
2251               &read_general_port, &write_general_port);
2252   dev_hook_io(dev, PRI_SECT_CNT_PORT,
2253               &read_general_port, &write_general_port);
2254   dev_hook_io(dev, PRI_SECT_ADDR1_PORT,
2255               &read_general_port, &write_general_port);
2256   dev_hook_io(dev, PRI_SECT_ADDR2_PORT,
2257               &read_general_port, &write_general_port);
2258   dev_hook_io(dev, PRI_SECT_ADDR3_PORT,
2259               &read_general_port, &write_general_port);
2260   dev_hook_io(dev, PRI_DRV_SEL_PORT,
2261               &read_general_port, &write_general_port);
2262   dev_hook_io(dev, PRI_CMD_PORT,
2263               &read_status_port, &write_cmd_port);
2264
2265
2266   dev_hook_io(dev, SEC_CTRL_PORT,
2267               &read_status_port, &write_ctrl_port);
2268
2269   dev_hook_io(dev, SEC_DATA_PORT,
2270               &read_data_port, &write_data_port);
2271   dev_hook_io(dev, SEC_FEATURES_PORT,
2272               &read_general_port, &write_general_port);
2273   dev_hook_io(dev, SEC_SECT_CNT_PORT,
2274               &read_general_port, &write_general_port);
2275   dev_hook_io(dev, SEC_SECT_ADDR1_PORT,
2276               &read_general_port, &write_general_port);
2277   dev_hook_io(dev, SEC_SECT_ADDR2_PORT,
2278               &read_general_port, &write_general_port);
2279   dev_hook_io(dev, SEC_SECT_ADDR3_PORT,
2280               &read_general_port, &write_general_port);
2281   dev_hook_io(dev, SEC_DRV_SEL_PORT,
2282               &read_general_port, &write_general_port);
2283   dev_hook_io(dev, SEC_CMD_PORT,
2284               &read_status_port, &write_cmd_port);
2285
2286
2287
2288   dev_hook_io(dev, SEC_ADDR_REG_PORT,
2289               &read_general_port, &write_general_port);
2290
2291   dev_hook_io(dev, PRI_ADDR_REG_PORT,
2292               &read_general_port, &write_general_port);
2293
2294
2295
2296   return 0;
2297
2298 }
2299
2300
2301 static int ramdisk_deinit_device(struct vm_device *dev) {
2302   struct ramdisk_t *ramdisk = (struct ramdisk_t *)(dev->private_data);
2303   rd_close_harddrive(ramdisk);
2304   return 0;
2305 }
2306
2307 static struct vm_device_ops dev_ops = {
2308   .init = ramdisk_init_device,
2309   .deinit = ramdisk_deinit_device,
2310   .reset = NULL,
2311   .start = NULL,
2312   .stop = NULL,
2313 };
2314
2315
2316
2317
2318 struct vm_device *create_ramdisk()
2319 {
2320
2321   struct ramdisk_t *ramdisk;
2322   ramdisk = (struct ramdisk_t *)V3_Malloc(sizeof(struct ramdisk_t));
2323   V3_ASSERT(ramdisk != NULL);
2324
2325   PrintDebug("[create_ramdisk]\n");
2326
2327   struct vm_device *device = create_device("RAMDISK", &dev_ops, ramdisk);
2328
2329   return device;
2330 }
2331
2332
2333
2334
2335 #ifdef DEBUG_RAMDISK
2336
2337 static void rd_print_state(struct ramdisk_t * ramdisk) {
2338   uchar_t channel;
2339   uchar_t device;
2340   struct channel_t * channels = (struct channel_t *)(&(ramdisk->channels));
2341
2342   /*
2343   for (channel = 0; channel < MAX_ATA_CHANNEL; channel++) {
2344     memset((char *)(channels + channel), 0, sizeof(struct channel_t));
2345   }
2346   */
2347   PrintDebug("sizeof(*channels) = %d\n", sizeof(*channels));
2348   PrintDebug("sizeof(channles->drives[0].controller) = %d\n", sizeof((channels->drives[0].controller)));
2349   PrintDebug("sizeof(channles->drives[0].cdrom) = %d\n", sizeof((channels->drives[0].cdrom)));
2350   PrintDebug("sizeof(channles->drives[0].sense) = %d\n", sizeof((channels->drives[0].sense)));
2351   PrintDebug("sizeof(channles->drives[0].atapi) = %d\n", sizeof((channels->drives[0].atapi)));
2352
2353
2354   PrintDebug("sizeof(channles->drives[0].controller.status) = %d\n",
2355                 sizeof((channels->drives[0].controller.status)));
2356   PrintDebug("sizeof(channles->drives[0].controller.sector_count) = %d\n",
2357                 sizeof((channels->drives[0].controller.sector_count)));
2358   PrintDebug("sizeof(channles->drives[0].controller.interrupt_reason) = %d\n",
2359                 sizeof((channels->drives[0].controller.interrupt_reason)));
2360
2361   PrintDebug("sizeof(channles->drives[0].controller.cylinder_no) = %d\n",
2362                 sizeof((channels->drives[0].controller.cylinder_no)));
2363   PrintDebug("sizeof(channles->drives[0].controller.byte_count) = %d\n",
2364                 sizeof((channels->drives[0].controller.byte_count)));
2365
2366
2367   PrintDebug("sizeof(channles->drives[0].controller.control) = %d\n",
2368                 sizeof((channels->drives[0].controller.control)));
2369
2370
2371   for (channel = 0; channel < MAX_ATA_CHANNEL; channel++){
2372
2373     for (device = 0; device < 2; device++){
2374
2375       // Initialize controller state, even if device is not present
2376       PrintDebug("channels[%d].drives[%d].controller.status.busy = %d\n",
2377                     channel, device,
2378                     channels[channel].drives[device].controller.status.busy);
2379       PrintDebug("channels[%d].drives[%d].controller.status.drive_ready = %d\n",
2380                     channel, device,
2381                     channels[channel].drives[device].controller.status.drive_ready);
2382       PrintDebug("channels[%d].drives[%d].controller.status.write_fault = %d\n",
2383                     channel, device,
2384                     channels[channel].drives[device].controller.status.write_fault);
2385       PrintDebug("channels[%d].drives[%d].controller.status.seek_complete = %d\n",
2386                     channel, device,
2387                     channels[channel].drives[device].controller.status.seek_complete);
2388       PrintDebug("channels[%d].drives[%d].controller.status.drq = %d\n",
2389                     channel, device,
2390                     channels[channel].drives[device].controller.status.drq);
2391       PrintDebug("channels[%d].drives[%d].controller.status.corrected_data = %d\n",
2392                     channel, device,
2393                     channels[channel].drives[device].controller.status.corrected_data);
2394       PrintDebug("channels[%d].drives[%d].controller.status.index_pulse = %d\n",
2395                     channel, device,
2396                     channels[channel].drives[device].controller.status.index_pulse);
2397       PrintDebug("channels[%d].drives[%d].controller.status.index_pulse_count = %d\n",
2398                     channel, device,
2399                     channels[channel].drives[device].controller.status.index_pulse_count);
2400       PrintDebug("channels[%d].drives[%d].controller.status.err = %d\n",
2401                     channel, device,
2402                     channels[channel].drives[device].controller.status.err);
2403
2404
2405       PrintDebug("channels[%d].drives[%d].controller.error_register = %d\n",
2406                     channel, device,
2407                     channels[channel].drives[device].controller.error_register);
2408       PrintDebug("channels[%d].drives[%d].controller.head_no = %d\n",
2409                     channel, device,
2410                     channels[channel].drives[device].controller.head_no);
2411       PrintDebug("channels[%d].drives[%d].controller.sector_count = %d\n",
2412                     channel, device,
2413                     channels[channel].drives[device].controller.sector_count);
2414       PrintDebug("channels[%d].drives[%d].controller.sector_no = %d\n",
2415                     channel, device,
2416                     channels[channel].drives[device].controller.sector_no);
2417       PrintDebug("channels[%d].drives[%d].controller.cylinder_no = %d\n",
2418                     channel, device,
2419                     channels[channel].drives[device].controller.cylinder_no);
2420       PrintDebug("channels[%d].drives[%d].controller.current_command = %02x\n",
2421                     channel, device,
2422                     channels[channel].drives[device].controller.current_command);
2423       PrintDebug("channels[%d].drives[%d].controller.buffer_index = %d\n",
2424                     channel, device,
2425                     channels[channel].drives[device].controller.buffer_index);
2426
2427
2428       PrintDebug("channels[%d].drives[%d].controller.control.reset = %d\n",
2429                     channel, device,
2430                     channels[channel].drives[device].controller.control.reset);
2431       PrintDebug("channels[%d].drives[%d].controller.control.disable_irq = %d\n",
2432                     channel, device,
2433                     channels[channel].drives[device].controller.control.disable_irq);
2434
2435
2436       PrintDebug("channels[%d].drives[%d].controller.reset_in_progress = %d\n",
2437                     channel, device,
2438                     channels[channel].drives[device].controller.reset_in_progress);
2439       PrintDebug("channels[%d].drives[%d].controller.sectors_per_block = %02x\n",
2440                     channel, device,
2441                     channels[channel].drives[device].controller.sectors_per_block);
2442       PrintDebug("channels[%d].drives[%d].controller.lba_mode = %d\n",
2443                     channel, device,
2444                     channels[channel].drives[device].controller.lba_mode);
2445       PrintDebug("channels[%d].drives[%d].controller.features = %d\n",
2446                     channel, device,
2447                     channels[channel].drives[device].controller.features);
2448
2449
2450       PrintDebug("channels[%d].drives[%d].model_no = %s\n",
2451                     channel, device,
2452                     channels[channel].drives[device].model_no);
2453       PrintDebug("channels[%d].drives[%d].device_type = %d\n",
2454                     channel, device,
2455                     channels[channel].drives[device].device_type);
2456       PrintDebug("channels[%d].drives[%d].cdrom.locked = %d\n",
2457                     channel, device,
2458                     channels[channel].drives[device].cdrom.locked);
2459       PrintDebug("channels[%d].drives[%d].sense.sense_key = %d\n",
2460                     channel, device,
2461                     channels[channel].drives[device].sense.sense_key);
2462       PrintDebug("channels[%d].drives[%d].sense.asc = %d\n",
2463                     channel, device,
2464                     channels[channel].drives[device].sense.asc);
2465       PrintDebug("channels[%d].drives[%d].sense.ascq = %d\n",
2466                     channel, device,
2467                     channels[channel].drives[device].sense.ascq);
2468
2469
2470
2471       PrintDebug("channels[%d].drives[%d].controller.interrupt_reason.c_d = %02x\n",
2472                     channel, device,
2473                     channels[channel].drives[device].controller.interrupt_reason.c_d);
2474
2475       PrintDebug("channels[%d].drives[%d].controller.interrupt_reason.i_o = %02x\n",
2476                     channel, device,
2477                     channels[channel].drives[device].controller.interrupt_reason.i_o);
2478
2479       PrintDebug("channels[%d].drives[%d].controller.interrupt_reason.rel = %02x\n",
2480                     channel, device,
2481                     channels[channel].drives[device].controller.interrupt_reason.rel);
2482
2483       PrintDebug("channels[%d].drives[%d].controller.interrupt_reason.tag = %02x\n",
2484                     channel, device,
2485                     channels[channel].drives[device].controller.interrupt_reason.tag);
2486
2487       PrintDebug("channels[%d].drives[%d].cdrom.ready = %d\n",
2488                     channel, device,
2489                     channels[channel].drives[device].cdrom.ready);
2490
2491     }  //for device
2492   }  //for channel
2493
2494   return;
2495 }
2496
2497 #if 0
2498 static void trace_info(ushort_t port, void *src, uint_t length) {
2499
2500   switch(port){
2501
2502   case 0x3e8:
2503     if (length == 1 && *((uchar_t*) src) == ATA_DETECT)
2504       PrintDebug("ata_detect()\n");
2505     break;
2506
2507   case 0x3e9:
2508     if (length == 1 && *((uchar_t*) src) == ATA_RESET)
2509       PrintDebug("ata_reset()\n");
2510     break;
2511
2512   case 0x3ea:
2513     if (length == 1 && *((uchar_t*) src) == ATA_CMD_DATA_IN)
2514       PrintDebug("ata_cmd_data_in()\n");
2515     break;
2516
2517   case 0x3eb:
2518     if (length == 1 && *((uchar_t*) src) == ATA_CMD_DATA_OUT)
2519       PrintDebug("ata_cmd_data_out()\n");
2520     break;
2521
2522   case 0x3ec:
2523     if (length == 1 && *((uchar_t*) src) == ATA_CMD_PACKET)
2524       PrintDebug("ata_cmd_packet()\n");
2525     break;
2526
2527   case 0x3ed:
2528     if (length == 1 && *((uchar_t*) src) == ATAPI_GET_SENSE)
2529       PrintDebug("atapi_get_sense()\n");
2530     break;
2531
2532   case 0x3ee:
2533     if (length == 1 && *((uchar_t*) src) == ATAPI_IS_READY)
2534       PrintDebug("atapi_is_ready()\n");
2535     break;
2536
2537   case 0x3ef:
2538     if (length == 1 && *((uchar_t*) src) == ATAPI_IS_CDROM)
2539       PrintDebug("atapi_is_cdrom()\n");
2540     break;
2541
2542
2543   case 0x2e8:
2544     if (length == 1 && *((uchar_t*) src) == CDEMU_INIT)
2545       PrintDebug("cdemu_init()\n");
2546     break;
2547
2548   case 0x2e9:
2549     if (length == 1 && *((uchar_t*) src) == CDEMU_ISACTIVE)
2550       PrintDebug("cdemu_isactive()\n");
2551     break;
2552
2553   case 0x2ea:
2554     if (length == 1 && *((uchar_t*) src) == CDEMU_EMULATED_DRIVE)
2555       PrintDebug("cdemu_emulated_drive()\n");
2556     break;
2557
2558   case 0x2eb:
2559     if (length == 1 && *((uchar_t*) src) == CDROM_BOOT)
2560       PrintDebug("cdrom_boot()\n");
2561     break;
2562
2563   case 0x2ec:
2564     if (length == 1 && *((uchar_t*) src) == HARD_DRIVE_POST)
2565       PrintDebug("ata_hard_drive_post()\n");
2566     break;
2567
2568   case 0x2ed:
2569     if (length == 1)
2570       PrintDebug("ata_device_no(%d)\n", *((uchar_t*) src));
2571     break;
2572
2573   case 0x2ee:
2574     if (length == 1)
2575       PrintDebug("ata_device_type(%d)\n", *((uchar_t*) src));
2576     break;
2577
2578   case 0x2ef:
2579     if (length == 1 && *((uchar_t*) src) == INT13_HARDDISK)
2580       PrintDebug("int13_harddrive()\n");
2581     break;
2582
2583   case 0x2f8:
2584     if (length == 1 && *((uchar_t*) src) == INT13_CDROM)
2585       PrintDebug("int13_cdrom()\n");
2586     break;
2587
2588   case 0x2f9:
2589     if (length == 1 && *((uchar_t*) src) == INT13_CDEMU)
2590       PrintDebug("int13_cdemu()\n");
2591     break;
2592
2593   case 0x2fa:
2594     if (length == 1 && *((uchar_t*) src) == INT13_ELTORITO)
2595       PrintDebug("int13_eltorito()\n");
2596     break;
2597
2598   case 0x2fb:
2599     if (length == 1 && *((uchar_t*) src) == INT13_DISKETTE_FUNCTION)
2600       PrintDebug("int13_diskette_function()\n");
2601     break;
2602
2603
2604   default:
2605     break;
2606   }
2607 }
2608
2609 #endif
2610
2611 static int check_bit_fields(struct controller_t * controller) {
2612   //Check bit fields
2613   controller->sector_count = 0;
2614   controller->interrupt_reason.c_d = 1;
2615   if (controller->sector_count != 0x01) {
2616     return INTR_REASON_BIT_ERR;
2617   }
2618
2619   controller->sector_count = 0;
2620   controller->interrupt_reason.i_o = 1;
2621   if (controller->sector_count != 0x02) {
2622     return INTR_REASON_BIT_ERR;
2623   }
2624
2625   controller->sector_count = 0;
2626   controller->interrupt_reason.rel = 1;
2627   if (controller->sector_count != 0x04) {
2628     return INTR_REASON_BIT_ERR;
2629   }
2630
2631   controller->sector_count = 0;
2632   controller->interrupt_reason.tag = 3;
2633   if (controller->sector_count != 0x18) {
2634     return INTR_REASON_BIT_ERR;
2635   }
2636
2637   return 0;
2638 }
2639 #endif