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