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