hw/scsi-disk.c

   1 /*
   2  * SCSI Device emulation
   3  *
   4  * Copyright (c) 2006 CodeSourcery.
   5  * Based on code by Fabrice Bellard
   6  *
   7  * Written by Paul Brook
   8  *
   9  * This code is licenced under the LGPL.
  10  *
  11  * Note that this file only handles the SCSI architecture model and device
  12  * commands.  Emulation of interface/link layer protocols is handled by
  13  * the host adapter emulator.
  14  */
  15
  16 //#define DEBUG_SCSI
  17
  18 #ifdef DEBUG_SCSI
  19 #define DPRINTF(fmt, args...) \
  20 do { printf("scsi-disk: " fmt , ##args); } while (0)
  21 #else
  22 #define DPRINTF(fmt, args...) do {} while(0)
  23 #endif
  24
  25 #define BADF(fmt, args...) \
  26 do { fprintf(stderr, "scsi-disk: " fmt , ##args); } while (0)
  27
  28 #include "qemu-common.h"
  29 #include "block.h"
  30 #include "scsi-disk.h"
  31
  32 #define SENSE_NO_SENSE        0
  33 #define SENSE_NOT_READY       2
  34 #define SENSE_HARDWARE_ERROR  4
  35 #define SENSE_ILLEGAL_REQUEST 5
  36
  37 #define SCSI_DMA_BUF_SIZE    65536
  38
  39 typedef struct SCSIRequest {
  40     SCSIDeviceState *dev;
  41     uint32_t tag;
  42     /* ??? We should probably keep track of whether the data trasfer is
  43        a read or a write.  Currently we rely on the host getting it right.  */
  44     /* Both sector and sector_count are in terms of qemu 512 byte blocks.  */
  45     int sector;
  46     int sector_count;
  47     /* The amounnt of data in the buffer.  */
  48     int buf_len;
  49     uint8_t *dma_buf;
  50     BlockDriverAIOCB *aiocb;
  51     struct SCSIRequest *next;
  52 } SCSIRequest;
  53
  54 struct SCSIDeviceState
  55 {
  56     BlockDriverState *bdrv;
  57     SCSIRequest *requests;
  58     /* The qemu block layer uses a fixed 512 byte sector size.
  59        This is the number of 512 byte blocks in a single scsi sector.  */
  60     int cluster_size;
  61     int sense;
  62     int tcq;
  63     /* Completion functions may be called from either scsi_{read,write}_data
  64        or from the AIO completion routines.  */
  65     scsi_completionfn completion;
  66     void *opaque;
  67 };
  68
  69 /* Global pool of SCSIRequest structures.  */
  70 static SCSIRequest *free_requests = NULL;
  71
  72 static SCSIRequest *scsi_new_request(SCSIDeviceState *s, uint32_t tag)
  73 {
  74     SCSIRequest *r;
  75
  76     if (free_requests) {
  77         r = free_requests;
  78         free_requests = r->next;
  79     } else {
  80         r = qemu_malloc(sizeof(SCSIRequest));
  81         r->dma_buf = qemu_memalign(512, SCSI_DMA_BUF_SIZE);
  82     }
  83     r->dev = s;
  84     r->tag = tag;
  85     r->sector_count = 0;
  86     r->buf_len = 0;
  87     r->aiocb = NULL;
  88
  89     r->next = s->requests;
  90     s->requests = r;
  91     return r;
  92 }
  93
  94 static void scsi_remove_request(SCSIRequest *r)
  95 {
  96     SCSIRequest *last;
  97     SCSIDeviceState *s = r->dev;
  98
  99     if (s->requests == r) {
 100         s->requests = r->next;
 101     } else {
 102         last = s->requests;
 103         while (last && last->next != r)
 104             last = last->next;
 105         if (last) {
 106             last->next = r->next;
 107         } else {
 108             BADF("Orphaned request\n");
 109         }
 110     }
 111     r->next = free_requests;
 112     free_requests = r;
 113 }
 114
 115 static SCSIRequest *scsi_find_request(SCSIDeviceState *s, uint32_t tag)
 116 {
 117     SCSIRequest *r;
 118
 119     r = s->requests;
 120     while (r && r->tag != tag)
 121         r = r->next;
 122
 123     return r;
 124 }
 125
 126 /* Helper function for command completion.  */
 127 static void scsi_command_complete(SCSIRequest *r, int sense)
 128 {
 129     SCSIDeviceState *s = r->dev;
 130     uint32_t tag;
 131     DPRINTF("Command complete tag=0x%x sense=%d\n", r->tag, sense);
 132     s->sense = sense;
 133     tag = r->tag;
 134     scsi_remove_request(r);
 135     s->completion(s->opaque, SCSI_REASON_DONE, tag, sense);
 136 }
 137
 138 /* Cancel a pending data transfer.  */
 139 static void scsi_cancel_io(SCSIDevice *d, uint32_t tag)
 140 {
 141     SCSIDeviceState *s = d->state;
 142     SCSIRequest *r;
 143     DPRINTF("Cancel tag=0x%x\n", tag);
 144     r = scsi_find_request(s, tag);
 145     if (r) {
 146         if (r->aiocb)
 147             bdrv_aio_cancel(r->aiocb);
 148         r->aiocb = NULL;
 149         scsi_remove_request(r);
 150     }
 151 }
 152
 153 static void scsi_read_complete(void * opaque, int ret)
 154 {
 155     SCSIRequest *r = (SCSIRequest *)opaque;
 156     SCSIDeviceState *s = r->dev;
 157
 158     if (ret) {
 159         DPRINTF("IO error\n");
 160         scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 161         return;
 162     }
 163     DPRINTF("Data ready tag=0x%x len=%d\n", r->tag, r->buf_len);
 164
 165     s->completion(s->opaque, SCSI_REASON_DATA, r->tag, r->buf_len);
 166 }
 167
 168 /* Read more data from scsi device into buffer.  */
 169 static void scsi_read_data(SCSIDevice *d, uint32_t tag)
 170 {
 171     SCSIDeviceState *s = d->state;
 172     SCSIRequest *r;
 173     uint32_t n;
 174
 175     r = scsi_find_request(s, tag);
 176     if (!r) {
 177         BADF("Bad read tag 0x%x\n", tag);
 178         /* ??? This is the wrong error.  */
 179         scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 180         return;
 181     }
 182     if (r->sector_count == (uint32_t)-1) {
 183         DPRINTF("Read buf_len=%d\n", r->buf_len);
 184         r->sector_count = 0;
 185         s->completion(s->opaque, SCSI_REASON_DATA, r->tag, r->buf_len);
 186         return;
 187     }
 188     DPRINTF("Read sector_count=%d\n", r->sector_count);
 189     if (r->sector_count == 0) {
 190         scsi_command_complete(r, SENSE_NO_SENSE);
 191         return;
 192     }
 193
 194     n = r->sector_count;
 195     if (n > SCSI_DMA_BUF_SIZE / 512)
 196         n = SCSI_DMA_BUF_SIZE / 512;
 197
 198     r->buf_len = n * 512;
 199     r->aiocb = bdrv_aio_read(s->bdrv, r->sector, r->dma_buf, n,
 200                              scsi_read_complete, r);
 201     if (r->aiocb == NULL)
 202         scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 203     r->sector += n;
 204     r->sector_count -= n;
 205 }
 206
 207 static void scsi_write_complete(void * opaque, int ret)
 208 {
 209     SCSIRequest *r = (SCSIRequest *)opaque;
 210     SCSIDeviceState *s = r->dev;
 211     uint32_t len;
 212
 213     if (ret) {
 214         fprintf(stderr, "scsi-disc: IO write error\n");
 215         exit(1);
 216     }
 217
 218     r->aiocb = NULL;
 219     if (r->sector_count == 0) {
 220         scsi_command_complete(r, SENSE_NO_SENSE);
 221     } else {
 222         len = r->sector_count * 512;
 223         if (len > SCSI_DMA_BUF_SIZE) {
 224             len = SCSI_DMA_BUF_SIZE;
 225         }
 226         r->buf_len = len;
 227         DPRINTF("Write complete tag=0x%x more=%d\n", r->tag, len);
 228         s->completion(s->opaque, SCSI_REASON_DATA, r->tag, len);
 229     }
 230 }
 231
 232 /* Write data to a scsi device.  Returns nonzero on failure.
 233    The transfer may complete asynchronously.  */
 234 static int scsi_write_data(SCSIDevice *d, uint32_t tag)
 235 {
 236     SCSIDeviceState *s = d->state;
 237     SCSIRequest *r;
 238     uint32_t n;
 239
 240     DPRINTF("Write data tag=0x%x\n", tag);
 241     r = scsi_find_request(s, tag);
 242     if (!r) {
 243         BADF("Bad write tag 0x%x\n", tag);
 244         scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 245         return 1;
 246     }
 247     if (r->aiocb)
 248         BADF("Data transfer already in progress\n");
 249     n = r->buf_len / 512;
 250     if (n) {
 251         r->aiocb = bdrv_aio_write(s->bdrv, r->sector, r->dma_buf, n,
 252                                   scsi_write_complete, r);
 253         if (r->aiocb == NULL)
 254             scsi_command_complete(r, SENSE_HARDWARE_ERROR);
 255         r->sector += n;
 256         r->sector_count -= n;
 257     } else {
 258         /* Invoke completion routine to fetch data from host.  */
 259         scsi_write_complete(r, 0);
 260     }
 261
 262     return 0;
 263 }
 264
 265 /* Return a pointer to the data buffer.  */
 266 static uint8_t *scsi_get_buf(SCSIDevice *d, uint32_t tag)
 267 {
 268     SCSIDeviceState *s = d->state;
 269     SCSIRequest *r;
 270
 271     r = scsi_find_request(s, tag);
 272     if (!r) {
 273         BADF("Bad buffer tag 0x%x\n", tag);
 274         return NULL;
 275     }
 276     return r->dma_buf;
 277 }
 278
 279 /* Execute a scsi command.  Returns the length of the data expected by the
 280    command.  This will be Positive for data transfers from the device
 281    (eg. disk reads), negative for transfers to the device (eg. disk writes),
 282    and zero if the command does not transfer any data.  */
 283
 284 static int32_t scsi_send_command(SCSIDevice *d, uint32_t tag,
 285                                  uint8_t *buf, int lun)
 286 {
 287     SCSIDeviceState *s = d->state;
 288     uint64_t nb_sectors;
 289     uint32_t lba;
 290     uint32_t len;
 291     int cmdlen;
 292     int is_write;
 293     uint8_t command;
 294     uint8_t *outbuf;
 295     SCSIRequest *r;
 296
 297     command = buf[0];
 298     r = scsi_find_request(s, tag);
 299     if (r) {
 300         BADF("Tag 0x%x already in use\n", tag);
 301         scsi_cancel_io(d, tag);
 302     }
 303     /* ??? Tags are not unique for different luns.  We only implement a
 304        single lun, so this should not matter.  */
 305     r = scsi_new_request(s, tag);
 306     outbuf = r->dma_buf;
 307     is_write = 0;
 308     DPRINTF("Command: lun=%d tag=0x%x data=0x%02x", lun, tag, buf[0]);
 309     switch (command >> 5) {
 310     case 0:
 311         lba = buf[3] | (buf[2] << 8) | ((buf[1] & 0x1f) << 16);
 312         len = buf[4];
 313         cmdlen = 6;
 314         break;
 315     case 1:
 316     case 2:
 317         lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
 318         len = buf[8] | (buf[7] << 8);
 319         cmdlen = 10;
 320         break;
 321     case 4:
 322         lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
 323         len = buf[13] | (buf[12] << 8) | (buf[11] << 16) | (buf[10] << 24);
 324         cmdlen = 16;
 325         break;
 326     case 5:
 327         lba = buf[5] | (buf[4] << 8) | (buf[3] << 16) | (buf[2] << 24);
 328         len = buf[9] | (buf[8] << 8) | (buf[7] << 16) | (buf[6] << 24);
 329         cmdlen = 12;
 330         break;
 331     default:
 332         BADF("Unsupported command length, command %x\n", command);
 333         goto fail;
 334     }
 335 #ifdef DEBUG_SCSI
 336     {
 337         int i;
 338         for (i = 1; i < cmdlen; i++) {
 339             printf(" 0x%02x", buf[i]);
 340         }
 341         printf("\n");
 342     }
 343 #endif
 344     if (lun || buf[1] >> 5) {
 345         /* Only LUN 0 supported.  */
 346         DPRINTF("Unimplemented LUN %d\n", lun ? lun : buf[1] >> 5);
 347         goto fail;
 348     }
 349     switch (command) {
 350     case 0x0:
 351         DPRINTF("Test Unit Ready\n");
 352         break;
 353     case 0x03:
 354         DPRINTF("Request Sense (len %d)\n", len);
 355         if (len < 4)
 356             goto fail;
 357         memset(outbuf, 0, 4);
 358         outbuf[0] = 0xf0;
 359         outbuf[1] = 0;
 360         outbuf[2] = s->sense;
 361         r->buf_len = 4;
 362         break;
 363     case 0x12:
 364         DPRINTF("Inquiry (len %d)\n", len);
 365         if (buf[1] & 0x2) {
 366             /* Command support data - optional, not implemented */
 367             BADF("optional INQUIRY command support request not implemented\n");
 368             goto fail;
 369         }
 370         else if (buf[1] & 0x1) {
 371             /* Vital product data */
 372             uint8_t page_code = buf[2];
 373             if (len < 4) {
 374                 BADF("Error: Inquiry (EVPD[%02X]) buffer size %d is "
 375                      "less than 4\n", page_code, len);
 376                 goto fail;
 377             }
 378
 379             switch (page_code) {
 380                 case 0x00:
 381                     {
 382                         /* Supported page codes, mandatory */
 383                         DPRINTF("Inquiry EVPD[Supported pages] "
 384                                 "buffer size %d\n", len);
 385
 386                         r->buf_len = 0;
 387
 388                         if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 389                             outbuf[r->buf_len++] = 5;
 390                         } else {
 391                             outbuf[r->buf_len++] = 0;
 392                         }
 393
 394                         outbuf[r->buf_len++] = 0x00; // this page
 395                         outbuf[r->buf_len++] = 0x00;
 396                         outbuf[r->buf_len++] = 3;    // number of pages
 397                         outbuf[r->buf_len++] = 0x00; // list of supported pages (this page)
 398                         outbuf[r->buf_len++] = 0x80; // unit serial number
 399                         outbuf[r->buf_len++] = 0x83; // device identification
 400                     }
 401                     break;
 402                 case 0x80:
 403                     {
 404                         /* Device serial number, optional */
 405                         if (len < 4) {
 406                             BADF("Error: EVPD[Serial number] Inquiry buffer "
 407                                  "size %d too small, %d needed\n", len, 4);
 408                             goto fail;
 409                         }
 410
 411                         DPRINTF("Inquiry EVPD[Serial number] buffer size %d\n", len);
 412
 413                         r->buf_len = 0;
 414
 415                         /* Supported page codes */
 416                         if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 417                             outbuf[r->buf_len++] = 5;
 418                         } else {
 419                             outbuf[r->buf_len++] = 0;
 420                         }
 421
 422                         outbuf[r->buf_len++] = 0x80; // this page
 423                         outbuf[r->buf_len++] = 0x00;
 424                         outbuf[r->buf_len++] = 0x01; // 1 byte data follow
 425
 426                         outbuf[r->buf_len++] = '0';  // 1 byte data follow
 427                     }
 428
 429                     break;
 430                 case 0x83:
 431                     {
 432                         /* Device identification page, mandatory */
 433                         int max_len = 255 - 8;
 434                         int id_len = strlen(bdrv_get_device_name(s->bdrv));
 435                         if (id_len > max_len)
 436                             id_len = max_len;
 437
 438                         DPRINTF("Inquiry EVPD[Device identification] "
 439                                 "buffer size %d\n", len);
 440                         r->buf_len = 0;
 441                         if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 442                             outbuf[r->buf_len++] = 5;
 443                         } else {
 444                             outbuf[r->buf_len++] = 0;
 445                         }
 446
 447                         outbuf[r->buf_len++] = 0x83; // this page
 448                         outbuf[r->buf_len++] = 0x00;
 449                         outbuf[r->buf_len++] = 3 + id_len;
 450
 451                         outbuf[r->buf_len++] = 0x2; // ASCII
 452                         outbuf[r->buf_len++] = 0;   // not officially assigned
 453                         outbuf[r->buf_len++] = 0;   // reserved
 454                         outbuf[r->buf_len++] = id_len; // length of data following
 455
 456                         memcpy(&outbuf[r->buf_len],
 457                                bdrv_get_device_name(s->bdrv), id_len);
 458                         r->buf_len += id_len;
 459                     }
 460                     break;
 461                 default:
 462                     BADF("Error: unsupported Inquiry (EVPD[%02X]) "
 463                          "buffer size %d\n", page_code, len);
 464                     goto fail;
 465             }
 466             /* done with EVPD */
 467             break;
 468         }
 469         else {
 470             /* Standard INQUIRY data */
 471             if (buf[2] != 0) {
 472                 BADF("Error: Inquiry (STANDARD) page or code "
 473                      "is non-zero [%02X]\n", buf[2]);
 474                 goto fail;
 475             }
 476
 477             /* PAGE CODE == 0 */
 478             if (len < 5) {
 479                 BADF("Error: Inquiry (STANDARD) buffer size %d "
 480                      "is less than 5\n", len);
 481                 goto fail;
 482             }
 483
 484             if (len < 36) {
 485                 BADF("Error: Inquiry (STANDARD) buffer size %d "
 486                      "is less than 36 (TODO: only 5 required)\n", len);
 487             }
 488         }
 489         memset(outbuf, 0, 36);
 490         if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 491             outbuf[0] = 5;
 492             outbuf[1] = 0x80;
 493             memcpy(&outbuf[16], "QEMU CD-ROM    ", 16);
 494         } else {
 495             outbuf[0] = 0;
 496             memcpy(&outbuf[16], "QEMU HARDDISK  ", 16);
 497         }
 498         memcpy(&outbuf[8], "QEMU   ", 8);
 499         memcpy(&outbuf[32], QEMU_VERSION, 4);
 500         /* Identify device as SCSI-3 rev 1.
 501            Some later commands are also implemented. */
 502         outbuf[2] = 3;
 503         outbuf[3] = 2; /* Format 2 */
 504         outbuf[4] = 31;
 505         /* Sync data transfer and TCQ.  */
 506         outbuf[7] = 0x10 | (s->tcq ? 0x02 : 0);
 507         r->buf_len = 36;
 508         break;
 509     case 0x16:
 510         DPRINTF("Reserve(6)\n");
 511         if (buf[1] & 1)
 512             goto fail;
 513         break;
 514     case 0x17:
 515         DPRINTF("Release(6)\n");
 516         if (buf[1] & 1)
 517             goto fail;
 518         break;
 519     case 0x1a:
 520     case 0x5a:
 521         {
 522             uint8_t *p;
 523             int page;
 524
 525             page = buf[2] & 0x3f;
 526             DPRINTF("Mode Sense (page %d, len %d)\n", page, len);
 527             p = outbuf;
 528             memset(p, 0, 4);
 529             outbuf[1] = 0; /* Default media type.  */
 530             outbuf[3] = 0; /* Block descriptor length.  */
 531             if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 532                 outbuf[2] = 0x80; /* Readonly.  */
 533             }
 534             p += 4;
 535             if ((page == 8 || page == 0x3f)) {
 536                 /* Caching page.  */
 537                 memset(p,0,20);
 538                 p[0] = 8;
 539                 p[1] = 0x12;
 540                 p[2] = 4; /* WCE */
 541                 p += 20;
 542             }
 543             if ((page == 0x3f || page == 0x2a)
 544                     && (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM)) {
 545                 /* CD Capabilities and Mechanical Status page. */
 546                 p[0] = 0x2a;
 547                 p[1] = 0x14;
 548                 p[2] = 3; // CD-R & CD-RW read
 549                 p[3] = 0; // Writing not supported
 550                 p[4] = 0x7f; /* Audio, composite, digital out,
 551                                          mode 2 form 1&2, multi session */
 552                 p[5] = 0xff; /* CD DA, DA accurate, RW supported,
 553                                          RW corrected, C2 errors, ISRC,
 554                                          UPC, Bar code */
 555                 p[6] = 0x2d | (bdrv_is_locked(s->bdrv)? 2 : 0);
 556                 /* Locking supported, jumper present, eject, tray */
 557                 p[7] = 0; /* no volume & mute control, no
 558                                       changer */
 559                 p[8] = (50 * 176) >> 8; // 50x read speed
 560                 p[9] = (50 * 176) & 0xff;
 561                 p[10] = 0 >> 8; // No volume
 562                 p[11] = 0 & 0xff;
 563                 p[12] = 2048 >> 8; // 2M buffer
 564                 p[13] = 2048 & 0xff;
 565                 p[14] = (16 * 176) >> 8; // 16x read speed current
 566                 p[15] = (16 * 176) & 0xff;
 567                 p[18] = (16 * 176) >> 8; // 16x write speed
 568                 p[19] = (16 * 176) & 0xff;
 569                 p[20] = (16 * 176) >> 8; // 16x write speed current
 570                 p[21] = (16 * 176) & 0xff;
 571                 p += 22;
 572             }
 573             r->buf_len = p - outbuf;
 574             outbuf[0] = r->buf_len - 4;
 575             if (r->buf_len > len)
 576                 r->buf_len = len;
 577         }
 578         break;
 579     case 0x1b:
 580         DPRINTF("Start Stop Unit\n");
 581         break;
 582     case 0x1e:
 583         DPRINTF("Prevent Allow Medium Removal (prevent = %d)\n", buf[4] & 3);
 584         bdrv_set_locked(s->bdrv, buf[4] & 1);
 585         break;
 586     case 0x25:
 587         DPRINTF("Read Capacity\n");
 588         /* The normal LEN field for this command is zero.  */
 589         memset(outbuf, 0, 8);
 590         bdrv_get_geometry(s->bdrv, &nb_sectors);
 591         /* Returned value is the address of the last sector.  */
 592         if (nb_sectors) {
 593             nb_sectors--;
 594             outbuf[0] = (nb_sectors >> 24) & 0xff;
 595             outbuf[1] = (nb_sectors >> 16) & 0xff;
 596             outbuf[2] = (nb_sectors >> 8) & 0xff;
 597             outbuf[3] = nb_sectors & 0xff;
 598             outbuf[4] = 0;
 599             outbuf[5] = 0;
 600             outbuf[6] = s->cluster_size * 2;
 601             outbuf[7] = 0;
 602             r->buf_len = 8;
 603         } else {
 604             scsi_command_complete(r, SENSE_NOT_READY);
 605             return 0;
 606         }
 607         break;
 608     case 0x08:
 609     case 0x28:
 610         DPRINTF("Read (sector %d, count %d)\n", lba, len);
 611         r->sector = lba * s->cluster_size;
 612         r->sector_count = len * s->cluster_size;
 613         break;
 614     case 0x0a:
 615     case 0x2a:
 616         DPRINTF("Write (sector %d, count %d)\n", lba, len);
 617         r->sector = lba * s->cluster_size;
 618         r->sector_count = len * s->cluster_size;
 619         is_write = 1;
 620         break;
 621     case 0x35:
 622         DPRINTF("Synchronise cache (sector %d, count %d)\n", lba, len);
 623         bdrv_flush(s->bdrv);
 624         break;
 625     case 0x43:
 626         {
 627             int start_track, format, msf, toclen;
 628
 629             msf = buf[1] & 2;
 630             format = buf[2] & 0xf;
 631             start_track = buf[6];
 632             bdrv_get_geometry(s->bdrv, &nb_sectors);
 633             DPRINTF("Read TOC (track %d format %d msf %d)\n", start_track, format, msf >> 1);
 634             switch(format) {
 635             case 0:
 636                 toclen = cdrom_read_toc(nb_sectors, outbuf, msf, start_track);
 637                 break;
 638             case 1:
 639                 /* multi session : only a single session defined */
 640                 toclen = 12;
 641                 memset(outbuf, 0, 12);
 642                 outbuf[1] = 0x0a;
 643                 outbuf[2] = 0x01;
 644                 outbuf[3] = 0x01;
 645                 break;
 646             case 2:
 647                 toclen = cdrom_read_toc_raw(nb_sectors, outbuf, msf, start_track);
 648                 break;
 649             default:
 650                 goto error_cmd;
 651             }
 652             if (toclen > 0) {
 653                 if (len > toclen)
 654                   len = toclen;
 655                 r->buf_len = len;
 656                 break;
 657             }
 658         error_cmd:
 659             DPRINTF("Read TOC error\n");
 660             goto fail;
 661         }
 662     case 0x46:
 663         DPRINTF("Get Configuration (rt %d, maxlen %d)\n", buf[1] & 3, len);
 664         memset(outbuf, 0, 8);
 665         /* ??? This shoud probably return much more information.  For now
 666            just return the basic header indicating the CD-ROM profile.  */
 667         outbuf[7] = 8; // CD-ROM
 668         r->buf_len = 8;
 669         break;
 670     case 0x56:
 671         DPRINTF("Reserve(10)\n");
 672         if (buf[1] & 3)
 673             goto fail;
 674         break;
 675     case 0x57:
 676         DPRINTF("Release(10)\n");
 677         if (buf[1] & 3)
 678             goto fail;
 679         break;
 680     case 0xa0:
 681         DPRINTF("Report LUNs (len %d)\n", len);
 682         if (len < 16)
 683             goto fail;
 684         memset(outbuf, 0, 16);
 685         outbuf[3] = 8;
 686         r->buf_len = 16;
 687         break;
 688     default:
 689         DPRINTF("Unknown SCSI command (%2.2x)\n", buf[0]);
 690     fail:
 691         scsi_command_complete(r, SENSE_ILLEGAL_REQUEST);
 692         return 0;
 693     }
 694     if (r->sector_count == 0 && r->buf_len == 0) {
 695         scsi_command_complete(r, SENSE_NO_SENSE);
 696     }
 697     len = r->sector_count * 512 + r->buf_len;
 698     if (is_write) {
 699         return -len;
 700     } else {
 701         if (!r->sector_count)
 702             r->sector_count = -1;
 703         return len;
 704     }
 705 }
 706
 707 static void scsi_destroy(SCSIDevice *d)
 708 {
 709     qemu_free(d->state);
 710     qemu_free(d);
 711 }
 712
 713 SCSIDevice *scsi_disk_init(BlockDriverState *bdrv, int tcq,
 714                            scsi_completionfn completion, void *opaque)
 715 {
 716     SCSIDevice *d;
 717     SCSIDeviceState *s;
 718
 719     s = (SCSIDeviceState *)qemu_mallocz(sizeof(SCSIDeviceState));
 720     s->bdrv = bdrv;
 721     s->tcq = tcq;
 722     s->completion = completion;
 723     s->opaque = opaque;
 724     if (bdrv_get_type_hint(s->bdrv) == BDRV_TYPE_CDROM) {
 725         s->cluster_size = 4;
 726     } else {
 727         s->cluster_size = 1;
 728     }
 729
 730     d = (SCSIDevice *)qemu_mallocz(sizeof(SCSIDevice));
 731     d->state = s;
 732     d->destroy = scsi_destroy;
 733     d->send_command = scsi_send_command;
 734     d->read_data = scsi_read_data;
 735     d->write_data = scsi_write_data;
 736     d->cancel_io = scsi_cancel_io;
 737     d->get_buf = scsi_get_buf;
 738
 739     return d;
 740 }