hw/ide/atapi.c

   1 /*
   2  * QEMU ATAPI Emulation
   3  *
   4  * Copyright (c) 2003 Fabrice Bellard
   5  * Copyright (c) 2006 Openedhand Ltd.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a copy
   8  * of this software and associated documentation files (the "Software"), to deal
   9  * in the Software without restriction, including without limitation the rights
  10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  11  * copies of the Software, and to permit persons to whom the Software is
  12  * furnished to do so, subject to the following conditions:
  13  *
  14  * The above copyright notice and this permission notice shall be included in
  15  * all copies or substantial portions of the Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  23  * THE SOFTWARE.
  24  */
  25
  26 #include "hw/ide/internal.h"
  27 #include "hw/scsi/scsi.h"
  28 #include "sysemu/block-backend.h"
  29
  30 static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);
  31
  32 static void padstr8(uint8_t *buf, int buf_size, const char *src)
  33 {
  34     int i;
  35     for(i = 0; i < buf_size; i++) {
  36         if (*src)
  37             buf[i] = *src++;
  38         else
  39             buf[i] = ' ';
  40     }
  41 }
  42
  43 static inline void cpu_to_ube16(uint8_t *buf, int val)
  44 {
  45     buf[0] = val >> 8;
  46     buf[1] = val & 0xff;
  47 }
  48
  49 static inline void cpu_to_ube32(uint8_t *buf, unsigned int val)
  50 {
  51     buf[0] = val >> 24;
  52     buf[1] = val >> 16;
  53     buf[2] = val >> 8;
  54     buf[3] = val & 0xff;
  55 }
  56
  57 static inline int ube16_to_cpu(const uint8_t *buf)
  58 {
  59     return (buf[0] << 8) | buf[1];
  60 }
  61
  62 static inline int ube32_to_cpu(const uint8_t *buf)
  63 {
  64     return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
  65 }
  66
  67 static void lba_to_msf(uint8_t *buf, int lba)
  68 {
  69     lba += 150;
  70     buf[0] = (lba / 75) / 60;
  71     buf[1] = (lba / 75) % 60;
  72     buf[2] = lba % 75;
  73 }
  74
  75 static inline int media_present(IDEState *s)
  76 {
  77     return !s->tray_open && s->nb_sectors > 0;
  78 }
  79
  80 /* XXX: DVDs that could fit on a CD will be reported as a CD */
  81 static inline int media_is_dvd(IDEState *s)
  82 {
  83     return (media_present(s) && s->nb_sectors > CD_MAX_SECTORS);
  84 }
  85
  86 static inline int media_is_cd(IDEState *s)
  87 {
  88     return (media_present(s) && s->nb_sectors <= CD_MAX_SECTORS);
  89 }
  90
  91 static void cd_data_to_raw(uint8_t *buf, int lba)
  92 {
  93     /* sync bytes */
  94     buf[0] = 0x00;
  95     memset(buf + 1, 0xff, 10);
  96     buf[11] = 0x00;
  97     buf += 12;
  98     /* MSF */
  99     lba_to_msf(buf, lba);
 100     buf[3] = 0x01; /* mode 1 data */
 101     buf += 4;
 102     /* data */
 103     buf += 2048;
 104     /* XXX: ECC not computed */
 105     memset(buf, 0, 288);
 106 }
 107
 108 static int cd_read_sector(IDEState *s, int lba, uint8_t *buf, int sector_size)
 109 {
 110     int ret;
 111
 112     switch(sector_size) {
 113     case 2048:
 114         block_acct_start(blk_get_stats(s->blk), &s->acct,
 115                          4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
 116         ret = blk_read(s->blk, (int64_t)lba << 2, buf, 4);
 117         block_acct_done(blk_get_stats(s->blk), &s->acct);
 118         break;
 119     case 2352:
 120         block_acct_start(blk_get_stats(s->blk), &s->acct,
 121                          4 * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
 122         ret = blk_read(s->blk, (int64_t)lba << 2, buf + 16, 4);
 123         block_acct_done(blk_get_stats(s->blk), &s->acct);
 124         if (ret < 0)
 125             return ret;
 126         cd_data_to_raw(buf, lba);
 127         break;
 128     default:
 129         ret = -EIO;
 130         break;
 131     }
 132     return ret;
 133 }
 134
 135 void ide_atapi_cmd_ok(IDEState *s)
 136 {
 137     s->error = 0;
 138     s->status = READY_STAT | SEEK_STAT;
 139     s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 140     ide_transfer_stop(s);
 141     ide_set_irq(s->bus);
 142 }
 143
 144 void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc)
 145 {
 146 #ifdef DEBUG_IDE_ATAPI
 147     printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key, asc);
 148 #endif
 149     s->error = sense_key << 4;
 150     s->status = READY_STAT | ERR_STAT;
 151     s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 152     s->sense_key = sense_key;
 153     s->asc = asc;
 154     ide_transfer_stop(s);
 155     ide_set_irq(s->bus);
 156 }
 157
 158 void ide_atapi_io_error(IDEState *s, int ret)
 159 {
 160     /* XXX: handle more errors */
 161     if (ret == -ENOMEDIUM) {
 162         ide_atapi_cmd_error(s, NOT_READY,
 163                             ASC_MEDIUM_NOT_PRESENT);
 164     } else {
 165         ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
 166                             ASC_LOGICAL_BLOCK_OOR);
 167     }
 168 }
 169
 170 /* The whole ATAPI transfer logic is handled in this function */
 171 void ide_atapi_cmd_reply_end(IDEState *s)
 172 {
 173     int byte_count_limit, size, ret;
 174 #ifdef DEBUG_IDE_ATAPI
 175     printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
 176            s->packet_transfer_size,
 177            s->elementary_transfer_size,
 178            s->io_buffer_index);
 179 #endif
 180     if (s->packet_transfer_size <= 0) {
 181         /* end of transfer */
 182         ide_atapi_cmd_ok(s);
 183         ide_set_irq(s->bus);
 184 #ifdef DEBUG_IDE_ATAPI
 185         printf("status=0x%x\n", s->status);
 186 #endif
 187     } else {
 188         /* see if a new sector must be read */
 189         if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
 190             ret = cd_read_sector(s, s->lba, s->io_buffer, s->cd_sector_size);
 191             if (ret < 0) {
 192                 ide_atapi_io_error(s, ret);
 193                 return;
 194             }
 195             s->lba++;
 196             s->io_buffer_index = 0;
 197         }
 198         if (s->elementary_transfer_size > 0) {
 199             /* there are some data left to transmit in this elementary
 200                transfer */
 201             size = s->cd_sector_size - s->io_buffer_index;
 202             if (size > s->elementary_transfer_size)
 203                 size = s->elementary_transfer_size;
 204             s->packet_transfer_size -= size;
 205             s->elementary_transfer_size -= size;
 206             s->io_buffer_index += size;
 207             ide_transfer_start(s, s->io_buffer + s->io_buffer_index - size,
 208                                size, ide_atapi_cmd_reply_end);
 209         } else {
 210             /* a new transfer is needed */
 211             s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
 212             byte_count_limit = s->lcyl | (s->hcyl << 8);
 213 #ifdef DEBUG_IDE_ATAPI
 214             printf("byte_count_limit=%d\n", byte_count_limit);
 215 #endif
 216             if (byte_count_limit == 0xffff)
 217                 byte_count_limit--;
 218             size = s->packet_transfer_size;
 219             if (size > byte_count_limit) {
 220                 /* byte count limit must be even if this case */
 221                 if (byte_count_limit & 1)
 222                     byte_count_limit--;
 223                 size = byte_count_limit;
 224             }
 225             s->lcyl = size;
 226             s->hcyl = size >> 8;
 227             s->elementary_transfer_size = size;
 228             /* we cannot transmit more than one sector at a time */
 229             if (s->lba != -1) {
 230                 if (size > (s->cd_sector_size - s->io_buffer_index))
 231                     size = (s->cd_sector_size - s->io_buffer_index);
 232             }
 233             s->packet_transfer_size -= size;
 234             s->elementary_transfer_size -= size;
 235             s->io_buffer_index += size;
 236             ide_transfer_start(s, s->io_buffer + s->io_buffer_index - size,
 237                                size, ide_atapi_cmd_reply_end);
 238             ide_set_irq(s->bus);
 239 #ifdef DEBUG_IDE_ATAPI
 240             printf("status=0x%x\n", s->status);
 241 #endif
 242         }
 243     }
 244 }
 245
 246 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
 247 static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
 248 {
 249     if (size > max_size)
 250         size = max_size;
 251     s->lba = -1; /* no sector read */
 252     s->packet_transfer_size = size;
 253     s->io_buffer_size = size;    /* dma: send the reply data as one chunk */
 254     s->elementary_transfer_size = 0;
 255     s->io_buffer_index = 0;
 256
 257     if (s->atapi_dma) {
 258         block_acct_start(blk_get_stats(s->blk), &s->acct, size,
 259                          BLOCK_ACCT_READ);
 260         s->status = READY_STAT | SEEK_STAT | DRQ_STAT;
 261         ide_start_dma(s, ide_atapi_cmd_read_dma_cb);
 262     } else {
 263         s->status = READY_STAT | SEEK_STAT;
 264         ide_atapi_cmd_reply_end(s);
 265     }
 266 }
 267
 268 /* start a CD-CDROM read command */
 269 static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
 270                                    int sector_size)
 271 {
 272     s->lba = lba;
 273     s->packet_transfer_size = nb_sectors * sector_size;
 274     s->elementary_transfer_size = 0;
 275     s->io_buffer_index = sector_size;
 276     s->cd_sector_size = sector_size;
 277
 278     s->status = READY_STAT | SEEK_STAT;
 279     ide_atapi_cmd_reply_end(s);
 280 }
 281
 282 static void ide_atapi_cmd_check_status(IDEState *s)
 283 {
 284 #ifdef DEBUG_IDE_ATAPI
 285     printf("atapi_cmd_check_status\n");
 286 #endif
 287     s->error = MC_ERR | (UNIT_ATTENTION << 4);
 288     s->status = ERR_STAT;
 289     s->nsector = 0;
 290     ide_set_irq(s->bus);
 291 }
 292 /* ATAPI DMA support */
 293
 294 /* XXX: handle read errors */
 295 static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
 296 {
 297     IDEState *s = opaque;
 298     int data_offset, n;
 299
 300     if (ret < 0) {
 301         ide_atapi_io_error(s, ret);
 302         goto eot;
 303     }
 304
 305     if (s->io_buffer_size > 0) {
 306         /*
 307          * For a cdrom read sector command (s->lba != -1),
 308          * adjust the lba for the next s->io_buffer_size chunk
 309          * and dma the current chunk.
 310          * For a command != read (s->lba == -1), just transfer
 311          * the reply data.
 312          */
 313         if (s->lba != -1) {
 314             if (s->cd_sector_size == 2352) {
 315                 n = 1;
 316                 cd_data_to_raw(s->io_buffer, s->lba);
 317             } else {
 318                 n = s->io_buffer_size >> 11;
 319             }
 320             s->lba += n;
 321         }
 322         s->packet_transfer_size -= s->io_buffer_size;
 323         if (s->bus->dma->ops->rw_buf(s->bus->dma, 1) == 0)
 324             goto eot;
 325     }
 326
 327     if (s->packet_transfer_size <= 0) {
 328         s->status = READY_STAT | SEEK_STAT;
 329         s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 330         ide_set_irq(s->bus);
 331         goto eot;
 332     }
 333
 334     s->io_buffer_index = 0;
 335     if (s->cd_sector_size == 2352) {
 336         n = 1;
 337         s->io_buffer_size = s->cd_sector_size;
 338         data_offset = 16;
 339     } else {
 340         n = s->packet_transfer_size >> 11;
 341         if (n > (IDE_DMA_BUF_SECTORS / 4))
 342             n = (IDE_DMA_BUF_SECTORS / 4);
 343         s->io_buffer_size = n * 2048;
 344         data_offset = 0;
 345     }
 346 #ifdef DEBUG_AIO
 347     printf("aio_read_cd: lba=%u n=%d\n", s->lba, n);
 348 #endif
 349
 350     s->bus->dma->iov.iov_base = (void *)(s->io_buffer + data_offset);
 351     s->bus->dma->iov.iov_len = n * 4 * 512;
 352     qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1);
 353
 354     s->bus->dma->aiocb = blk_aio_readv(s->blk, (int64_t)s->lba << 2,
 355                                        &s->bus->dma->qiov, n * 4,
 356                                        ide_atapi_cmd_read_dma_cb, s);
 357     return;
 358
 359 eot:
 360     block_acct_done(blk_get_stats(s->blk), &s->acct);
 361     ide_set_inactive(s, false);
 362 }
 363
 364 /* start a CD-CDROM read command with DMA */
 365 /* XXX: test if DMA is available */
 366 static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors,
 367                                    int sector_size)
 368 {
 369     s->lba = lba;
 370     s->packet_transfer_size = nb_sectors * sector_size;
 371     s->io_buffer_index = 0;
 372     s->io_buffer_size = 0;
 373     s->cd_sector_size = sector_size;
 374
 375     block_acct_start(blk_get_stats(s->blk), &s->acct, s->packet_transfer_size,
 376                      BLOCK_ACCT_READ);
 377
 378     /* XXX: check if BUSY_STAT should be set */
 379     s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
 380     ide_start_dma(s, ide_atapi_cmd_read_dma_cb);
 381 }
 382
 383 static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors,
 384                                int sector_size)
 385 {
 386 #ifdef DEBUG_IDE_ATAPI
 387     printf("read %s: LBA=%d nb_sectors=%d\n", s->atapi_dma ? "dma" : "pio",
 388         lba, nb_sectors);
 389 #endif
 390     if (s->atapi_dma) {
 391         ide_atapi_cmd_read_dma(s, lba, nb_sectors, sector_size);
 392     } else {
 393         ide_atapi_cmd_read_pio(s, lba, nb_sectors, sector_size);
 394     }
 395 }
 396
 397 static inline uint8_t ide_atapi_set_profile(uint8_t *buf, uint8_t *index,
 398                                             uint16_t profile)
 399 {
 400     uint8_t *buf_profile = buf + 12; /* start of profiles */
 401
 402     buf_profile += ((*index) * 4); /* start of indexed profile */
 403     cpu_to_ube16 (buf_profile, profile);
 404     buf_profile[2] = ((buf_profile[0] == buf[6]) && (buf_profile[1] == buf[7]));
 405
 406     /* each profile adds 4 bytes to the response */
 407     (*index)++;
 408     buf[11] += 4; /* Additional Length */
 409
 410     return 4;
 411 }
 412
 413 static int ide_dvd_read_structure(IDEState *s, int format,
 414                                   const uint8_t *packet, uint8_t *buf)
 415 {
 416     switch (format) {
 417         case 0x0: /* Physical format information */
 418             {
 419                 int layer = packet[6];
 420                 uint64_t total_sectors;
 421
 422                 if (layer != 0)
 423                     return -ASC_INV_FIELD_IN_CMD_PACKET;
 424
 425                 total_sectors = s->nb_sectors >> 2;
 426                 if (total_sectors == 0) {
 427                     return -ASC_MEDIUM_NOT_PRESENT;
 428                 }
 429
 430                 buf[4] = 1;   /* DVD-ROM, part version 1 */
 431                 buf[5] = 0xf; /* 120mm disc, minimum rate unspecified */
 432                 buf[6] = 1;   /* one layer, read-only (per MMC-2 spec) */
 433                 buf[7] = 0;   /* default densities */
 434
 435                 /* FIXME: 0x30000 per spec? */
 436                 cpu_to_ube32(buf + 8, 0); /* start sector */
 437                 cpu_to_ube32(buf + 12, total_sectors - 1); /* end sector */
 438                 cpu_to_ube32(buf + 16, total_sectors - 1); /* l0 end sector */
 439
 440                 /* Size of buffer, not including 2 byte size field */
 441                 stw_be_p(buf, 2048 + 2);
 442
 443                 /* 2k data + 4 byte header */
 444                 return (2048 + 4);
 445             }
 446
 447         case 0x01: /* DVD copyright information */
 448             buf[4] = 0; /* no copyright data */
 449             buf[5] = 0; /* no region restrictions */
 450
 451             /* Size of buffer, not including 2 byte size field */
 452             stw_be_p(buf, 4 + 2);
 453
 454             /* 4 byte header + 4 byte data */
 455             return (4 + 4);
 456
 457         case 0x03: /* BCA information - invalid field for no BCA info */
 458             return -ASC_INV_FIELD_IN_CMD_PACKET;
 459
 460         case 0x04: /* DVD disc manufacturing information */
 461             /* Size of buffer, not including 2 byte size field */
 462             stw_be_p(buf, 2048 + 2);
 463
 464             /* 2k data + 4 byte header */
 465             return (2048 + 4);
 466
 467         case 0xff:
 468             /*
 469              * This lists all the command capabilities above.  Add new ones
 470              * in order and update the length and buffer return values.
 471              */
 472
 473             buf[4] = 0x00; /* Physical format */
 474             buf[5] = 0x40; /* Not writable, is readable */
 475             stw_be_p(buf + 6, 2048 + 4);
 476
 477             buf[8] = 0x01; /* Copyright info */
 478             buf[9] = 0x40; /* Not writable, is readable */
 479             stw_be_p(buf + 10, 4 + 4);
 480
 481             buf[12] = 0x03; /* BCA info */
 482             buf[13] = 0x40; /* Not writable, is readable */
 483             stw_be_p(buf + 14, 188 + 4);
 484
 485             buf[16] = 0x04; /* Manufacturing info */
 486             buf[17] = 0x40; /* Not writable, is readable */
 487             stw_be_p(buf + 18, 2048 + 4);
 488
 489             /* Size of buffer, not including 2 byte size field */
 490             stw_be_p(buf, 16 + 2);
 491
 492             /* data written + 4 byte header */
 493             return (16 + 4);
 494
 495         default: /* TODO: formats beyond DVD-ROM requires */
 496             return -ASC_INV_FIELD_IN_CMD_PACKET;
 497     }
 498 }
 499
 500 static unsigned int event_status_media(IDEState *s,
 501                                        uint8_t *buf)
 502 {
 503     uint8_t event_code, media_status;
 504
 505     media_status = 0;
 506     if (s->tray_open) {
 507         media_status = MS_TRAY_OPEN;
 508     } else if (blk_is_inserted(s->blk)) {
 509         media_status = MS_MEDIA_PRESENT;
 510     }
 511
 512     /* Event notification descriptor */
 513     event_code = MEC_NO_CHANGE;
 514     if (media_status != MS_TRAY_OPEN) {
 515         if (s->events.new_media) {
 516             event_code = MEC_NEW_MEDIA;
 517             s->events.new_media = false;
 518         } else if (s->events.eject_request) {
 519             event_code = MEC_EJECT_REQUESTED;
 520             s->events.eject_request = false;
 521         }
 522     }
 523
 524     buf[4] = event_code;
 525     buf[5] = media_status;
 526
 527     /* These fields are reserved, just clear them. */
 528     buf[6] = 0;
 529     buf[7] = 0;
 530
 531     return 8; /* We wrote to 4 extra bytes from the header */
 532 }
 533
 534 static void cmd_get_event_status_notification(IDEState *s,
 535                                               uint8_t *buf)
 536 {
 537     const uint8_t *packet = buf;
 538
 539     struct {
 540         uint8_t opcode;
 541         uint8_t polled;        /* lsb bit is polled; others are reserved */
 542         uint8_t reserved2[2];
 543         uint8_t class;
 544         uint8_t reserved3[2];
 545         uint16_t len;
 546         uint8_t control;
 547     } QEMU_PACKED *gesn_cdb;
 548
 549     struct {
 550         uint16_t len;
 551         uint8_t notification_class;
 552         uint8_t supported_events;
 553     } QEMU_PACKED *gesn_event_header;
 554     unsigned int max_len, used_len;
 555
 556     gesn_cdb = (void *)packet;
 557     gesn_event_header = (void *)buf;
 558
 559     max_len = be16_to_cpu(gesn_cdb->len);
 560
 561     /* It is fine by the MMC spec to not support async mode operations */
 562     if (!(gesn_cdb->polled & 0x01)) { /* asynchronous mode */
 563         /* Only polling is supported, asynchronous mode is not. */
 564         ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
 565                             ASC_INV_FIELD_IN_CMD_PACKET);
 566         return;
 567     }
 568
 569     /* polling mode operation */
 570
 571     /*
 572      * These are the supported events.
 573      *
 574      * We currently only support requests of the 'media' type.
 575      * Notification class requests and supported event classes are bitmasks,
 576      * but they are build from the same values as the "notification class"
 577      * field.
 578      */
 579     gesn_event_header->supported_events = 1 << GESN_MEDIA;
 580
 581     /*
 582      * We use |= below to set the class field; other bits in this byte
 583      * are reserved now but this is useful to do if we have to use the
 584      * reserved fields later.
 585      */
 586     gesn_event_header->notification_class = 0;
 587
 588     /*
 589      * Responses to requests are to be based on request priority.  The
 590      * notification_class_request_type enum above specifies the
 591      * priority: upper elements are higher prio than lower ones.
 592      */
 593     if (gesn_cdb->class & (1 << GESN_MEDIA)) {
 594         gesn_event_header->notification_class |= GESN_MEDIA;
 595         used_len = event_status_media(s, buf);
 596     } else {
 597         gesn_event_header->notification_class = 0x80; /* No event available */
 598         used_len = sizeof(*gesn_event_header);
 599     }
 600     gesn_event_header->len = cpu_to_be16(used_len
 601                                          - sizeof(*gesn_event_header));
 602     ide_atapi_cmd_reply(s, used_len, max_len);
 603 }
 604
 605 static void cmd_request_sense(IDEState *s, uint8_t *buf)
 606 {
 607     int max_len = buf[4];
 608
 609     memset(buf, 0, 18);
 610     buf[0] = 0x70 | (1 << 7);
 611     buf[2] = s->sense_key;
 612     buf[7] = 10;
 613     buf[12] = s->asc;
 614
 615     if (s->sense_key == UNIT_ATTENTION) {
 616         s->sense_key = NO_SENSE;
 617     }
 618
 619     ide_atapi_cmd_reply(s, 18, max_len);
 620 }
 621
 622 static void cmd_inquiry(IDEState *s, uint8_t *buf)
 623 {
 624     uint8_t page_code = buf[2];
 625     int max_len = buf[4];
 626
 627     unsigned idx = 0;
 628     unsigned size_idx;
 629     unsigned preamble_len;
 630
 631     /* If the EVPD (Enable Vital Product Data) bit is set in byte 1,
 632      * we are being asked for a specific page of info indicated by byte 2. */
 633     if (buf[1] & 0x01) {
 634         preamble_len = 4;
 635         size_idx = 3;
 636
 637         buf[idx++] = 0x05;      /* CD-ROM */
 638         buf[idx++] = page_code; /* Page Code */
 639         buf[idx++] = 0x00;      /* reserved */
 640         idx++;                  /* length (set later) */
 641
 642         switch (page_code) {
 643         case 0x00:
 644             /* Supported Pages: List of supported VPD responses. */
 645             buf[idx++] = 0x00; /* 0x00: Supported Pages, and: */
 646             buf[idx++] = 0x83; /* 0x83: Device Identification. */
 647             break;
 648
 649         case 0x83:
 650             /* Device Identification. Each entry is optional, but the entries
 651              * included here are modeled after libata's VPD responses.
 652              * If the response is given, at least one entry must be present. */
 653
 654             /* Entry 1: Serial */
 655             if (idx + 24 > max_len) {
 656                 /* Not enough room for even the first entry: */
 657                 /* 4 byte header + 20 byte string */
 658                 ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
 659                                     ASC_DATA_PHASE_ERROR);
 660                 return;
 661             }
 662             buf[idx++] = 0x02; /* Ascii */
 663             buf[idx++] = 0x00; /* Vendor Specific */
 664             buf[idx++] = 0x00;
 665             buf[idx++] = 20;   /* Remaining length */
 666             padstr8(buf + idx, 20, s->drive_serial_str);
 667             idx += 20;
 668
 669             /* Entry 2: Drive Model and Serial */
 670             if (idx + 72 > max_len) {
 671                 /* 4 (header) + 8 (vendor) + 60 (model & serial) */
 672                 goto out;
 673             }
 674             buf[idx++] = 0x02; /* Ascii */
 675             buf[idx++] = 0x01; /* T10 Vendor */
 676             buf[idx++] = 0x00;
 677             buf[idx++] = 68;
 678             padstr8(buf + idx, 8, "ATA"); /* Generic T10 vendor */
 679             idx += 8;
 680             padstr8(buf + idx, 40, s->drive_model_str);
 681             idx += 40;
 682             padstr8(buf + idx, 20, s->drive_serial_str);
 683             idx += 20;
 684
 685             /* Entry 3: WWN */
 686             if (s->wwn && (idx + 12 <= max_len)) {
 687                 /* 4 byte header + 8 byte wwn */
 688                 buf[idx++] = 0x01; /* Binary */
 689                 buf[idx++] = 0x03; /* NAA */
 690                 buf[idx++] = 0x00;
 691                 buf[idx++] = 0x08;
 692                 stq_be_p(&buf[idx], s->wwn);
 693                 idx += 8;
 694             }
 695             break;
 696
 697         default:
 698             /* SPC-3, revision 23 sec. 6.4 */
 699             ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
 700                                 ASC_INV_FIELD_IN_CMD_PACKET);
 701             return;
 702         }
 703     } else {
 704         preamble_len = 5;
 705         size_idx = 4;
 706
 707         buf[0] = 0x05; /* CD-ROM */
 708         buf[1] = 0x80; /* removable */
 709         buf[2] = 0x00; /* ISO */
 710         buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
 711         /* buf[size_idx] set below. */
 712         buf[5] = 0;    /* reserved */
 713         buf[6] = 0;    /* reserved */
 714         buf[7] = 0;    /* reserved */
 715         padstr8(buf + 8, 8, "QEMU");
 716         padstr8(buf + 16, 16, "QEMU DVD-ROM");
 717         padstr8(buf + 32, 4, s->version);
 718         idx = 36;
 719     }
 720
 721  out:
 722     buf[size_idx] = idx - preamble_len;
 723     ide_atapi_cmd_reply(s, idx, max_len);
 724     return;
 725 }
 726
 727 static void cmd_get_configuration(IDEState *s, uint8_t *buf)
 728 {
 729     uint32_t len;
 730     uint8_t index = 0;
 731     int max_len;
 732
 733     /* only feature 0 is supported */
 734     if (buf[2] != 0 || buf[3] != 0) {
 735         ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
 736                             ASC_INV_FIELD_IN_CMD_PACKET);
 737         return;
 738     }
 739
 740     /* XXX: could result in alignment problems in some architectures */
 741     max_len = ube16_to_cpu(buf + 7);
 742
 743     /*
 744      * XXX: avoid overflow for io_buffer if max_len is bigger than
 745      *      the size of that buffer (dimensioned to max number of
 746      *      sectors to transfer at once)
 747      *
 748      *      Only a problem if the feature/profiles grow.
 749      */
 750     if (max_len > 512) {
 751         /* XXX: assume 1 sector */
 752         max_len = 512;
 753     }
 754
 755     memset(buf, 0, max_len);
 756     /*
 757      * the number of sectors from the media tells us which profile
 758      * to use as current.  0 means there is no media
 759      */
 760     if (media_is_dvd(s)) {
 761         cpu_to_ube16(buf + 6, MMC_PROFILE_DVD_ROM);
 762     } else if (media_is_cd(s)) {
 763         cpu_to_ube16(buf + 6, MMC_PROFILE_CD_ROM);
 764     }
 765
 766     buf[10] = 0x02 | 0x01; /* persistent and current */
 767     len = 12; /* headers: 8 + 4 */
 768     len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_DVD_ROM);
 769     len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_CD_ROM);
 770     cpu_to_ube32(buf, len - 4); /* data length */
 771
 772     ide_atapi_cmd_reply(s, len, max_len);
 773 }
 774
 775 static void cmd_mode_sense(IDEState *s, uint8_t *buf)
 776 {
 777     int action, code;
 778     int max_len;
 779
 780     max_len = ube16_to_cpu(buf + 7);
 781     action = buf[2] >> 6;
 782     code = buf[2] & 0x3f;
 783
 784     switch(action) {
 785     case 0: /* current values */
 786         switch(code) {
 787         case MODE_PAGE_R_W_ERROR: /* error recovery */
 788             cpu_to_ube16(&buf[0], 16 - 2);
 789             buf[2] = 0x70;
 790             buf[3] = 0;
 791             buf[4] = 0;
 792             buf[5] = 0;
 793             buf[6] = 0;
 794             buf[7] = 0;
 795
 796             buf[8] = MODE_PAGE_R_W_ERROR;
 797             buf[9] = 16 - 10;
 798             buf[10] = 0x00;
 799             buf[11] = 0x05;
 800             buf[12] = 0x00;
 801             buf[13] = 0x00;
 802             buf[14] = 0x00;
 803             buf[15] = 0x00;
 804             ide_atapi_cmd_reply(s, 16, max_len);
 805             break;
 806         case MODE_PAGE_AUDIO_CTL:
 807             cpu_to_ube16(&buf[0], 24 - 2);
 808             buf[2] = 0x70;
 809             buf[3] = 0;
 810             buf[4] = 0;
 811             buf[5] = 0;
 812             buf[6] = 0;
 813             buf[7] = 0;
 814
 815             buf[8] = MODE_PAGE_AUDIO_CTL;
 816             buf[9] = 24 - 10;
 817             /* Fill with CDROM audio volume */
 818             buf[17] = 0;
 819             buf[19] = 0;
 820             buf[21] = 0;
 821             buf[23] = 0;
 822
 823             ide_atapi_cmd_reply(s, 24, max_len);
 824             break;
 825         case MODE_PAGE_CAPABILITIES:
 826             cpu_to_ube16(&buf[0], 30 - 2);
 827             buf[2] = 0x70;
 828             buf[3] = 0;
 829             buf[4] = 0;
 830             buf[5] = 0;
 831             buf[6] = 0;
 832             buf[7] = 0;
 833
 834             buf[8] = MODE_PAGE_CAPABILITIES;
 835             buf[9] = 30 - 10;
 836             buf[10] = 0x3b; /* read CDR/CDRW/DVDROM/DVDR/DVDRAM */
 837             buf[11] = 0x00;
 838
 839             /* Claim PLAY_AUDIO capability (0x01) since some Linux
 840                code checks for this to automount media. */
 841             buf[12] = 0x71;
 842             buf[13] = 3 << 5;
 843             buf[14] = (1 << 0) | (1 << 3) | (1 << 5);
 844             if (s->tray_locked) {
 845                 buf[14] |= 1 << 1;
 846             }
 847             buf[15] = 0x00; /* No volume & mute control, no changer */
 848             cpu_to_ube16(&buf[16], 704); /* 4x read speed */
 849             buf[18] = 0; /* Two volume levels */
 850             buf[19] = 2;
 851             cpu_to_ube16(&buf[20], 512); /* 512k buffer */
 852             cpu_to_ube16(&buf[22], 704); /* 4x read speed current */
 853             buf[24] = 0;
 854             buf[25] = 0;
 855             buf[26] = 0;
 856             buf[27] = 0;
 857             buf[28] = 0;
 858             buf[29] = 0;
 859             ide_atapi_cmd_reply(s, 30, max_len);
 860             break;
 861         default:
 862             goto error_cmd;
 863         }
 864         break;
 865     case 1: /* changeable values */
 866         goto error_cmd;
 867     case 2: /* default values */
 868         goto error_cmd;
 869     default:
 870     case 3: /* saved values */
 871         ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
 872                             ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
 873         break;
 874     }
 875     return;
 876
 877 error_cmd:
 878     ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_INV_FIELD_IN_CMD_PACKET);
 879 }
 880
 881 static void cmd_test_unit_ready(IDEState *s, uint8_t *buf)
 882 {
 883     /* Not Ready Conditions are already handled in ide_atapi_cmd(), so if we
 884      * come here, we know that it's ready. */
 885     ide_atapi_cmd_ok(s);
 886 }
 887
 888 static void cmd_prevent_allow_medium_removal(IDEState *s, uint8_t* buf)
 889 {
 890     s->tray_locked = buf[4] & 1;
 891     blk_lock_medium(s->blk, buf[4] & 1);
 892     ide_atapi_cmd_ok(s);
 893 }
 894
 895 static void cmd_read(IDEState *s, uint8_t* buf)
 896 {
 897     int nb_sectors, lba;
 898
 899     if (buf[0] == GPCMD_READ_10) {
 900         nb_sectors = ube16_to_cpu(buf + 7);
 901     } else {
 902         nb_sectors = ube32_to_cpu(buf + 6);
 903     }
 904
 905     lba = ube32_to_cpu(buf + 2);
 906     if (nb_sectors == 0) {
 907         ide_atapi_cmd_ok(s);
 908         return;
 909     }
 910
 911     ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
 912 }
 913
 914 static void cmd_read_cd(IDEState *s, uint8_t* buf)
 915 {
 916     int nb_sectors, lba, transfer_request;
 917
 918     nb_sectors = (buf[6] << 16) | (buf[7] << 8) | buf[8];
 919     lba = ube32_to_cpu(buf + 2);
 920
 921     if (nb_sectors == 0) {
 922         ide_atapi_cmd_ok(s);
 923         return;
 924     }
 925
 926     transfer_request = buf[9];
 927     switch(transfer_request & 0xf8) {
 928     case 0x00:
 929         /* nothing */
 930         ide_atapi_cmd_ok(s);
 931         break;
 932     case 0x10:
 933         /* normal read */
 934         ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
 935         break;
 936     case 0xf8:
 937         /* read all data */
 938         ide_atapi_cmd_read(s, lba, nb_sectors, 2352);
 939         break;
 940     default:
 941         ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
 942                             ASC_INV_FIELD_IN_CMD_PACKET);
 943         break;
 944     }
 945 }
 946
 947 static void cmd_seek(IDEState *s, uint8_t* buf)
 948 {
 949     unsigned int lba;
 950     uint64_t total_sectors = s->nb_sectors >> 2;
 951
 952     lba = ube32_to_cpu(buf + 2);
 953     if (lba >= total_sectors) {
 954         ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_LOGICAL_BLOCK_OOR);
 955         return;
 956     }
 957
 958     ide_atapi_cmd_ok(s);
 959 }
 960
 961 static void cmd_start_stop_unit(IDEState *s, uint8_t* buf)
 962 {
 963     int sense;
 964     bool start = buf[4] & 1;
 965     bool loej = buf[4] & 2;     /* load on start, eject on !start */
 966     int pwrcnd = buf[4] & 0xf0;
 967
 968     if (pwrcnd) {
 969         /* eject/load only happens for power condition == 0 */
 970         return;
 971     }
 972
 973     if (loej) {
 974         if (!start && !s->tray_open && s->tray_locked) {
 975             sense = blk_is_inserted(s->blk)
 976                 ? NOT_READY : ILLEGAL_REQUEST;
 977             ide_atapi_cmd_error(s, sense, ASC_MEDIA_REMOVAL_PREVENTED);
 978             return;
 979         }
 980
 981         if (s->tray_open != !start) {
 982             blk_eject(s->blk, !start);
 983             s->tray_open = !start;
 984         }
 985     }
 986
 987     ide_atapi_cmd_ok(s);
 988 }
 989
 990 static void cmd_mechanism_status(IDEState *s, uint8_t* buf)
 991 {
 992     int max_len = ube16_to_cpu(buf + 8);
 993
 994     cpu_to_ube16(buf, 0);
 995     /* no current LBA */
 996     buf[2] = 0;
 997     buf[3] = 0;
 998     buf[4] = 0;
 999     buf[5] = 1;
1000     cpu_to_ube16(buf + 6, 0);
1001     ide_atapi_cmd_reply(s, 8, max_len);
1002 }
1003
1004 static void cmd_read_toc_pma_atip(IDEState *s, uint8_t* buf)
1005 {
1006     int format, msf, start_track, len;
1007     int max_len;
1008     uint64_t total_sectors = s->nb_sectors >> 2;
1009
1010     max_len = ube16_to_cpu(buf + 7);
1011     format = buf[9] >> 6;
1012     msf = (buf[1] >> 1) & 1;
1013     start_track = buf[6];
1014
1015     switch(format) {
1016     case 0:
1017         len = cdrom_read_toc(total_sectors, buf, msf, start_track);
1018         if (len < 0)
1019             goto error_cmd;
1020         ide_atapi_cmd_reply(s, len, max_len);
1021         break;
1022     case 1:
1023         /* multi session : only a single session defined */
1024         memset(buf, 0, 12);
1025         buf[1] = 0x0a;
1026         buf[2] = 0x01;
1027         buf[3] = 0x01;
1028         ide_atapi_cmd_reply(s, 12, max_len);
1029         break;
1030     case 2:
1031         len = cdrom_read_toc_raw(total_sectors, buf, msf, start_track);
1032         if (len < 0)
1033             goto error_cmd;
1034         ide_atapi_cmd_reply(s, len, max_len);
1035         break;
1036     default:
1037     error_cmd:
1038         ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1039                             ASC_INV_FIELD_IN_CMD_PACKET);
1040     }
1041 }
1042
1043 static void cmd_read_cdvd_capacity(IDEState *s, uint8_t* buf)
1044 {
1045     uint64_t total_sectors = s->nb_sectors >> 2;
1046
1047     /* NOTE: it is really the number of sectors minus 1 */
1048     cpu_to_ube32(buf, total_sectors - 1);
1049     cpu_to_ube32(buf + 4, 2048);
1050     ide_atapi_cmd_reply(s, 8, 8);
1051 }
1052
1053 static void cmd_read_disc_information(IDEState *s, uint8_t* buf)
1054 {
1055     uint8_t type = buf[1] & 7;
1056     uint32_t max_len = ube16_to_cpu(buf + 7);
1057
1058     /* Types 1/2 are only defined for Blu-Ray.  */
1059     if (type != 0) {
1060         ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1061                             ASC_INV_FIELD_IN_CMD_PACKET);
1062         return;
1063     }
1064
1065     memset(buf, 0, 34);
1066     buf[1] = 32;
1067     buf[2] = 0xe; /* last session complete, disc finalized */
1068     buf[3] = 1;   /* first track on disc */
1069     buf[4] = 1;   /* # of sessions */
1070     buf[5] = 1;   /* first track of last session */
1071     buf[6] = 1;   /* last track of last session */
1072     buf[7] = 0x20; /* unrestricted use */
1073     buf[8] = 0x00; /* CD-ROM or DVD-ROM */
1074     /* 9-10-11: most significant byte corresponding bytes 4-5-6 */
1075     /* 12-23: not meaningful for CD-ROM or DVD-ROM */
1076     /* 24-31: disc bar code */
1077     /* 32: disc application code */
1078     /* 33: number of OPC tables */
1079
1080     ide_atapi_cmd_reply(s, 34, max_len);
1081 }
1082
1083 static void cmd_read_dvd_structure(IDEState *s, uint8_t* buf)
1084 {
1085     int max_len;
1086     int media = buf[1];
1087     int format = buf[7];
1088     int ret;
1089
1090     max_len = ube16_to_cpu(buf + 8);
1091
1092     if (format < 0xff) {
1093         if (media_is_cd(s)) {
1094             ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1095                                 ASC_INCOMPATIBLE_FORMAT);
1096             return;
1097         } else if (!media_present(s)) {
1098             ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1099                                 ASC_INV_FIELD_IN_CMD_PACKET);
1100             return;
1101         }
1102     }
1103
1104     memset(buf, 0, max_len > IDE_DMA_BUF_SECTORS * 512 + 4 ?
1105            IDE_DMA_BUF_SECTORS * 512 + 4 : max_len);
1106
1107     switch (format) {
1108         case 0x00 ... 0x7f:
1109         case 0xff:
1110             if (media == 0) {
1111                 ret = ide_dvd_read_structure(s, format, buf, buf);
1112
1113                 if (ret < 0) {
1114                     ide_atapi_cmd_error(s, ILLEGAL_REQUEST, -ret);
1115                 } else {
1116                     ide_atapi_cmd_reply(s, ret, max_len);
1117                 }
1118
1119                 break;
1120             }
1121             /* TODO: BD support, fall through for now */
1122
1123         /* Generic disk structures */
1124         case 0x80: /* TODO: AACS volume identifier */
1125         case 0x81: /* TODO: AACS media serial number */
1126         case 0x82: /* TODO: AACS media identifier */
1127         case 0x83: /* TODO: AACS media key block */
1128         case 0x90: /* TODO: List of recognized format layers */
1129         case 0xc0: /* TODO: Write protection status */
1130         default:
1131             ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1132                                 ASC_INV_FIELD_IN_CMD_PACKET);
1133             break;
1134     }
1135 }
1136
1137 static void cmd_set_speed(IDEState *s, uint8_t* buf)
1138 {
1139     ide_atapi_cmd_ok(s);
1140 }
1141
1142 enum {
1143     /*
1144      * Only commands flagged as ALLOW_UA are allowed to run under a
1145      * unit attention condition. (See MMC-5, section 4.1.6.1)
1146      */
1147     ALLOW_UA = 0x01,
1148
1149     /*
1150      * Commands flagged with CHECK_READY can only execute if a medium is present.
1151      * Otherwise they report the Not Ready Condition. (See MMC-5, section
1152      * 4.1.8)
1153      */
1154     CHECK_READY = 0x02,
1155 };
1156
1157 static const struct {
1158     void (*handler)(IDEState *s, uint8_t *buf);
1159     int flags;
1160 } atapi_cmd_table[0x100] = {
1161     [ 0x00 ] = { cmd_test_unit_ready,               CHECK_READY },
1162     [ 0x03 ] = { cmd_request_sense,                 ALLOW_UA },
1163     [ 0x12 ] = { cmd_inquiry,                       ALLOW_UA },
1164     [ 0x1b ] = { cmd_start_stop_unit,               0 }, /* [1] */
1165     [ 0x1e ] = { cmd_prevent_allow_medium_removal,  0 },
1166     [ 0x25 ] = { cmd_read_cdvd_capacity,            CHECK_READY },
1167     [ 0x28 ] = { cmd_read, /* (10) */               CHECK_READY },
1168     [ 0x2b ] = { cmd_seek,                          CHECK_READY },
1169     [ 0x43 ] = { cmd_read_toc_pma_atip,             CHECK_READY },
1170     [ 0x46 ] = { cmd_get_configuration,             ALLOW_UA },
1171     [ 0x4a ] = { cmd_get_event_status_notification, ALLOW_UA },
1172     [ 0x51 ] = { cmd_read_disc_information,         CHECK_READY },
1173     [ 0x5a ] = { cmd_mode_sense, /* (10) */         0 },
1174     [ 0xa8 ] = { cmd_read, /* (12) */               CHECK_READY },
1175     [ 0xad ] = { cmd_read_dvd_structure,            CHECK_READY },
1176     [ 0xbb ] = { cmd_set_speed,                     0 },
1177     [ 0xbd ] = { cmd_mechanism_status,              0 },
1178     [ 0xbe ] = { cmd_read_cd,                       CHECK_READY },
1179     /* [1] handler detects and reports not ready condition itself */
1180 };
1181
1182 void ide_atapi_cmd(IDEState *s)
1183 {
1184     uint8_t *buf;
1185
1186     buf = s->io_buffer;
1187 #ifdef DEBUG_IDE_ATAPI
1188     {
1189         int i;
1190         printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8));
1191         for(i = 0; i < ATAPI_PACKET_SIZE; i++) {
1192             printf(" %02x", buf[i]);
1193         }
1194         printf("\n");
1195     }
1196 #endif
1197     /*
1198      * If there's a UNIT_ATTENTION condition pending, only command flagged with
1199      * ALLOW_UA are allowed to complete. with other commands getting a CHECK
1200      * condition response unless a higher priority status, defined by the drive
1201      * here, is pending.
1202      */
1203     if (s->sense_key == UNIT_ATTENTION &&
1204         !(atapi_cmd_table[s->io_buffer[0]].flags & ALLOW_UA)) {
1205         ide_atapi_cmd_check_status(s);
1206         return;
1207     }
1208     /*
1209      * When a CD gets changed, we have to report an ejected state and
1210      * then a loaded state to guests so that they detect tray
1211      * open/close and media change events.  Guests that do not use
1212      * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close
1213      * states rely on this behavior.
1214      */
1215     if (!(atapi_cmd_table[s->io_buffer[0]].flags & ALLOW_UA) &&
1216         !s->tray_open && blk_is_inserted(s->blk) && s->cdrom_changed) {
1217
1218         if (s->cdrom_changed == 1) {
1219             ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1220             s->cdrom_changed = 2;
1221         } else {
1222             ide_atapi_cmd_error(s, UNIT_ATTENTION, ASC_MEDIUM_MAY_HAVE_CHANGED);
1223             s->cdrom_changed = 0;
1224         }
1225
1226         return;
1227     }
1228
1229     /* Report a Not Ready condition if appropriate for the command */
1230     if ((atapi_cmd_table[s->io_buffer[0]].flags & CHECK_READY) &&
1231         (!media_present(s) || !blk_is_inserted(s->blk)))
1232     {
1233         ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1234         return;
1235     }
1236
1237     /* Execute the command */
1238     if (atapi_cmd_table[s->io_buffer[0]].handler) {
1239         atapi_cmd_table[s->io_buffer[0]].handler(s, buf);
1240         return;
1241     }
1242
1243     ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_ILLEGAL_OPCODE);
1244 }