hw/ide/core.c

   1 /*
   2  * QEMU IDE disk and CD/DVD-ROM Emulator
   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 #include <hw/hw.h>
  26 #include <hw/i386/pc.h>
  27 #include <hw/pci/pci.h>
  28 #include <hw/isa/isa.h>
  29 #include "qemu/error-report.h"
  30 #include "qemu/timer.h"
  31 #include "sysemu/sysemu.h"
  32 #include "sysemu/dma.h"
  33 #include "hw/block/block.h"
  34 #include "sysemu/blockdev.h"
  35
  36 #include <hw/ide/internal.h>
  37
  38 /* These values were based on a Seagate ST3500418AS but have been modified
  39    to make more sense in QEMU */
  40 static const int smart_attributes[][12] = {
  41     /* id,  flags, hflags, val, wrst, raw (6 bytes), threshold */
  42     /* raw read error rate*/
  43     { 0x01, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06},
  44     /* spin up */
  45     { 0x03, 0x03, 0x00, 0x64, 0x64, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  46     /* start stop count */
  47     { 0x04, 0x02, 0x00, 0x64, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14},
  48     /* remapped sectors */
  49     { 0x05, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24},
  50     /* power on hours */
  51     { 0x09, 0x03, 0x00, 0x64, 0x64, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  52     /* power cycle count */
  53     { 0x0c, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
  54     /* airflow-temperature-celsius */
  55     { 190,  0x03, 0x00, 0x45, 0x45, 0x1f, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x32},
  56 };
  57
  58 static int ide_handle_rw_error(IDEState *s, int error, int op);
  59 static void ide_dummy_transfer_stop(IDEState *s);
  60
  61 static void padstr(char *str, const char *src, int len)
  62 {
  63     int i, v;
  64     for(i = 0; i < len; i++) {
  65         if (*src)
  66             v = *src++;
  67         else
  68             v = ' ';
  69         str[i^1] = v;
  70     }
  71 }
  72
  73 static void put_le16(uint16_t *p, unsigned int v)
  74 {
  75     *p = cpu_to_le16(v);
  76 }
  77
  78 static void ide_identify(IDEState *s)
  79 {
  80     uint16_t *p;
  81     unsigned int oldsize;
  82     IDEDevice *dev = s->unit ? s->bus->slave : s->bus->master;
  83
  84     if (s->identify_set) {
  85         memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
  86         return;
  87     }
  88
  89     memset(s->io_buffer, 0, 512);
  90     p = (uint16_t *)s->io_buffer;
  91     put_le16(p + 0, 0x0040);
  92     put_le16(p + 1, s->cylinders);
  93     put_le16(p + 3, s->heads);
  94     put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
  95     put_le16(p + 5, 512); /* XXX: retired, remove ? */
  96     put_le16(p + 6, s->sectors);
  97     padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
  98     put_le16(p + 20, 3); /* XXX: retired, remove ? */
  99     put_le16(p + 21, 512); /* cache size in sectors */
 100     put_le16(p + 22, 4); /* ecc bytes */
 101     padstr((char *)(p + 23), s->version, 8); /* firmware version */
 102     padstr((char *)(p + 27), s->drive_model_str, 40); /* model */
 103 #if MAX_MULT_SECTORS > 1
 104     put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
 105 #endif
 106     put_le16(p + 48, 1); /* dword I/O */
 107     put_le16(p + 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
 108     put_le16(p + 51, 0x200); /* PIO transfer cycle */
 109     put_le16(p + 52, 0x200); /* DMA transfer cycle */
 110     put_le16(p + 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
 111     put_le16(p + 54, s->cylinders);
 112     put_le16(p + 55, s->heads);
 113     put_le16(p + 56, s->sectors);
 114     oldsize = s->cylinders * s->heads * s->sectors;
 115     put_le16(p + 57, oldsize);
 116     put_le16(p + 58, oldsize >> 16);
 117     if (s->mult_sectors)
 118         put_le16(p + 59, 0x100 | s->mult_sectors);
 119     put_le16(p + 60, s->nb_sectors);
 120     put_le16(p + 61, s->nb_sectors >> 16);
 121     put_le16(p + 62, 0x07); /* single word dma0-2 supported */
 122     put_le16(p + 63, 0x07); /* mdma0-2 supported */
 123     put_le16(p + 64, 0x03); /* pio3-4 supported */
 124     put_le16(p + 65, 120);
 125     put_le16(p + 66, 120);
 126     put_le16(p + 67, 120);
 127     put_le16(p + 68, 120);
 128     if (dev && dev->conf.discard_granularity) {
 129         put_le16(p + 69, (1 << 14)); /* determinate TRIM behavior */
 130     }
 131
 132     if (s->ncq_queues) {
 133         put_le16(p + 75, s->ncq_queues - 1);
 134         /* NCQ supported */
 135         put_le16(p + 76, (1 << 8));
 136     }
 137
 138     put_le16(p + 80, 0xf0); /* ata3 -> ata6 supported */
 139     put_le16(p + 81, 0x16); /* conforms to ata5 */
 140     /* 14=NOP supported, 5=WCACHE supported, 0=SMART supported */
 141     put_le16(p + 82, (1 << 14) | (1 << 5) | 1);
 142     /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
 143     put_le16(p + 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
 144     /* 14=set to 1, 8=has WWN, 1=SMART self test, 0=SMART error logging */
 145     if (s->wwn) {
 146         put_le16(p + 84, (1 << 14) | (1 << 8) | 0);
 147     } else {
 148         put_le16(p + 84, (1 << 14) | 0);
 149     }
 150     /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
 151     if (bdrv_enable_write_cache(s->bs))
 152          put_le16(p + 85, (1 << 14) | (1 << 5) | 1);
 153     else
 154          put_le16(p + 85, (1 << 14) | 1);
 155     /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
 156     put_le16(p + 86, (1 << 13) | (1 <<12) | (1 << 10));
 157     /* 14=set to 1, 8=has WWN, 1=SMART self test, 0=SMART error logging */
 158     if (s->wwn) {
 159         put_le16(p + 87, (1 << 14) | (1 << 8) | 0);
 160     } else {
 161         put_le16(p + 87, (1 << 14) | 0);
 162     }
 163     put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
 164     put_le16(p + 93, 1 | (1 << 14) | 0x2000);
 165     put_le16(p + 100, s->nb_sectors);
 166     put_le16(p + 101, s->nb_sectors >> 16);
 167     put_le16(p + 102, s->nb_sectors >> 32);
 168     put_le16(p + 103, s->nb_sectors >> 48);
 169
 170     if (dev && dev->conf.physical_block_size)
 171         put_le16(p + 106, 0x6000 | get_physical_block_exp(&dev->conf));
 172     if (s->wwn) {
 173         /* LE 16-bit words 111-108 contain 64-bit World Wide Name */
 174         put_le16(p + 108, s->wwn >> 48);
 175         put_le16(p + 109, s->wwn >> 32);
 176         put_le16(p + 110, s->wwn >> 16);
 177         put_le16(p + 111, s->wwn);
 178     }
 179     if (dev && dev->conf.discard_granularity) {
 180         put_le16(p + 169, 1); /* TRIM support */
 181     }
 182
 183     memcpy(s->identify_data, p, sizeof(s->identify_data));
 184     s->identify_set = 1;
 185 }
 186
 187 static void ide_atapi_identify(IDEState *s)
 188 {
 189     uint16_t *p;
 190
 191     if (s->identify_set) {
 192         memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
 193         return;
 194     }
 195
 196     memset(s->io_buffer, 0, 512);
 197     p = (uint16_t *)s->io_buffer;
 198     /* Removable CDROM, 50us response, 12 byte packets */
 199     put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
 200     padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
 201     put_le16(p + 20, 3); /* buffer type */
 202     put_le16(p + 21, 512); /* cache size in sectors */
 203     put_le16(p + 22, 4); /* ecc bytes */
 204     padstr((char *)(p + 23), s->version, 8); /* firmware version */
 205     padstr((char *)(p + 27), s->drive_model_str, 40); /* model */
 206     put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
 207 #ifdef USE_DMA_CDROM
 208     put_le16(p + 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
 209     put_le16(p + 53, 7); /* words 64-70, 54-58, 88 valid */
 210     put_le16(p + 62, 7);  /* single word dma0-2 supported */
 211     put_le16(p + 63, 7);  /* mdma0-2 supported */
 212 #else
 213     put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
 214     put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
 215     put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
 216 #endif
 217     put_le16(p + 64, 3); /* pio3-4 supported */
 218     put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
 219     put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
 220     put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
 221     put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
 222
 223     put_le16(p + 71, 30); /* in ns */
 224     put_le16(p + 72, 30); /* in ns */
 225
 226     if (s->ncq_queues) {
 227         put_le16(p + 75, s->ncq_queues - 1);
 228         /* NCQ supported */
 229         put_le16(p + 76, (1 << 8));
 230     }
 231
 232     put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
 233 #ifdef USE_DMA_CDROM
 234     put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
 235 #endif
 236     memcpy(s->identify_data, p, sizeof(s->identify_data));
 237     s->identify_set = 1;
 238 }
 239
 240 static void ide_cfata_identify(IDEState *s)
 241 {
 242     uint16_t *p;
 243     uint32_t cur_sec;
 244
 245     p = (uint16_t *) s->identify_data;
 246     if (s->identify_set)
 247         goto fill_buffer;
 248
 249     memset(p, 0, sizeof(s->identify_data));
 250
 251     cur_sec = s->cylinders * s->heads * s->sectors;
 252
 253     put_le16(p + 0, 0x848a);                    /* CF Storage Card signature */
 254     put_le16(p + 1, s->cylinders);              /* Default cylinders */
 255     put_le16(p + 3, s->heads);                  /* Default heads */
 256     put_le16(p + 6, s->sectors);                /* Default sectors per track */
 257     put_le16(p + 7, s->nb_sectors >> 16);       /* Sectors per card */
 258     put_le16(p + 8, s->nb_sectors);             /* Sectors per card */
 259     padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
 260     put_le16(p + 22, 0x0004);                   /* ECC bytes */
 261     padstr((char *) (p + 23), s->version, 8);   /* Firmware Revision */
 262     padstr((char *) (p + 27), s->drive_model_str, 40);/* Model number */
 263 #if MAX_MULT_SECTORS > 1
 264     put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
 265 #else
 266     put_le16(p + 47, 0x0000);
 267 #endif
 268     put_le16(p + 49, 0x0f00);                   /* Capabilities */
 269     put_le16(p + 51, 0x0002);                   /* PIO cycle timing mode */
 270     put_le16(p + 52, 0x0001);                   /* DMA cycle timing mode */
 271     put_le16(p + 53, 0x0003);                   /* Translation params valid */
 272     put_le16(p + 54, s->cylinders);             /* Current cylinders */
 273     put_le16(p + 55, s->heads);                 /* Current heads */
 274     put_le16(p + 56, s->sectors);               /* Current sectors */
 275     put_le16(p + 57, cur_sec);                  /* Current capacity */
 276     put_le16(p + 58, cur_sec >> 16);            /* Current capacity */
 277     if (s->mult_sectors)                        /* Multiple sector setting */
 278         put_le16(p + 59, 0x100 | s->mult_sectors);
 279     put_le16(p + 60, s->nb_sectors);            /* Total LBA sectors */
 280     put_le16(p + 61, s->nb_sectors >> 16);      /* Total LBA sectors */
 281     put_le16(p + 63, 0x0203);                   /* Multiword DMA capability */
 282     put_le16(p + 64, 0x0001);                   /* Flow Control PIO support */
 283     put_le16(p + 65, 0x0096);                   /* Min. Multiword DMA cycle */
 284     put_le16(p + 66, 0x0096);                   /* Rec. Multiword DMA cycle */
 285     put_le16(p + 68, 0x00b4);                   /* Min. PIO cycle time */
 286     put_le16(p + 82, 0x400c);                   /* Command Set supported */
 287     put_le16(p + 83, 0x7068);                   /* Command Set supported */
 288     put_le16(p + 84, 0x4000);                   /* Features supported */
 289     put_le16(p + 85, 0x000c);                   /* Command Set enabled */
 290     put_le16(p + 86, 0x7044);                   /* Command Set enabled */
 291     put_le16(p + 87, 0x4000);                   /* Features enabled */
 292     put_le16(p + 91, 0x4060);                   /* Current APM level */
 293     put_le16(p + 129, 0x0002);                  /* Current features option */
 294     put_le16(p + 130, 0x0005);                  /* Reassigned sectors */
 295     put_le16(p + 131, 0x0001);                  /* Initial power mode */
 296     put_le16(p + 132, 0x0000);                  /* User signature */
 297     put_le16(p + 160, 0x8100);                  /* Power requirement */
 298     put_le16(p + 161, 0x8001);                  /* CF command set */
 299
 300     s->identify_set = 1;
 301
 302 fill_buffer:
 303     memcpy(s->io_buffer, p, sizeof(s->identify_data));
 304 }
 305
 306 static void ide_set_signature(IDEState *s)
 307 {
 308     s->select &= 0xf0; /* clear head */
 309     /* put signature */
 310     s->nsector = 1;
 311     s->sector = 1;
 312     if (s->drive_kind == IDE_CD) {
 313         s->lcyl = 0x14;
 314         s->hcyl = 0xeb;
 315     } else if (s->bs) {
 316         s->lcyl = 0;
 317         s->hcyl = 0;
 318     } else {
 319         s->lcyl = 0xff;
 320         s->hcyl = 0xff;
 321     }
 322 }
 323
 324 typedef struct TrimAIOCB {
 325     BlockDriverAIOCB common;
 326     QEMUBH *bh;
 327     int ret;
 328     QEMUIOVector *qiov;
 329     BlockDriverAIOCB *aiocb;
 330     int i, j;
 331 } TrimAIOCB;
 332
 333 static void trim_aio_cancel(BlockDriverAIOCB *acb)
 334 {
 335     TrimAIOCB *iocb = container_of(acb, TrimAIOCB, common);
 336
 337     /* Exit the loop in case bdrv_aio_cancel calls ide_issue_trim_cb again.  */
 338     iocb->j = iocb->qiov->niov - 1;
 339     iocb->i = (iocb->qiov->iov[iocb->j].iov_len / 8) - 1;
 340
 341     /* Tell ide_issue_trim_cb not to trigger the completion, too.  */
 342     qemu_bh_delete(iocb->bh);
 343     iocb->bh = NULL;
 344
 345     if (iocb->aiocb) {
 346         bdrv_aio_cancel(iocb->aiocb);
 347     }
 348     qemu_aio_release(iocb);
 349 }
 350
 351 static const AIOCBInfo trim_aiocb_info = {
 352     .aiocb_size         = sizeof(TrimAIOCB),
 353     .cancel             = trim_aio_cancel,
 354 };
 355
 356 static void ide_trim_bh_cb(void *opaque)
 357 {
 358     TrimAIOCB *iocb = opaque;
 359
 360     iocb->common.cb(iocb->common.opaque, iocb->ret);
 361
 362     qemu_bh_delete(iocb->bh);
 363     iocb->bh = NULL;
 364     qemu_aio_release(iocb);
 365 }
 366
 367 static void ide_issue_trim_cb(void *opaque, int ret)
 368 {
 369     TrimAIOCB *iocb = opaque;
 370     if (ret >= 0) {
 371         while (iocb->j < iocb->qiov->niov) {
 372             int j = iocb->j;
 373             while (++iocb->i < iocb->qiov->iov[j].iov_len / 8) {
 374                 int i = iocb->i;
 375                 uint64_t *buffer = iocb->qiov->iov[j].iov_base;
 376
 377                 /* 6-byte LBA + 2-byte range per entry */
 378                 uint64_t entry = le64_to_cpu(buffer[i]);
 379                 uint64_t sector = entry & 0x0000ffffffffffffULL;
 380                 uint16_t count = entry >> 48;
 381
 382                 if (count == 0) {
 383                     continue;
 384                 }
 385
 386                 /* Got an entry! Submit and exit.  */
 387                 iocb->aiocb = bdrv_aio_discard(iocb->common.bs, sector, count,
 388                                                ide_issue_trim_cb, opaque);
 389                 return;
 390             }
 391
 392             iocb->j++;
 393             iocb->i = -1;
 394         }
 395     } else {
 396         iocb->ret = ret;
 397     }
 398
 399     iocb->aiocb = NULL;
 400     if (iocb->bh) {
 401         qemu_bh_schedule(iocb->bh);
 402     }
 403 }
 404
 405 BlockDriverAIOCB *ide_issue_trim(BlockDriverState *bs,
 406         int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
 407         BlockDriverCompletionFunc *cb, void *opaque)
 408 {
 409     TrimAIOCB *iocb;
 410
 411     iocb = qemu_aio_get(&trim_aiocb_info, bs, cb, opaque);
 412     iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb);
 413     iocb->ret = 0;
 414     iocb->qiov = qiov;
 415     iocb->i = -1;
 416     iocb->j = 0;
 417     ide_issue_trim_cb(iocb, 0);
 418     return &iocb->common;
 419 }
 420
 421 static inline void ide_abort_command(IDEState *s)
 422 {
 423     ide_transfer_stop(s);
 424     s->status = READY_STAT | ERR_STAT;
 425     s->error = ABRT_ERR;
 426 }
 427
 428 /* prepare data transfer and tell what to do after */
 429 void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
 430                         EndTransferFunc *end_transfer_func)
 431 {
 432     s->end_transfer_func = end_transfer_func;
 433     s->data_ptr = buf;
 434     s->data_end = buf + size;
 435     if (!(s->status & ERR_STAT)) {
 436         s->status |= DRQ_STAT;
 437     }
 438     if (s->bus->dma->ops->start_transfer) {
 439         s->bus->dma->ops->start_transfer(s->bus->dma);
 440     }
 441 }
 442
 443 void ide_transfer_stop(IDEState *s)
 444 {
 445     s->end_transfer_func = ide_transfer_stop;
 446     s->data_ptr = s->io_buffer;
 447     s->data_end = s->io_buffer;
 448     s->status &= ~DRQ_STAT;
 449 }
 450
 451 int64_t ide_get_sector(IDEState *s)
 452 {
 453     int64_t sector_num;
 454     if (s->select & 0x40) {
 455         /* lba */
 456         if (!s->lba48) {
 457             sector_num = ((s->select & 0x0f) << 24) | (s->hcyl << 16) |
 458                 (s->lcyl << 8) | s->sector;
 459         } else {
 460             sector_num = ((int64_t)s->hob_hcyl << 40) |
 461                 ((int64_t) s->hob_lcyl << 32) |
 462                 ((int64_t) s->hob_sector << 24) |
 463                 ((int64_t) s->hcyl << 16) |
 464                 ((int64_t) s->lcyl << 8) | s->sector;
 465         }
 466     } else {
 467         sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
 468             (s->select & 0x0f) * s->sectors + (s->sector - 1);
 469     }
 470     return sector_num;
 471 }
 472
 473 void ide_set_sector(IDEState *s, int64_t sector_num)
 474 {
 475     unsigned int cyl, r;
 476     if (s->select & 0x40) {
 477         if (!s->lba48) {
 478             s->select = (s->select & 0xf0) | (sector_num >> 24);
 479             s->hcyl = (sector_num >> 16);
 480             s->lcyl = (sector_num >> 8);
 481             s->sector = (sector_num);
 482         } else {
 483             s->sector = sector_num;
 484             s->lcyl = sector_num >> 8;
 485             s->hcyl = sector_num >> 16;
 486             s->hob_sector = sector_num >> 24;
 487             s->hob_lcyl = sector_num >> 32;
 488             s->hob_hcyl = sector_num >> 40;
 489         }
 490     } else {
 491         cyl = sector_num / (s->heads * s->sectors);
 492         r = sector_num % (s->heads * s->sectors);
 493         s->hcyl = cyl >> 8;
 494         s->lcyl = cyl;
 495         s->select = (s->select & 0xf0) | ((r / s->sectors) & 0x0f);
 496         s->sector = (r % s->sectors) + 1;
 497     }
 498 }
 499
 500 static void ide_rw_error(IDEState *s) {
 501     ide_abort_command(s);
 502     ide_set_irq(s->bus);
 503 }
 504
 505 static bool ide_sect_range_ok(IDEState *s,
 506                               uint64_t sector, uint64_t nb_sectors)
 507 {
 508     uint64_t total_sectors;
 509
 510     bdrv_get_geometry(s->bs, &total_sectors);
 511     if (sector > total_sectors || nb_sectors > total_sectors - sector) {
 512         return false;
 513     }
 514     return true;
 515 }
 516
 517 static void ide_sector_read_cb(void *opaque, int ret)
 518 {
 519     IDEState *s = opaque;
 520     int n;
 521
 522     s->pio_aiocb = NULL;
 523     s->status &= ~BUSY_STAT;
 524
 525     bdrv_acct_done(s->bs, &s->acct);
 526     if (ret != 0) {
 527         if (ide_handle_rw_error(s, -ret, IDE_RETRY_PIO |
 528                                 IDE_RETRY_READ)) {
 529             return;
 530         }
 531     }
 532
 533     n = s->nsector;
 534     if (n > s->req_nb_sectors) {
 535         n = s->req_nb_sectors;
 536     }
 537
 538     /* Allow the guest to read the io_buffer */
 539     ide_transfer_start(s, s->io_buffer, n * BDRV_SECTOR_SIZE, ide_sector_read);
 540
 541     ide_set_irq(s->bus);
 542
 543     ide_set_sector(s, ide_get_sector(s) + n);
 544     s->nsector -= n;
 545 }
 546
 547 void ide_sector_read(IDEState *s)
 548 {
 549     int64_t sector_num;
 550     int n;
 551
 552     s->status = READY_STAT | SEEK_STAT;
 553     s->error = 0; /* not needed by IDE spec, but needed by Windows */
 554     sector_num = ide_get_sector(s);
 555     n = s->nsector;
 556
 557     if (n == 0) {
 558         ide_transfer_stop(s);
 559         return;
 560     }
 561
 562     s->status |= BUSY_STAT;
 563
 564     if (n > s->req_nb_sectors) {
 565         n = s->req_nb_sectors;
 566     }
 567
 568 #if defined(DEBUG_IDE)
 569     printf("sector=%" PRId64 "\n", sector_num);
 570 #endif
 571
 572     if (!ide_sect_range_ok(s, sector_num, n)) {
 573         ide_rw_error(s);
 574         return;
 575     }
 576
 577     s->iov.iov_base = s->io_buffer;
 578     s->iov.iov_len  = n * BDRV_SECTOR_SIZE;
 579     qemu_iovec_init_external(&s->qiov, &s->iov, 1);
 580
 581     bdrv_acct_start(s->bs, &s->acct, n * BDRV_SECTOR_SIZE, BDRV_ACCT_READ);
 582     s->pio_aiocb = bdrv_aio_readv(s->bs, sector_num, &s->qiov, n,
 583                                   ide_sector_read_cb, s);
 584 }
 585
 586 static void dma_buf_commit(IDEState *s)
 587 {
 588     qemu_sglist_destroy(&s->sg);
 589 }
 590
 591 static void ide_async_cmd_done(IDEState *s)
 592 {
 593     if (s->bus->dma->ops->async_cmd_done) {
 594         s->bus->dma->ops->async_cmd_done(s->bus->dma);
 595     }
 596 }
 597
 598 void ide_set_inactive(IDEState *s, bool more)
 599 {
 600     s->bus->dma->aiocb = NULL;
 601     if (s->bus->dma->ops->set_inactive) {
 602         s->bus->dma->ops->set_inactive(s->bus->dma, more);
 603     }
 604     ide_async_cmd_done(s);
 605 }
 606
 607 void ide_dma_error(IDEState *s)
 608 {
 609     ide_abort_command(s);
 610     ide_set_inactive(s, false);
 611     ide_set_irq(s->bus);
 612 }
 613
 614 static int ide_handle_rw_error(IDEState *s, int error, int op)
 615 {
 616     bool is_read = (op & IDE_RETRY_READ) != 0;
 617     BlockErrorAction action = bdrv_get_error_action(s->bs, is_read, error);
 618
 619     if (action == BLOCK_ERROR_ACTION_STOP) {
 620         s->bus->dma->ops->set_unit(s->bus->dma, s->unit);
 621         s->bus->error_status = op;
 622     } else if (action == BLOCK_ERROR_ACTION_REPORT) {
 623         if (op & IDE_RETRY_DMA) {
 624             dma_buf_commit(s);
 625             ide_dma_error(s);
 626         } else {
 627             ide_rw_error(s);
 628         }
 629     }
 630     bdrv_error_action(s->bs, action, is_read, error);
 631     return action != BLOCK_ERROR_ACTION_IGNORE;
 632 }
 633
 634 void ide_dma_cb(void *opaque, int ret)
 635 {
 636     IDEState *s = opaque;
 637     int n;
 638     int64_t sector_num;
 639     bool stay_active = false;
 640
 641     if (ret < 0) {
 642         int op = IDE_RETRY_DMA;
 643
 644         if (s->dma_cmd == IDE_DMA_READ)
 645             op |= IDE_RETRY_READ;
 646         else if (s->dma_cmd == IDE_DMA_TRIM)
 647             op |= IDE_RETRY_TRIM;
 648
 649         if (ide_handle_rw_error(s, -ret, op)) {
 650             return;
 651         }
 652     }
 653
 654     n = s->io_buffer_size >> 9;
 655     if (n > s->nsector) {
 656         /* The PRDs were longer than needed for this request. Shorten them so
 657          * we don't get a negative remainder. The Active bit must remain set
 658          * after the request completes. */
 659         n = s->nsector;
 660         stay_active = true;
 661     }
 662
 663     sector_num = ide_get_sector(s);
 664     if (n > 0) {
 665         dma_buf_commit(s);
 666         sector_num += n;
 667         ide_set_sector(s, sector_num);
 668         s->nsector -= n;
 669     }
 670
 671     /* end of transfer ? */
 672     if (s->nsector == 0) {
 673         s->status = READY_STAT | SEEK_STAT;
 674         ide_set_irq(s->bus);
 675         goto eot;
 676     }
 677
 678     /* launch next transfer */
 679     n = s->nsector;
 680     s->io_buffer_index = 0;
 681     s->io_buffer_size = n * 512;
 682     if (s->bus->dma->ops->prepare_buf(s->bus->dma, ide_cmd_is_read(s)) == 0) {
 683         /* The PRDs were too short. Reset the Active bit, but don't raise an
 684          * interrupt. */
 685         s->status = READY_STAT | SEEK_STAT;
 686         goto eot;
 687     }
 688
 689 #ifdef DEBUG_AIO
 690     printf("ide_dma_cb: sector_num=%" PRId64 " n=%d, cmd_cmd=%d\n",
 691            sector_num, n, s->dma_cmd);
 692 #endif
 693
 694     if (!ide_sect_range_ok(s, sector_num, n)) {
 695         dma_buf_commit(s);
 696         ide_dma_error(s);
 697         return;
 698     }
 699
 700     switch (s->dma_cmd) {
 701     case IDE_DMA_READ:
 702         s->bus->dma->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num,
 703                                            ide_dma_cb, s);
 704         break;
 705     case IDE_DMA_WRITE:
 706         s->bus->dma->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num,
 707                                             ide_dma_cb, s);
 708         break;
 709     case IDE_DMA_TRIM:
 710         s->bus->dma->aiocb = dma_bdrv_io(s->bs, &s->sg, sector_num,
 711                                          ide_issue_trim, ide_dma_cb, s,
 712                                          DMA_DIRECTION_TO_DEVICE);
 713         break;
 714     }
 715     return;
 716
 717 eot:
 718     if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) {
 719         bdrv_acct_done(s->bs, &s->acct);
 720     }
 721     ide_set_inactive(s, stay_active);
 722 }
 723
 724 static void ide_sector_start_dma(IDEState *s, enum ide_dma_cmd dma_cmd)
 725 {
 726     s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
 727     s->io_buffer_index = 0;
 728     s->io_buffer_size = 0;
 729     s->dma_cmd = dma_cmd;
 730
 731     switch (dma_cmd) {
 732     case IDE_DMA_READ:
 733         bdrv_acct_start(s->bs, &s->acct, s->nsector * BDRV_SECTOR_SIZE,
 734                         BDRV_ACCT_READ);
 735         break;
 736     case IDE_DMA_WRITE:
 737         bdrv_acct_start(s->bs, &s->acct, s->nsector * BDRV_SECTOR_SIZE,
 738                         BDRV_ACCT_WRITE);
 739         break;
 740     default:
 741         break;
 742     }
 743
 744     ide_start_dma(s, ide_dma_cb);
 745 }
 746
 747 void ide_start_dma(IDEState *s, BlockDriverCompletionFunc *cb)
 748 {
 749     if (s->bus->dma->ops->start_dma) {
 750         s->bus->dma->ops->start_dma(s->bus->dma, s, cb);
 751     }
 752 }
 753
 754 static void ide_sector_write_timer_cb(void *opaque)
 755 {
 756     IDEState *s = opaque;
 757     ide_set_irq(s->bus);
 758 }
 759
 760 static void ide_sector_write_cb(void *opaque, int ret)
 761 {
 762     IDEState *s = opaque;
 763     int n;
 764
 765     bdrv_acct_done(s->bs, &s->acct);
 766
 767     s->pio_aiocb = NULL;
 768     s->status &= ~BUSY_STAT;
 769
 770     if (ret != 0) {
 771         if (ide_handle_rw_error(s, -ret, IDE_RETRY_PIO)) {
 772             return;
 773         }
 774     }
 775
 776     n = s->nsector;
 777     if (n > s->req_nb_sectors) {
 778         n = s->req_nb_sectors;
 779     }
 780     s->nsector -= n;
 781     if (s->nsector == 0) {
 782         /* no more sectors to write */
 783         ide_transfer_stop(s);
 784     } else {
 785         int n1 = s->nsector;
 786         if (n1 > s->req_nb_sectors) {
 787             n1 = s->req_nb_sectors;
 788         }
 789         ide_transfer_start(s, s->io_buffer, n1 * BDRV_SECTOR_SIZE,
 790                            ide_sector_write);
 791     }
 792     ide_set_sector(s, ide_get_sector(s) + n);
 793
 794     if (win2k_install_hack && ((++s->irq_count % 16) == 0)) {
 795         /* It seems there is a bug in the Windows 2000 installer HDD
 796            IDE driver which fills the disk with empty logs when the
 797            IDE write IRQ comes too early. This hack tries to correct
 798            that at the expense of slower write performances. Use this
 799            option _only_ to install Windows 2000. You must disable it
 800            for normal use. */
 801         timer_mod(s->sector_write_timer,
 802                        qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + (get_ticks_per_sec() / 1000));
 803     } else {
 804         ide_set_irq(s->bus);
 805     }
 806 }
 807
 808 void ide_sector_write(IDEState *s)
 809 {
 810     int64_t sector_num;
 811     int n;
 812
 813     s->status = READY_STAT | SEEK_STAT | BUSY_STAT;
 814     sector_num = ide_get_sector(s);
 815 #if defined(DEBUG_IDE)
 816     printf("sector=%" PRId64 "\n", sector_num);
 817 #endif
 818     n = s->nsector;
 819     if (n > s->req_nb_sectors) {
 820         n = s->req_nb_sectors;
 821     }
 822
 823     if (!ide_sect_range_ok(s, sector_num, n)) {
 824         ide_rw_error(s);
 825         return;
 826     }
 827
 828     s->iov.iov_base = s->io_buffer;
 829     s->iov.iov_len  = n * BDRV_SECTOR_SIZE;
 830     qemu_iovec_init_external(&s->qiov, &s->iov, 1);
 831
 832     bdrv_acct_start(s->bs, &s->acct, n * BDRV_SECTOR_SIZE, BDRV_ACCT_READ);
 833     s->pio_aiocb = bdrv_aio_writev(s->bs, sector_num, &s->qiov, n,
 834                                    ide_sector_write_cb, s);
 835 }
 836
 837 static void ide_flush_cb(void *opaque, int ret)
 838 {
 839     IDEState *s = opaque;
 840
 841     s->pio_aiocb = NULL;
 842
 843     if (ret < 0) {
 844         /* XXX: What sector number to set here? */
 845         if (ide_handle_rw_error(s, -ret, IDE_RETRY_FLUSH)) {
 846             return;
 847         }
 848     }
 849
 850     bdrv_acct_done(s->bs, &s->acct);
 851     s->status = READY_STAT | SEEK_STAT;
 852     ide_async_cmd_done(s);
 853     ide_set_irq(s->bus);
 854 }
 855
 856 void ide_flush_cache(IDEState *s)
 857 {
 858     if (s->bs == NULL) {
 859         ide_flush_cb(s, 0);
 860         return;
 861     }
 862
 863     s->status |= BUSY_STAT;
 864     bdrv_acct_start(s->bs, &s->acct, 0, BDRV_ACCT_FLUSH);
 865     s->pio_aiocb = bdrv_aio_flush(s->bs, ide_flush_cb, s);
 866 }
 867
 868 static void ide_cfata_metadata_inquiry(IDEState *s)
 869 {
 870     uint16_t *p;
 871     uint32_t spd;
 872
 873     p = (uint16_t *) s->io_buffer;
 874     memset(p, 0, 0x200);
 875     spd = ((s->mdata_size - 1) >> 9) + 1;
 876
 877     put_le16(p + 0, 0x0001);                    /* Data format revision */
 878     put_le16(p + 1, 0x0000);                    /* Media property: silicon */
 879     put_le16(p + 2, s->media_changed);          /* Media status */
 880     put_le16(p + 3, s->mdata_size & 0xffff);    /* Capacity in bytes (low) */
 881     put_le16(p + 4, s->mdata_size >> 16);       /* Capacity in bytes (high) */
 882     put_le16(p + 5, spd & 0xffff);              /* Sectors per device (low) */
 883     put_le16(p + 6, spd >> 16);                 /* Sectors per device (high) */
 884 }
 885
 886 static void ide_cfata_metadata_read(IDEState *s)
 887 {
 888     uint16_t *p;
 889
 890     if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
 891         s->status = ERR_STAT;
 892         s->error = ABRT_ERR;
 893         return;
 894     }
 895
 896     p = (uint16_t *) s->io_buffer;
 897     memset(p, 0, 0x200);
 898
 899     put_le16(p + 0, s->media_changed);          /* Media status */
 900     memcpy(p + 1, s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
 901                     MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
 902                                     s->nsector << 9), 0x200 - 2));
 903 }
 904
 905 static void ide_cfata_metadata_write(IDEState *s)
 906 {
 907     if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
 908         s->status = ERR_STAT;
 909         s->error = ABRT_ERR;
 910         return;
 911     }
 912
 913     s->media_changed = 0;
 914
 915     memcpy(s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
 916                     s->io_buffer + 2,
 917                     MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
 918                                     s->nsector << 9), 0x200 - 2));
 919 }
 920
 921 /* called when the inserted state of the media has changed */
 922 static void ide_cd_change_cb(void *opaque, bool load)
 923 {
 924     IDEState *s = opaque;
 925     uint64_t nb_sectors;
 926
 927     s->tray_open = !load;
 928     bdrv_get_geometry(s->bs, &nb_sectors);
 929     s->nb_sectors = nb_sectors;
 930
 931     /*
 932      * First indicate to the guest that a CD has been removed.  That's
 933      * done on the next command the guest sends us.
 934      *
 935      * Then we set UNIT_ATTENTION, by which the guest will
 936      * detect a new CD in the drive.  See ide_atapi_cmd() for details.
 937      */
 938     s->cdrom_changed = 1;
 939     s->events.new_media = true;
 940     s->events.eject_request = false;
 941     ide_set_irq(s->bus);
 942 }
 943
 944 static void ide_cd_eject_request_cb(void *opaque, bool force)
 945 {
 946     IDEState *s = opaque;
 947
 948     s->events.eject_request = true;
 949     if (force) {
 950         s->tray_locked = false;
 951     }
 952     ide_set_irq(s->bus);
 953 }
 954
 955 static void ide_cmd_lba48_transform(IDEState *s, int lba48)
 956 {
 957     s->lba48 = lba48;
 958
 959     /* handle the 'magic' 0 nsector count conversion here. to avoid
 960      * fiddling with the rest of the read logic, we just store the
 961      * full sector count in ->nsector and ignore ->hob_nsector from now
 962      */
 963     if (!s->lba48) {
 964         if (!s->nsector)
 965             s->nsector = 256;
 966     } else {
 967         if (!s->nsector && !s->hob_nsector)
 968             s->nsector = 65536;
 969         else {
 970             int lo = s->nsector;
 971             int hi = s->hob_nsector;
 972
 973             s->nsector = (hi << 8) | lo;
 974         }
 975     }
 976 }
 977
 978 static void ide_clear_hob(IDEBus *bus)
 979 {
 980     /* any write clears HOB high bit of device control register */
 981     bus->ifs[0].select &= ~(1 << 7);
 982     bus->ifs[1].select &= ~(1 << 7);
 983 }
 984
 985 void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 986 {
 987     IDEBus *bus = opaque;
 988
 989 #ifdef DEBUG_IDE
 990     printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
 991 #endif
 992
 993     addr &= 7;
 994
 995     /* ignore writes to command block while busy with previous command */
 996     if (addr != 7 && (idebus_active_if(bus)->status & (BUSY_STAT|DRQ_STAT)))
 997         return;
 998
 999     switch(addr) {
1000     case 0:
1001         break;
1002     case 1:
1003         ide_clear_hob(bus);
1004         /* NOTE: data is written to the two drives */
1005         bus->ifs[0].hob_feature = bus->ifs[0].feature;
1006         bus->ifs[1].hob_feature = bus->ifs[1].feature;
1007         bus->ifs[0].feature = val;
1008         bus->ifs[1].feature = val;
1009         break;
1010     case 2:
1011         ide_clear_hob(bus);
1012         bus->ifs[0].hob_nsector = bus->ifs[0].nsector;
1013         bus->ifs[1].hob_nsector = bus->ifs[1].nsector;
1014         bus->ifs[0].nsector = val;
1015         bus->ifs[1].nsector = val;
1016         break;
1017     case 3:
1018         ide_clear_hob(bus);
1019         bus->ifs[0].hob_sector = bus->ifs[0].sector;
1020         bus->ifs[1].hob_sector = bus->ifs[1].sector;
1021         bus->ifs[0].sector = val;
1022         bus->ifs[1].sector = val;
1023         break;
1024     case 4:
1025         ide_clear_hob(bus);
1026         bus->ifs[0].hob_lcyl = bus->ifs[0].lcyl;
1027         bus->ifs[1].hob_lcyl = bus->ifs[1].lcyl;
1028         bus->ifs[0].lcyl = val;
1029         bus->ifs[1].lcyl = val;
1030         break;
1031     case 5:
1032         ide_clear_hob(bus);
1033         bus->ifs[0].hob_hcyl = bus->ifs[0].hcyl;
1034         bus->ifs[1].hob_hcyl = bus->ifs[1].hcyl;
1035         bus->ifs[0].hcyl = val;
1036         bus->ifs[1].hcyl = val;
1037         break;
1038     case 6:
1039         /* FIXME: HOB readback uses bit 7 */
1040         bus->ifs[0].select = (val & ~0x10) | 0xa0;
1041         bus->ifs[1].select = (val | 0x10) | 0xa0;
1042         /* select drive */
1043         bus->unit = (val >> 4) & 1;
1044         break;
1045     default:
1046     case 7:
1047         /* command */
1048         ide_exec_cmd(bus, val);
1049         break;
1050     }
1051 }
1052
1053 static bool cmd_nop(IDEState *s, uint8_t cmd)
1054 {
1055     return true;
1056 }
1057
1058 static bool cmd_data_set_management(IDEState *s, uint8_t cmd)
1059 {
1060     switch (s->feature) {
1061     case DSM_TRIM:
1062         if (s->bs) {
1063             ide_sector_start_dma(s, IDE_DMA_TRIM);
1064             return false;
1065         }
1066         break;
1067     }
1068
1069     ide_abort_command(s);
1070     return true;
1071 }
1072
1073 static bool cmd_identify(IDEState *s, uint8_t cmd)
1074 {
1075     if (s->bs && s->drive_kind != IDE_CD) {
1076         if (s->drive_kind != IDE_CFATA) {
1077             ide_identify(s);
1078         } else {
1079             ide_cfata_identify(s);
1080         }
1081         s->status = READY_STAT | SEEK_STAT;
1082         ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1083         ide_set_irq(s->bus);
1084         return false;
1085     } else {
1086         if (s->drive_kind == IDE_CD) {
1087             ide_set_signature(s);
1088         }
1089         ide_abort_command(s);
1090     }
1091
1092     return true;
1093 }
1094
1095 static bool cmd_verify(IDEState *s, uint8_t cmd)
1096 {
1097     bool lba48 = (cmd == WIN_VERIFY_EXT);
1098
1099     /* do sector number check ? */
1100     ide_cmd_lba48_transform(s, lba48);
1101
1102     return true;
1103 }
1104
1105 static bool cmd_set_multiple_mode(IDEState *s, uint8_t cmd)
1106 {
1107     if (s->drive_kind == IDE_CFATA && s->nsector == 0) {
1108         /* Disable Read and Write Multiple */
1109         s->mult_sectors = 0;
1110     } else if ((s->nsector & 0xff) != 0 &&
1111         ((s->nsector & 0xff) > MAX_MULT_SECTORS ||
1112          (s->nsector & (s->nsector - 1)) != 0)) {
1113         ide_abort_command(s);
1114     } else {
1115         s->mult_sectors = s->nsector & 0xff;
1116     }
1117
1118     return true;
1119 }
1120
1121 static bool cmd_read_multiple(IDEState *s, uint8_t cmd)
1122 {
1123     bool lba48 = (cmd == WIN_MULTREAD_EXT);
1124
1125     if (!s->bs || !s->mult_sectors) {
1126         ide_abort_command(s);
1127         return true;
1128     }
1129
1130     ide_cmd_lba48_transform(s, lba48);
1131     s->req_nb_sectors = s->mult_sectors;
1132     ide_sector_read(s);
1133     return false;
1134 }
1135
1136 static bool cmd_write_multiple(IDEState *s, uint8_t cmd)
1137 {
1138     bool lba48 = (cmd == WIN_MULTWRITE_EXT);
1139     int n;
1140
1141     if (!s->bs || !s->mult_sectors) {
1142         ide_abort_command(s);
1143         return true;
1144     }
1145
1146     ide_cmd_lba48_transform(s, lba48);
1147
1148     s->req_nb_sectors = s->mult_sectors;
1149     n = MIN(s->nsector, s->req_nb_sectors);
1150
1151     s->status = SEEK_STAT | READY_STAT;
1152     ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
1153
1154     s->media_changed = 1;
1155
1156     return false;
1157 }
1158
1159 static bool cmd_read_pio(IDEState *s, uint8_t cmd)
1160 {
1161     bool lba48 = (cmd == WIN_READ_EXT);
1162
1163     if (s->drive_kind == IDE_CD) {
1164         ide_set_signature(s); /* odd, but ATA4 8.27.5.2 requires it */
1165         ide_abort_command(s);
1166         return true;
1167     }
1168
1169     if (!s->bs) {
1170         ide_abort_command(s);
1171         return true;
1172     }
1173
1174     ide_cmd_lba48_transform(s, lba48);
1175     s->req_nb_sectors = 1;
1176     ide_sector_read(s);
1177
1178     return false;
1179 }
1180
1181 static bool cmd_write_pio(IDEState *s, uint8_t cmd)
1182 {
1183     bool lba48 = (cmd == WIN_WRITE_EXT);
1184
1185     if (!s->bs) {
1186         ide_abort_command(s);
1187         return true;
1188     }
1189
1190     ide_cmd_lba48_transform(s, lba48);
1191
1192     s->req_nb_sectors = 1;
1193     s->status = SEEK_STAT | READY_STAT;
1194     ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
1195
1196     s->media_changed = 1;
1197
1198     return false;
1199 }
1200
1201 static bool cmd_read_dma(IDEState *s, uint8_t cmd)
1202 {
1203     bool lba48 = (cmd == WIN_READDMA_EXT);
1204
1205     if (!s->bs) {
1206         ide_abort_command(s);
1207         return true;
1208     }
1209
1210     ide_cmd_lba48_transform(s, lba48);
1211     ide_sector_start_dma(s, IDE_DMA_READ);
1212
1213     return false;
1214 }
1215
1216 static bool cmd_write_dma(IDEState *s, uint8_t cmd)
1217 {
1218     bool lba48 = (cmd == WIN_WRITEDMA_EXT);
1219
1220     if (!s->bs) {
1221         ide_abort_command(s);
1222         return true;
1223     }
1224
1225     ide_cmd_lba48_transform(s, lba48);
1226     ide_sector_start_dma(s, IDE_DMA_WRITE);
1227
1228     s->media_changed = 1;
1229
1230     return false;
1231 }
1232
1233 static bool cmd_flush_cache(IDEState *s, uint8_t cmd)
1234 {
1235     ide_flush_cache(s);
1236     return false;
1237 }
1238
1239 static bool cmd_seek(IDEState *s, uint8_t cmd)
1240 {
1241     /* XXX: Check that seek is within bounds */
1242     return true;
1243 }
1244
1245 static bool cmd_read_native_max(IDEState *s, uint8_t cmd)
1246 {
1247     bool lba48 = (cmd == WIN_READ_NATIVE_MAX_EXT);
1248
1249     /* Refuse if no sectors are addressable (e.g. medium not inserted) */
1250     if (s->nb_sectors == 0) {
1251         ide_abort_command(s);
1252         return true;
1253     }
1254
1255     ide_cmd_lba48_transform(s, lba48);
1256     ide_set_sector(s, s->nb_sectors - 1);
1257
1258     return true;
1259 }
1260
1261 static bool cmd_check_power_mode(IDEState *s, uint8_t cmd)
1262 {
1263     s->nsector = 0xff; /* device active or idle */
1264     return true;
1265 }
1266
1267 static bool cmd_set_features(IDEState *s, uint8_t cmd)
1268 {
1269     uint16_t *identify_data;
1270
1271     if (!s->bs) {
1272         ide_abort_command(s);
1273         return true;
1274     }
1275
1276     /* XXX: valid for CDROM ? */
1277     switch (s->feature) {
1278     case 0x02: /* write cache enable */
1279         bdrv_set_enable_write_cache(s->bs, true);
1280         identify_data = (uint16_t *)s->identify_data;
1281         put_le16(identify_data + 85, (1 << 14) | (1 << 5) | 1);
1282         return true;
1283     case 0x82: /* write cache disable */
1284         bdrv_set_enable_write_cache(s->bs, false);
1285         identify_data = (uint16_t *)s->identify_data;
1286         put_le16(identify_data + 85, (1 << 14) | 1);
1287         ide_flush_cache(s);
1288         return false;
1289     case 0xcc: /* reverting to power-on defaults enable */
1290     case 0x66: /* reverting to power-on defaults disable */
1291     case 0xaa: /* read look-ahead enable */
1292     case 0x55: /* read look-ahead disable */
1293     case 0x05: /* set advanced power management mode */
1294     case 0x85: /* disable advanced power management mode */
1295     case 0x69: /* NOP */
1296     case 0x67: /* NOP */
1297     case 0x96: /* NOP */
1298     case 0x9a: /* NOP */
1299     case 0x42: /* enable Automatic Acoustic Mode */
1300     case 0xc2: /* disable Automatic Acoustic Mode */
1301         return true;
1302     case 0x03: /* set transfer mode */
1303         {
1304             uint8_t val = s->nsector & 0x07;
1305             identify_data = (uint16_t *)s->identify_data;
1306
1307             switch (s->nsector >> 3) {
1308             case 0x00: /* pio default */
1309             case 0x01: /* pio mode */
1310                 put_le16(identify_data + 62, 0x07);
1311                 put_le16(identify_data + 63, 0x07);
1312                 put_le16(identify_data + 88, 0x3f);
1313                 break;
1314             case 0x02: /* sigle word dma mode*/
1315                 put_le16(identify_data + 62, 0x07 | (1 << (val + 8)));
1316                 put_le16(identify_data + 63, 0x07);
1317                 put_le16(identify_data + 88, 0x3f);
1318                 break;
1319             case 0x04: /* mdma mode */
1320                 put_le16(identify_data + 62, 0x07);
1321                 put_le16(identify_data + 63, 0x07 | (1 << (val + 8)));
1322                 put_le16(identify_data + 88, 0x3f);
1323                 break;
1324             case 0x08: /* udma mode */
1325                 put_le16(identify_data + 62, 0x07);
1326                 put_le16(identify_data + 63, 0x07);
1327                 put_le16(identify_data + 88, 0x3f | (1 << (val + 8)));
1328                 break;
1329             default:
1330                 goto abort_cmd;
1331             }
1332             return true;
1333         }
1334     }
1335
1336 abort_cmd:
1337     ide_abort_command(s);
1338     return true;
1339 }
1340
1341
1342 /*** ATAPI commands ***/
1343
1344 static bool cmd_identify_packet(IDEState *s, uint8_t cmd)
1345 {
1346     ide_atapi_identify(s);
1347     s->status = READY_STAT | SEEK_STAT;
1348     ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1349     ide_set_irq(s->bus);
1350     return false;
1351 }
1352
1353 static bool cmd_exec_dev_diagnostic(IDEState *s, uint8_t cmd)
1354 {
1355     ide_set_signature(s);
1356
1357     if (s->drive_kind == IDE_CD) {
1358         s->status = 0; /* ATAPI spec (v6) section 9.10 defines packet
1359                         * devices to return a clear status register
1360                         * with READY_STAT *not* set. */
1361         s->error = 0x01;
1362     } else {
1363         s->status = READY_STAT | SEEK_STAT;
1364         /* The bits of the error register are not as usual for this command!
1365          * They are part of the regular output (this is why ERR_STAT isn't set)
1366          * Device 0 passed, Device 1 passed or not present. */
1367         s->error = 0x01;
1368         ide_set_irq(s->bus);
1369     }
1370
1371     return false;
1372 }
1373
1374 static bool cmd_device_reset(IDEState *s, uint8_t cmd)
1375 {
1376     ide_set_signature(s);
1377     s->status = 0x00; /* NOTE: READY is _not_ set */
1378     s->error = 0x01;
1379
1380     return false;
1381 }
1382
1383 static bool cmd_packet(IDEState *s, uint8_t cmd)
1384 {
1385     /* overlapping commands not supported */
1386     if (s->feature & 0x02) {
1387         ide_abort_command(s);
1388         return true;
1389     }
1390
1391     s->status = READY_STAT | SEEK_STAT;
1392     s->atapi_dma = s->feature & 1;
1393     s->nsector = 1;
1394     ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
1395                        ide_atapi_cmd);
1396     return false;
1397 }
1398
1399
1400 /*** CF-ATA commands ***/
1401
1402 static bool cmd_cfa_req_ext_error_code(IDEState *s, uint8_t cmd)
1403 {
1404     s->error = 0x09;    /* miscellaneous error */
1405     s->status = READY_STAT | SEEK_STAT;
1406     ide_set_irq(s->bus);
1407
1408     return false;
1409 }
1410
1411 static bool cmd_cfa_erase_sectors(IDEState *s, uint8_t cmd)
1412 {
1413     /* WIN_SECURITY_FREEZE_LOCK has the same ID as CFA_WEAR_LEVEL and is
1414      * required for Windows 8 to work with AHCI */
1415
1416     if (cmd == CFA_WEAR_LEVEL) {
1417         s->nsector = 0;
1418     }
1419
1420     if (cmd == CFA_ERASE_SECTORS) {
1421         s->media_changed = 1;
1422     }
1423
1424     return true;
1425 }
1426
1427 static bool cmd_cfa_translate_sector(IDEState *s, uint8_t cmd)
1428 {
1429     s->status = READY_STAT | SEEK_STAT;
1430
1431     memset(s->io_buffer, 0, 0x200);
1432     s->io_buffer[0x00] = s->hcyl;                   /* Cyl MSB */
1433     s->io_buffer[0x01] = s->lcyl;                   /* Cyl LSB */
1434     s->io_buffer[0x02] = s->select;                 /* Head */
1435     s->io_buffer[0x03] = s->sector;                 /* Sector */
1436     s->io_buffer[0x04] = ide_get_sector(s) >> 16;   /* LBA MSB */
1437     s->io_buffer[0x05] = ide_get_sector(s) >> 8;    /* LBA */
1438     s->io_buffer[0x06] = ide_get_sector(s) >> 0;    /* LBA LSB */
1439     s->io_buffer[0x13] = 0x00;                      /* Erase flag */
1440     s->io_buffer[0x18] = 0x00;                      /* Hot count */
1441     s->io_buffer[0x19] = 0x00;                      /* Hot count */
1442     s->io_buffer[0x1a] = 0x01;                      /* Hot count */
1443
1444     ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1445     ide_set_irq(s->bus);
1446
1447     return false;
1448 }
1449
1450 static bool cmd_cfa_access_metadata_storage(IDEState *s, uint8_t cmd)
1451 {
1452     switch (s->feature) {
1453     case 0x02:  /* Inquiry Metadata Storage */
1454         ide_cfata_metadata_inquiry(s);
1455         break;
1456     case 0x03:  /* Read Metadata Storage */
1457         ide_cfata_metadata_read(s);
1458         break;
1459     case 0x04:  /* Write Metadata Storage */
1460         ide_cfata_metadata_write(s);
1461         break;
1462     default:
1463         ide_abort_command(s);
1464         return true;
1465     }
1466
1467     ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1468     s->status = 0x00; /* NOTE: READY is _not_ set */
1469     ide_set_irq(s->bus);
1470
1471     return false;
1472 }
1473
1474 static bool cmd_ibm_sense_condition(IDEState *s, uint8_t cmd)
1475 {
1476     switch (s->feature) {
1477     case 0x01:  /* sense temperature in device */
1478         s->nsector = 0x50;      /* +20 C */
1479         break;
1480     default:
1481         ide_abort_command(s);
1482         return true;
1483     }
1484
1485     return true;
1486 }
1487
1488
1489 /*** SMART commands ***/
1490
1491 static bool cmd_smart(IDEState *s, uint8_t cmd)
1492 {
1493     int n;
1494
1495     if (s->hcyl != 0xc2 || s->lcyl != 0x4f) {
1496         goto abort_cmd;
1497     }
1498
1499     if (!s->smart_enabled && s->feature != SMART_ENABLE) {
1500         goto abort_cmd;
1501     }
1502
1503     switch (s->feature) {
1504     case SMART_DISABLE:
1505         s->smart_enabled = 0;
1506         return true;
1507
1508     case SMART_ENABLE:
1509         s->smart_enabled = 1;
1510         return true;
1511
1512     case SMART_ATTR_AUTOSAVE:
1513         switch (s->sector) {
1514         case 0x00:
1515             s->smart_autosave = 0;
1516             break;
1517         case 0xf1:
1518             s->smart_autosave = 1;
1519             break;
1520         default:
1521             goto abort_cmd;
1522         }
1523         return true;
1524
1525     case SMART_STATUS:
1526         if (!s->smart_errors) {
1527             s->hcyl = 0xc2;
1528             s->lcyl = 0x4f;
1529         } else {
1530             s->hcyl = 0x2c;
1531             s->lcyl = 0xf4;
1532         }
1533         return true;
1534
1535     case SMART_READ_THRESH:
1536         memset(s->io_buffer, 0, 0x200);
1537         s->io_buffer[0] = 0x01; /* smart struct version */
1538
1539         for (n = 0; n < ARRAY_SIZE(smart_attributes); n++) {
1540             s->io_buffer[2 + 0 + (n * 12)] = smart_attributes[n][0];
1541             s->io_buffer[2 + 1 + (n * 12)] = smart_attributes[n][11];
1542         }
1543
1544         /* checksum */
1545         for (n = 0; n < 511; n++) {
1546             s->io_buffer[511] += s->io_buffer[n];
1547         }
1548         s->io_buffer[511] = 0x100 - s->io_buffer[511];
1549
1550         s->status = READY_STAT | SEEK_STAT;
1551         ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1552         ide_set_irq(s->bus);
1553         return false;
1554
1555     case SMART_READ_DATA:
1556         memset(s->io_buffer, 0, 0x200);
1557         s->io_buffer[0] = 0x01; /* smart struct version */
1558
1559         for (n = 0; n < ARRAY_SIZE(smart_attributes); n++) {
1560             int i;
1561             for (i = 0; i < 11; i++) {
1562                 s->io_buffer[2 + i + (n * 12)] = smart_attributes[n][i];
1563             }
1564         }
1565
1566         s->io_buffer[362] = 0x02 | (s->smart_autosave ? 0x80 : 0x00);
1567         if (s->smart_selftest_count == 0) {
1568             s->io_buffer[363] = 0;
1569         } else {
1570             s->io_buffer[363] =
1571                 s->smart_selftest_data[3 +
1572                            (s->smart_selftest_count - 1) *
1573                            24];
1574         }
1575         s->io_buffer[364] = 0x20;
1576         s->io_buffer[365] = 0x01;
1577         /* offline data collection capacity: execute + self-test*/
1578         s->io_buffer[367] = (1 << 4 | 1 << 3 | 1);
1579         s->io_buffer[368] = 0x03; /* smart capability (1) */
1580         s->io_buffer[369] = 0x00; /* smart capability (2) */
1581         s->io_buffer[370] = 0x01; /* error logging supported */
1582         s->io_buffer[372] = 0x02; /* minutes for poll short test */
1583         s->io_buffer[373] = 0x36; /* minutes for poll ext test */
1584         s->io_buffer[374] = 0x01; /* minutes for poll conveyance */
1585
1586         for (n = 0; n < 511; n++) {
1587             s->io_buffer[511] += s->io_buffer[n];
1588         }
1589         s->io_buffer[511] = 0x100 - s->io_buffer[511];
1590
1591         s->status = READY_STAT | SEEK_STAT;
1592         ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1593         ide_set_irq(s->bus);
1594         return false;
1595
1596     case SMART_READ_LOG:
1597         switch (s->sector) {
1598         case 0x01: /* summary smart error log */
1599             memset(s->io_buffer, 0, 0x200);
1600             s->io_buffer[0] = 0x01;
1601             s->io_buffer[1] = 0x00; /* no error entries */
1602             s->io_buffer[452] = s->smart_errors & 0xff;
1603             s->io_buffer[453] = (s->smart_errors & 0xff00) >> 8;
1604
1605             for (n = 0; n < 511; n++) {
1606                 s->io_buffer[511] += s->io_buffer[n];
1607             }
1608             s->io_buffer[511] = 0x100 - s->io_buffer[511];
1609             break;
1610         case 0x06: /* smart self test log */
1611             memset(s->io_buffer, 0, 0x200);
1612             s->io_buffer[0] = 0x01;
1613             if (s->smart_selftest_count == 0) {
1614                 s->io_buffer[508] = 0;
1615             } else {
1616                 s->io_buffer[508] = s->smart_selftest_count;
1617                 for (n = 2; n < 506; n++)  {
1618                     s->io_buffer[n] = s->smart_selftest_data[n];
1619                 }
1620             }
1621
1622             for (n = 0; n < 511; n++) {
1623                 s->io_buffer[511] += s->io_buffer[n];
1624             }
1625             s->io_buffer[511] = 0x100 - s->io_buffer[511];
1626             break;
1627         default:
1628             goto abort_cmd;
1629         }
1630         s->status = READY_STAT | SEEK_STAT;
1631         ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1632         ide_set_irq(s->bus);
1633         return false;
1634
1635     case SMART_EXECUTE_OFFLINE:
1636         switch (s->sector) {
1637         case 0: /* off-line routine */
1638         case 1: /* short self test */
1639         case 2: /* extended self test */
1640             s->smart_selftest_count++;
1641             if (s->smart_selftest_count > 21) {
1642                 s->smart_selftest_count = 1;
1643             }
1644             n = 2 + (s->smart_selftest_count - 1) * 24;
1645             s->smart_selftest_data[n] = s->sector;
1646             s->smart_selftest_data[n + 1] = 0x00; /* OK and finished */
1647             s->smart_selftest_data[n + 2] = 0x34; /* hour count lsb */
1648             s->smart_selftest_data[n + 3] = 0x12; /* hour count msb */
1649             break;
1650         default:
1651             goto abort_cmd;
1652         }
1653         return true;
1654     }
1655
1656 abort_cmd:
1657     ide_abort_command(s);
1658     return true;
1659 }
1660
1661 #define HD_OK (1u << IDE_HD)
1662 #define CD_OK (1u << IDE_CD)
1663 #define CFA_OK (1u << IDE_CFATA)
1664 #define HD_CFA_OK (HD_OK | CFA_OK)
1665 #define ALL_OK (HD_OK | CD_OK | CFA_OK)
1666
1667 /* Set the Disk Seek Completed status bit during completion */
1668 #define SET_DSC (1u << 8)
1669
1670 /* See ACS-2 T13/2015-D Table B.2 Command codes */
1671 static const struct {
1672     /* Returns true if the completion code should be run */
1673     bool (*handler)(IDEState *s, uint8_t cmd);
1674     int flags;
1675 } ide_cmd_table[0x100] = {
1676     /* NOP not implemented, mandatory for CD */
1677     [CFA_REQ_EXT_ERROR_CODE]      = { cmd_cfa_req_ext_error_code, CFA_OK },
1678     [WIN_DSM]                     = { cmd_data_set_management, ALL_OK },
1679     [WIN_DEVICE_RESET]            = { cmd_device_reset, CD_OK },
1680     [WIN_RECAL]                   = { cmd_nop, HD_CFA_OK | SET_DSC},
1681     [WIN_READ]                    = { cmd_read_pio, ALL_OK },
1682     [WIN_READ_ONCE]               = { cmd_read_pio, ALL_OK },
1683     [WIN_READ_EXT]                = { cmd_read_pio, HD_CFA_OK },
1684     [WIN_READDMA_EXT]             = { cmd_read_dma, HD_CFA_OK },
1685     [WIN_READ_NATIVE_MAX_EXT]     = { cmd_read_native_max, HD_CFA_OK | SET_DSC },
1686     [WIN_MULTREAD_EXT]            = { cmd_read_multiple, HD_CFA_OK },
1687     [WIN_WRITE]                   = { cmd_write_pio, HD_CFA_OK },
1688     [WIN_WRITE_ONCE]              = { cmd_write_pio, HD_CFA_OK },
1689     [WIN_WRITE_EXT]               = { cmd_write_pio, HD_CFA_OK },
1690     [WIN_WRITEDMA_EXT]            = { cmd_write_dma, HD_CFA_OK },
1691     [CFA_WRITE_SECT_WO_ERASE]     = { cmd_write_pio, CFA_OK },
1692     [WIN_MULTWRITE_EXT]           = { cmd_write_multiple, HD_CFA_OK },
1693     [WIN_WRITE_VERIFY]            = { cmd_write_pio, HD_CFA_OK },
1694     [WIN_VERIFY]                  = { cmd_verify, HD_CFA_OK | SET_DSC },
1695     [WIN_VERIFY_ONCE]             = { cmd_verify, HD_CFA_OK | SET_DSC },
1696     [WIN_VERIFY_EXT]              = { cmd_verify, HD_CFA_OK | SET_DSC },
1697     [WIN_SEEK]                    = { cmd_seek, HD_CFA_OK | SET_DSC },
1698     [CFA_TRANSLATE_SECTOR]        = { cmd_cfa_translate_sector, CFA_OK },
1699     [WIN_DIAGNOSE]                = { cmd_exec_dev_diagnostic, ALL_OK },
1700     [WIN_SPECIFY]                 = { cmd_nop, HD_CFA_OK | SET_DSC },
1701     [WIN_STANDBYNOW2]             = { cmd_nop, ALL_OK },
1702     [WIN_IDLEIMMEDIATE2]          = { cmd_nop, ALL_OK },
1703     [WIN_STANDBY2]                = { cmd_nop, ALL_OK },
1704     [WIN_SETIDLE2]                = { cmd_nop, ALL_OK },
1705     [WIN_CHECKPOWERMODE2]         = { cmd_check_power_mode, ALL_OK | SET_DSC },
1706     [WIN_SLEEPNOW2]               = { cmd_nop, ALL_OK },
1707     [WIN_PACKETCMD]               = { cmd_packet, CD_OK },
1708     [WIN_PIDENTIFY]               = { cmd_identify_packet, CD_OK },
1709     [WIN_SMART]                   = { cmd_smart, HD_CFA_OK | SET_DSC },
1710     [CFA_ACCESS_METADATA_STORAGE] = { cmd_cfa_access_metadata_storage, CFA_OK },
1711     [CFA_ERASE_SECTORS]           = { cmd_cfa_erase_sectors, CFA_OK | SET_DSC },
1712     [WIN_MULTREAD]                = { cmd_read_multiple, HD_CFA_OK },
1713     [WIN_MULTWRITE]               = { cmd_write_multiple, HD_CFA_OK },
1714     [WIN_SETMULT]                 = { cmd_set_multiple_mode, HD_CFA_OK | SET_DSC },
1715     [WIN_READDMA]                 = { cmd_read_dma, HD_CFA_OK },
1716     [WIN_READDMA_ONCE]            = { cmd_read_dma, HD_CFA_OK },
1717     [WIN_WRITEDMA]                = { cmd_write_dma, HD_CFA_OK },
1718     [WIN_WRITEDMA_ONCE]           = { cmd_write_dma, HD_CFA_OK },
1719     [CFA_WRITE_MULTI_WO_ERASE]    = { cmd_write_multiple, CFA_OK },
1720     [WIN_STANDBYNOW1]             = { cmd_nop, ALL_OK },
1721     [WIN_IDLEIMMEDIATE]           = { cmd_nop, ALL_OK },
1722     [WIN_STANDBY]                 = { cmd_nop, ALL_OK },
1723     [WIN_SETIDLE1]                = { cmd_nop, ALL_OK },
1724     [WIN_CHECKPOWERMODE1]         = { cmd_check_power_mode, ALL_OK | SET_DSC },
1725     [WIN_SLEEPNOW1]               = { cmd_nop, ALL_OK },
1726     [WIN_FLUSH_CACHE]             = { cmd_flush_cache, ALL_OK },
1727     [WIN_FLUSH_CACHE_EXT]         = { cmd_flush_cache, HD_CFA_OK },
1728     [WIN_IDENTIFY]                = { cmd_identify, ALL_OK },
1729     [WIN_SETFEATURES]             = { cmd_set_features, ALL_OK | SET_DSC },
1730     [IBM_SENSE_CONDITION]         = { cmd_ibm_sense_condition, CFA_OK | SET_DSC },
1731     [CFA_WEAR_LEVEL]              = { cmd_cfa_erase_sectors, HD_CFA_OK | SET_DSC },
1732     [WIN_READ_NATIVE_MAX]         = { cmd_read_native_max, ALL_OK | SET_DSC },
1733 };
1734
1735 static bool ide_cmd_permitted(IDEState *s, uint32_t cmd)
1736 {
1737     return cmd < ARRAY_SIZE(ide_cmd_table)
1738         && (ide_cmd_table[cmd].flags & (1u << s->drive_kind));
1739 }
1740
1741 void ide_exec_cmd(IDEBus *bus, uint32_t val)
1742 {
1743     IDEState *s;
1744     bool complete;
1745
1746 #if defined(DEBUG_IDE)
1747     printf("ide: CMD=%02x\n", val);
1748 #endif
1749     s = idebus_active_if(bus);
1750     /* ignore commands to non existent slave */
1751     if (s != bus->ifs && !s->bs)
1752         return;
1753
1754     /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
1755     if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET)
1756         return;
1757
1758     if (!ide_cmd_permitted(s, val)) {
1759         ide_abort_command(s);
1760         ide_set_irq(s->bus);
1761         return;
1762     }
1763
1764     s->status = READY_STAT | BUSY_STAT;
1765     s->error = 0;
1766
1767     complete = ide_cmd_table[val].handler(s, val);
1768     if (complete) {
1769         s->status &= ~BUSY_STAT;
1770         assert(!!s->error == !!(s->status & ERR_STAT));
1771
1772         if ((ide_cmd_table[val].flags & SET_DSC) && !s->error) {
1773             s->status |= SEEK_STAT;
1774         }
1775
1776         ide_set_irq(s->bus);
1777     }
1778 }
1779
1780 uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
1781 {
1782     IDEBus *bus = opaque;
1783     IDEState *s = idebus_active_if(bus);
1784     uint32_t addr;
1785     int ret, hob;
1786
1787     addr = addr1 & 7;
1788     /* FIXME: HOB readback uses bit 7, but it's always set right now */
1789     //hob = s->select & (1 << 7);
1790     hob = 0;
1791     switch(addr) {
1792     case 0:
1793         ret = 0xff;
1794         break;
1795     case 1:
1796         if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1797             (s != bus->ifs && !s->bs))
1798             ret = 0;
1799         else if (!hob)
1800             ret = s->error;
1801         else
1802             ret = s->hob_feature;
1803         break;
1804     case 2:
1805         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1806             ret = 0;
1807         else if (!hob)
1808             ret = s->nsector & 0xff;
1809         else
1810             ret = s->hob_nsector;
1811         break;
1812     case 3:
1813         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1814             ret = 0;
1815         else if (!hob)
1816             ret = s->sector;
1817         else
1818             ret = s->hob_sector;
1819         break;
1820     case 4:
1821         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1822             ret = 0;
1823         else if (!hob)
1824             ret = s->lcyl;
1825         else
1826             ret = s->hob_lcyl;
1827         break;
1828     case 5:
1829         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1830             ret = 0;
1831         else if (!hob)
1832             ret = s->hcyl;
1833         else
1834             ret = s->hob_hcyl;
1835         break;
1836     case 6:
1837         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1838             ret = 0;
1839         else
1840             ret = s->select;
1841         break;
1842     default:
1843     case 7:
1844         if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1845             (s != bus->ifs && !s->bs))
1846             ret = 0;
1847         else
1848             ret = s->status;
1849         qemu_irq_lower(bus->irq);
1850         break;
1851     }
1852 #ifdef DEBUG_IDE
1853     printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
1854 #endif
1855     return ret;
1856 }
1857
1858 uint32_t ide_status_read(void *opaque, uint32_t addr)
1859 {
1860     IDEBus *bus = opaque;
1861     IDEState *s = idebus_active_if(bus);
1862     int ret;
1863
1864     if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1865         (s != bus->ifs && !s->bs))
1866         ret = 0;
1867     else
1868         ret = s->status;
1869 #ifdef DEBUG_IDE
1870     printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
1871 #endif
1872     return ret;
1873 }
1874
1875 void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
1876 {
1877     IDEBus *bus = opaque;
1878     IDEState *s;
1879     int i;
1880
1881 #ifdef DEBUG_IDE
1882     printf("ide: write control addr=0x%x val=%02x\n", addr, val);
1883 #endif
1884     /* common for both drives */
1885     if (!(bus->cmd & IDE_CMD_RESET) &&
1886         (val & IDE_CMD_RESET)) {
1887         /* reset low to high */
1888         for(i = 0;i < 2; i++) {
1889             s = &bus->ifs[i];
1890             s->status = BUSY_STAT | SEEK_STAT;
1891             s->error = 0x01;
1892         }
1893     } else if ((bus->cmd & IDE_CMD_RESET) &&
1894                !(val & IDE_CMD_RESET)) {
1895         /* high to low */
1896         for(i = 0;i < 2; i++) {
1897             s = &bus->ifs[i];
1898             if (s->drive_kind == IDE_CD)
1899                 s->status = 0x00; /* NOTE: READY is _not_ set */
1900             else
1901                 s->status = READY_STAT | SEEK_STAT;
1902             ide_set_signature(s);
1903         }
1904     }
1905
1906     bus->cmd = val;
1907 }
1908
1909 /*
1910  * Returns true if the running PIO transfer is a PIO out (i.e. data is
1911  * transferred from the device to the guest), false if it's a PIO in
1912  */
1913 static bool ide_is_pio_out(IDEState *s)
1914 {
1915     if (s->end_transfer_func == ide_sector_write ||
1916         s->end_transfer_func == ide_atapi_cmd) {
1917         return false;
1918     } else if (s->end_transfer_func == ide_sector_read ||
1919                s->end_transfer_func == ide_transfer_stop ||
1920                s->end_transfer_func == ide_atapi_cmd_reply_end ||
1921                s->end_transfer_func == ide_dummy_transfer_stop) {
1922         return true;
1923     }
1924
1925     abort();
1926 }
1927
1928 void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
1929 {
1930     IDEBus *bus = opaque;
1931     IDEState *s = idebus_active_if(bus);
1932     uint8_t *p;
1933
1934     /* PIO data access allowed only when DRQ bit is set. The result of a write
1935      * during PIO out is indeterminate, just ignore it. */
1936     if (!(s->status & DRQ_STAT) || ide_is_pio_out(s)) {
1937         return;
1938     }
1939
1940     p = s->data_ptr;
1941     *(uint16_t *)p = le16_to_cpu(val);
1942     p += 2;
1943     s->data_ptr = p;
1944     if (p >= s->data_end)
1945         s->end_transfer_func(s);
1946 }
1947
1948 uint32_t ide_data_readw(void *opaque, uint32_t addr)
1949 {
1950     IDEBus *bus = opaque;
1951     IDEState *s = idebus_active_if(bus);
1952     uint8_t *p;
1953     int ret;
1954
1955     /* PIO data access allowed only when DRQ bit is set. The result of a read
1956      * during PIO in is indeterminate, return 0 and don't move forward. */
1957     if (!(s->status & DRQ_STAT) || !ide_is_pio_out(s)) {
1958         return 0;
1959     }
1960
1961     p = s->data_ptr;
1962     ret = cpu_to_le16(*(uint16_t *)p);
1963     p += 2;
1964     s->data_ptr = p;
1965     if (p >= s->data_end)
1966         s->end_transfer_func(s);
1967     return ret;
1968 }
1969
1970 void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
1971 {
1972     IDEBus *bus = opaque;
1973     IDEState *s = idebus_active_if(bus);
1974     uint8_t *p;
1975
1976     /* PIO data access allowed only when DRQ bit is set. The result of a write
1977      * during PIO out is indeterminate, just ignore it. */
1978     if (!(s->status & DRQ_STAT) || ide_is_pio_out(s)) {
1979         return;
1980     }
1981
1982     p = s->data_ptr;
1983     *(uint32_t *)p = le32_to_cpu(val);
1984     p += 4;
1985     s->data_ptr = p;
1986     if (p >= s->data_end)
1987         s->end_transfer_func(s);
1988 }
1989
1990 uint32_t ide_data_readl(void *opaque, uint32_t addr)
1991 {
1992     IDEBus *bus = opaque;
1993     IDEState *s = idebus_active_if(bus);
1994     uint8_t *p;
1995     int ret;
1996
1997     /* PIO data access allowed only when DRQ bit is set. The result of a read
1998      * during PIO in is indeterminate, return 0 and don't move forward. */
1999     if (!(s->status & DRQ_STAT) || !ide_is_pio_out(s)) {
2000         return 0;
2001     }
2002
2003     p = s->data_ptr;
2004     ret = cpu_to_le32(*(uint32_t *)p);
2005     p += 4;
2006     s->data_ptr = p;
2007     if (p >= s->data_end)
2008         s->end_transfer_func(s);
2009     return ret;
2010 }
2011
2012 static void ide_dummy_transfer_stop(IDEState *s)
2013 {
2014     s->data_ptr = s->io_buffer;
2015     s->data_end = s->io_buffer;
2016     s->io_buffer[0] = 0xff;
2017     s->io_buffer[1] = 0xff;
2018     s->io_buffer[2] = 0xff;
2019     s->io_buffer[3] = 0xff;
2020 }
2021
2022 static void ide_reset(IDEState *s)
2023 {
2024 #ifdef DEBUG_IDE
2025     printf("ide: reset\n");
2026 #endif
2027
2028     if (s->pio_aiocb) {
2029         bdrv_aio_cancel(s->pio_aiocb);
2030         s->pio_aiocb = NULL;
2031     }
2032
2033     if (s->drive_kind == IDE_CFATA)
2034         s->mult_sectors = 0;
2035     else
2036         s->mult_sectors = MAX_MULT_SECTORS;
2037     /* ide regs */
2038     s->feature = 0;
2039     s->error = 0;
2040     s->nsector = 0;
2041     s->sector = 0;
2042     s->lcyl = 0;
2043     s->hcyl = 0;
2044
2045     /* lba48 */
2046     s->hob_feature = 0;
2047     s->hob_sector = 0;
2048     s->hob_nsector = 0;
2049     s->hob_lcyl = 0;
2050     s->hob_hcyl = 0;
2051
2052     s->select = 0xa0;
2053     s->status = READY_STAT | SEEK_STAT;
2054
2055     s->lba48 = 0;
2056
2057     /* ATAPI specific */
2058     s->sense_key = 0;
2059     s->asc = 0;
2060     s->cdrom_changed = 0;
2061     s->packet_transfer_size = 0;
2062     s->elementary_transfer_size = 0;
2063     s->io_buffer_index = 0;
2064     s->cd_sector_size = 0;
2065     s->atapi_dma = 0;
2066     s->tray_locked = 0;
2067     s->tray_open = 0;
2068     /* ATA DMA state */
2069     s->io_buffer_size = 0;
2070     s->req_nb_sectors = 0;
2071
2072     ide_set_signature(s);
2073     /* init the transfer handler so that 0xffff is returned on data
2074        accesses */
2075     s->end_transfer_func = ide_dummy_transfer_stop;
2076     ide_dummy_transfer_stop(s);
2077     s->media_changed = 0;
2078 }
2079
2080 void ide_bus_reset(IDEBus *bus)
2081 {
2082     bus->unit = 0;
2083     bus->cmd = 0;
2084     ide_reset(&bus->ifs[0]);
2085     ide_reset(&bus->ifs[1]);
2086     ide_clear_hob(bus);
2087
2088     /* pending async DMA */
2089     if (bus->dma->aiocb) {
2090 #ifdef DEBUG_AIO
2091         printf("aio_cancel\n");
2092 #endif
2093         bdrv_aio_cancel(bus->dma->aiocb);
2094         bus->dma->aiocb = NULL;
2095     }
2096
2097     /* reset dma provider too */
2098     if (bus->dma->ops->reset) {
2099         bus->dma->ops->reset(bus->dma);
2100     }
2101 }
2102
2103 static bool ide_cd_is_tray_open(void *opaque)
2104 {
2105     return ((IDEState *)opaque)->tray_open;
2106 }
2107
2108 static bool ide_cd_is_medium_locked(void *opaque)
2109 {
2110     return ((IDEState *)opaque)->tray_locked;
2111 }
2112
2113 static const BlockDevOps ide_cd_block_ops = {
2114     .change_media_cb = ide_cd_change_cb,
2115     .eject_request_cb = ide_cd_eject_request_cb,
2116     .is_tray_open = ide_cd_is_tray_open,
2117     .is_medium_locked = ide_cd_is_medium_locked,
2118 };
2119
2120 int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind,
2121                    const char *version, const char *serial, const char *model,
2122                    uint64_t wwn,
2123                    uint32_t cylinders, uint32_t heads, uint32_t secs,
2124                    int chs_trans)
2125 {
2126     uint64_t nb_sectors;
2127
2128     s->bs = bs;
2129     s->drive_kind = kind;
2130
2131     bdrv_get_geometry(bs, &nb_sectors);
2132     s->cylinders = cylinders;
2133     s->heads = heads;
2134     s->sectors = secs;
2135     s->chs_trans = chs_trans;
2136     s->nb_sectors = nb_sectors;
2137     s->wwn = wwn;
2138     /* The SMART values should be preserved across power cycles
2139        but they aren't.  */
2140     s->smart_enabled = 1;
2141     s->smart_autosave = 1;
2142     s->smart_errors = 0;
2143     s->smart_selftest_count = 0;
2144     if (kind == IDE_CD) {
2145         bdrv_set_dev_ops(bs, &ide_cd_block_ops, s);
2146         bdrv_set_guest_block_size(bs, 2048);
2147     } else {
2148         if (!bdrv_is_inserted(s->bs)) {
2149             error_report("Device needs media, but drive is empty");
2150             return -1;
2151         }
2152         if (bdrv_is_read_only(bs)) {
2153             error_report("Can't use a read-only drive");
2154             return -1;
2155         }
2156     }
2157     if (serial) {
2158         pstrcpy(s->drive_serial_str, sizeof(s->drive_serial_str), serial);
2159     } else {
2160         snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),
2161                  "QM%05d", s->drive_serial);
2162     }
2163     if (model) {
2164         pstrcpy(s->drive_model_str, sizeof(s->drive_model_str), model);
2165     } else {
2166         switch (kind) {
2167         case IDE_CD:
2168             strcpy(s->drive_model_str, "QEMU DVD-ROM");
2169             break;
2170         case IDE_CFATA:
2171             strcpy(s->drive_model_str, "QEMU MICRODRIVE");
2172             break;
2173         default:
2174             strcpy(s->drive_model_str, "QEMU HARDDISK");
2175             break;
2176         }
2177     }
2178
2179     if (version) {
2180         pstrcpy(s->version, sizeof(s->version), version);
2181     } else {
2182         pstrcpy(s->version, sizeof(s->version), qemu_get_version());
2183     }
2184
2185     ide_reset(s);
2186     bdrv_iostatus_enable(bs);
2187     return 0;
2188 }
2189
2190 static void ide_init1(IDEBus *bus, int unit)
2191 {
2192     static int drive_serial = 1;
2193     IDEState *s = &bus->ifs[unit];
2194
2195     s->bus = bus;
2196     s->unit = unit;
2197     s->drive_serial = drive_serial++;
2198     /* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
2199     s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
2200     s->io_buffer = qemu_memalign(2048, s->io_buffer_total_len);
2201     memset(s->io_buffer, 0, s->io_buffer_total_len);
2202
2203     s->smart_selftest_data = qemu_blockalign(s->bs, 512);
2204     memset(s->smart_selftest_data, 0, 512);
2205
2206     s->sector_write_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
2207                                            ide_sector_write_timer_cb, s);
2208 }
2209
2210 static int ide_nop_int(IDEDMA *dma, int x)
2211 {
2212     return 0;
2213 }
2214
2215 static void ide_nop_restart(void *opaque, int x, RunState y)
2216 {
2217 }
2218
2219 static const IDEDMAOps ide_dma_nop_ops = {
2220     .prepare_buf    = ide_nop_int,
2221     .rw_buf         = ide_nop_int,
2222     .set_unit       = ide_nop_int,
2223     .restart_cb     = ide_nop_restart,
2224 };
2225
2226 static IDEDMA ide_dma_nop = {
2227     .ops = &ide_dma_nop_ops,
2228     .aiocb = NULL,
2229 };
2230
2231 void ide_init2(IDEBus *bus, qemu_irq irq)
2232 {
2233     int i;
2234
2235     for(i = 0; i < 2; i++) {
2236         ide_init1(bus, i);
2237         ide_reset(&bus->ifs[i]);
2238     }
2239     bus->irq = irq;
2240     bus->dma = &ide_dma_nop;
2241 }
2242
2243 static const MemoryRegionPortio ide_portio_list[] = {
2244     { 0, 8, 1, .read = ide_ioport_read, .write = ide_ioport_write },
2245     { 0, 2, 2, .read = ide_data_readw, .write = ide_data_writew },
2246     { 0, 4, 4, .read = ide_data_readl, .write = ide_data_writel },
2247     PORTIO_END_OF_LIST(),
2248 };
2249
2250 static const MemoryRegionPortio ide_portio2_list[] = {
2251     { 0, 1, 1, .read = ide_status_read, .write = ide_cmd_write },
2252     PORTIO_END_OF_LIST(),
2253 };
2254
2255 void ide_init_ioport(IDEBus *bus, ISADevice *dev, int iobase, int iobase2)
2256 {
2257     /* ??? Assume only ISA and PCI configurations, and that the PCI-ISA
2258        bridge has been setup properly to always register with ISA.  */
2259     isa_register_portio_list(dev, iobase, ide_portio_list, bus, "ide");
2260
2261     if (iobase2) {
2262         isa_register_portio_list(dev, iobase2, ide_portio2_list, bus, "ide");
2263     }
2264 }
2265
2266 static bool is_identify_set(void *opaque, int version_id)
2267 {
2268     IDEState *s = opaque;
2269
2270     return s->identify_set != 0;
2271 }
2272
2273 static EndTransferFunc* transfer_end_table[] = {
2274         ide_sector_read,
2275         ide_sector_write,
2276         ide_transfer_stop,
2277         ide_atapi_cmd_reply_end,
2278         ide_atapi_cmd,
2279         ide_dummy_transfer_stop,
2280 };
2281
2282 static int transfer_end_table_idx(EndTransferFunc *fn)
2283 {
2284     int i;
2285
2286     for (i = 0; i < ARRAY_SIZE(transfer_end_table); i++)
2287         if (transfer_end_table[i] == fn)
2288             return i;
2289
2290     return -1;
2291 }
2292
2293 static int ide_drive_post_load(void *opaque, int version_id)
2294 {
2295     IDEState *s = opaque;
2296
2297     if (s->identify_set) {
2298         bdrv_set_enable_write_cache(s->bs, !!(s->identify_data[85] & (1 << 5)));
2299     }
2300     return 0;
2301 }
2302
2303 static int ide_drive_pio_post_load(void *opaque, int version_id)
2304 {
2305     IDEState *s = opaque;
2306
2307     if (s->end_transfer_fn_idx >= ARRAY_SIZE(transfer_end_table)) {
2308         return -EINVAL;
2309     }
2310     s->end_transfer_func = transfer_end_table[s->end_transfer_fn_idx];
2311     s->data_ptr = s->io_buffer + s->cur_io_buffer_offset;
2312     s->data_end = s->data_ptr + s->cur_io_buffer_len;
2313
2314     return 0;
2315 }
2316
2317 static void ide_drive_pio_pre_save(void *opaque)
2318 {
2319     IDEState *s = opaque;
2320     int idx;
2321
2322     s->cur_io_buffer_offset = s->data_ptr - s->io_buffer;
2323     s->cur_io_buffer_len = s->data_end - s->data_ptr;
2324
2325     idx = transfer_end_table_idx(s->end_transfer_func);
2326     if (idx == -1) {
2327         fprintf(stderr, "%s: invalid end_transfer_func for DRQ_STAT\n",
2328                         __func__);
2329         s->end_transfer_fn_idx = 2;
2330     } else {
2331         s->end_transfer_fn_idx = idx;
2332     }
2333 }
2334
2335 static bool ide_drive_pio_state_needed(void *opaque)
2336 {
2337     IDEState *s = opaque;
2338
2339     return ((s->status & DRQ_STAT) != 0)
2340         || (s->bus->error_status & IDE_RETRY_PIO);
2341 }
2342
2343 static bool ide_tray_state_needed(void *opaque)
2344 {
2345     IDEState *s = opaque;
2346
2347     return s->tray_open || s->tray_locked;
2348 }
2349
2350 static bool ide_atapi_gesn_needed(void *opaque)
2351 {
2352     IDEState *s = opaque;
2353
2354     return s->events.new_media || s->events.eject_request;
2355 }
2356
2357 static bool ide_error_needed(void *opaque)
2358 {
2359     IDEBus *bus = opaque;
2360
2361     return (bus->error_status != 0);
2362 }
2363
2364 /* Fields for GET_EVENT_STATUS_NOTIFICATION ATAPI command */
2365 static const VMStateDescription vmstate_ide_atapi_gesn_state = {
2366     .name ="ide_drive/atapi/gesn_state",
2367     .version_id = 1,
2368     .minimum_version_id = 1,
2369     .fields = (VMStateField[]) {
2370         VMSTATE_BOOL(events.new_media, IDEState),
2371         VMSTATE_BOOL(events.eject_request, IDEState),
2372         VMSTATE_END_OF_LIST()
2373     }
2374 };
2375
2376 static const VMStateDescription vmstate_ide_tray_state = {
2377     .name = "ide_drive/tray_state",
2378     .version_id = 1,
2379     .minimum_version_id = 1,
2380     .fields = (VMStateField[]) {
2381         VMSTATE_BOOL(tray_open, IDEState),
2382         VMSTATE_BOOL(tray_locked, IDEState),
2383         VMSTATE_END_OF_LIST()
2384     }
2385 };
2386
2387 static const VMStateDescription vmstate_ide_drive_pio_state = {
2388     .name = "ide_drive/pio_state",
2389     .version_id = 1,
2390     .minimum_version_id = 1,
2391     .pre_save = ide_drive_pio_pre_save,
2392     .post_load = ide_drive_pio_post_load,
2393     .fields = (VMStateField[]) {
2394         VMSTATE_INT32(req_nb_sectors, IDEState),
2395         VMSTATE_VARRAY_INT32(io_buffer, IDEState, io_buffer_total_len, 1,
2396                              vmstate_info_uint8, uint8_t),
2397         VMSTATE_INT32(cur_io_buffer_offset, IDEState),
2398         VMSTATE_INT32(cur_io_buffer_len, IDEState),
2399         VMSTATE_UINT8(end_transfer_fn_idx, IDEState),
2400         VMSTATE_INT32(elementary_transfer_size, IDEState),
2401         VMSTATE_INT32(packet_transfer_size, IDEState),
2402         VMSTATE_END_OF_LIST()
2403     }
2404 };
2405
2406 const VMStateDescription vmstate_ide_drive = {
2407     .name = "ide_drive",
2408     .version_id = 3,
2409     .minimum_version_id = 0,
2410     .post_load = ide_drive_post_load,
2411     .fields = (VMStateField[]) {
2412         VMSTATE_INT32(mult_sectors, IDEState),
2413         VMSTATE_INT32(identify_set, IDEState),
2414         VMSTATE_BUFFER_TEST(identify_data, IDEState, is_identify_set),
2415         VMSTATE_UINT8(feature, IDEState),
2416         VMSTATE_UINT8(error, IDEState),
2417         VMSTATE_UINT32(nsector, IDEState),
2418         VMSTATE_UINT8(sector, IDEState),
2419         VMSTATE_UINT8(lcyl, IDEState),
2420         VMSTATE_UINT8(hcyl, IDEState),
2421         VMSTATE_UINT8(hob_feature, IDEState),
2422         VMSTATE_UINT8(hob_sector, IDEState),
2423         VMSTATE_UINT8(hob_nsector, IDEState),
2424         VMSTATE_UINT8(hob_lcyl, IDEState),
2425         VMSTATE_UINT8(hob_hcyl, IDEState),
2426         VMSTATE_UINT8(select, IDEState),
2427         VMSTATE_UINT8(status, IDEState),
2428         VMSTATE_UINT8(lba48, IDEState),
2429         VMSTATE_UINT8(sense_key, IDEState),
2430         VMSTATE_UINT8(asc, IDEState),
2431         VMSTATE_UINT8_V(cdrom_changed, IDEState, 3),
2432         VMSTATE_END_OF_LIST()
2433     },
2434     .subsections = (VMStateSubsection []) {
2435         {
2436             .vmsd = &vmstate_ide_drive_pio_state,
2437             .needed = ide_drive_pio_state_needed,
2438         }, {
2439             .vmsd = &vmstate_ide_tray_state,
2440             .needed = ide_tray_state_needed,
2441         }, {
2442             .vmsd = &vmstate_ide_atapi_gesn_state,
2443             .needed = ide_atapi_gesn_needed,
2444         }, {
2445             /* empty */
2446         }
2447     }
2448 };
2449
2450 static const VMStateDescription vmstate_ide_error_status = {
2451     .name ="ide_bus/error",
2452     .version_id = 1,
2453     .minimum_version_id = 1,
2454     .fields = (VMStateField[]) {
2455         VMSTATE_INT32(error_status, IDEBus),
2456         VMSTATE_END_OF_LIST()
2457     }
2458 };
2459
2460 const VMStateDescription vmstate_ide_bus = {
2461     .name = "ide_bus",
2462     .version_id = 1,
2463     .minimum_version_id = 1,
2464     .fields = (VMStateField[]) {
2465         VMSTATE_UINT8(cmd, IDEBus),
2466         VMSTATE_UINT8(unit, IDEBus),
2467         VMSTATE_END_OF_LIST()
2468     },
2469     .subsections = (VMStateSubsection []) {
2470         {
2471             .vmsd = &vmstate_ide_error_status,
2472             .needed = ide_error_needed,
2473         }, {
2474             /* empty */
2475         }
2476     }
2477 };
2478
2479 void ide_drive_get(DriveInfo **hd, int max_bus)
2480 {
2481     int i;
2482
2483     if (drive_get_max_bus(IF_IDE) >= max_bus) {
2484         fprintf(stderr, "qemu: too many IDE bus: %d\n", max_bus);
2485         exit(1);
2486     }
2487
2488     for(i = 0; i < max_bus * MAX_IDE_DEVS; i++) {
2489         hd[i] = drive_get(IF_IDE, i / MAX_IDE_DEVS, i % MAX_IDE_DEVS);
2490     }
2491 }