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(VMSTOP_DISKFULL);
 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, 1);
 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     bdrv_get_geometry(s->bs, &nb_sectors);
 793     s->nb_sectors = nb_sectors;
 794
 795     /*
 796      * First indicate to the guest that a CD has been removed.  That's
 797      * done on the next command the guest sends us.
 798      *
 799      * Then we set SENSE_UNIT_ATTENTION, by which the guest will
 800      * detect a new CD in the drive.  See ide_atapi_cmd() for details.
 801      */
 802     s->cdrom_changed = 1;
 803     s->events.new_media = true;
 804     ide_set_irq(s->bus);
 805 }
 806
 807 static void ide_cmd_lba48_transform(IDEState *s, int lba48)
 808 {
 809     s->lba48 = lba48;
 810
 811     /* handle the 'magic' 0 nsector count conversion here. to avoid
 812      * fiddling with the rest of the read logic, we just store the
 813      * full sector count in ->nsector and ignore ->hob_nsector from now
 814      */
 815     if (!s->lba48) {
 816         if (!s->nsector)
 817             s->nsector = 256;
 818     } else {
 819         if (!s->nsector && !s->hob_nsector)
 820             s->nsector = 65536;
 821         else {
 822             int lo = s->nsector;
 823             int hi = s->hob_nsector;
 824
 825             s->nsector = (hi << 8) | lo;
 826         }
 827     }
 828 }
 829
 830 static void ide_clear_hob(IDEBus *bus)
 831 {
 832     /* any write clears HOB high bit of device control register */
 833     bus->ifs[0].select &= ~(1 << 7);
 834     bus->ifs[1].select &= ~(1 << 7);
 835 }
 836
 837 void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 838 {
 839     IDEBus *bus = opaque;
 840
 841 #ifdef DEBUG_IDE
 842     printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
 843 #endif
 844
 845     addr &= 7;
 846
 847     /* ignore writes to command block while busy with previous command */
 848     if (addr != 7 && (idebus_active_if(bus)->status & (BUSY_STAT|DRQ_STAT)))
 849         return;
 850
 851     switch(addr) {
 852     case 0:
 853         break;
 854     case 1:
 855         ide_clear_hob(bus);
 856         /* NOTE: data is written to the two drives */
 857         bus->ifs[0].hob_feature = bus->ifs[0].feature;
 858         bus->ifs[1].hob_feature = bus->ifs[1].feature;
 859         bus->ifs[0].feature = val;
 860         bus->ifs[1].feature = val;
 861         break;
 862     case 2:
 863         ide_clear_hob(bus);
 864         bus->ifs[0].hob_nsector = bus->ifs[0].nsector;
 865         bus->ifs[1].hob_nsector = bus->ifs[1].nsector;
 866         bus->ifs[0].nsector = val;
 867         bus->ifs[1].nsector = val;
 868         break;
 869     case 3:
 870         ide_clear_hob(bus);
 871         bus->ifs[0].hob_sector = bus->ifs[0].sector;
 872         bus->ifs[1].hob_sector = bus->ifs[1].sector;
 873         bus->ifs[0].sector = val;
 874         bus->ifs[1].sector = val;
 875         break;
 876     case 4:
 877         ide_clear_hob(bus);
 878         bus->ifs[0].hob_lcyl = bus->ifs[0].lcyl;
 879         bus->ifs[1].hob_lcyl = bus->ifs[1].lcyl;
 880         bus->ifs[0].lcyl = val;
 881         bus->ifs[1].lcyl = val;
 882         break;
 883     case 5:
 884         ide_clear_hob(bus);
 885         bus->ifs[0].hob_hcyl = bus->ifs[0].hcyl;
 886         bus->ifs[1].hob_hcyl = bus->ifs[1].hcyl;
 887         bus->ifs[0].hcyl = val;
 888         bus->ifs[1].hcyl = val;
 889         break;
 890     case 6:
 891         /* FIXME: HOB readback uses bit 7 */
 892         bus->ifs[0].select = (val & ~0x10) | 0xa0;
 893         bus->ifs[1].select = (val | 0x10) | 0xa0;
 894         /* select drive */
 895         bus->unit = (val >> 4) & 1;
 896         break;
 897     default:
 898     case 7:
 899         /* command */
 900         ide_exec_cmd(bus, val);
 901         break;
 902     }
 903 }
 904
 905 #define HD_OK (1u << IDE_HD)
 906 #define CD_OK (1u << IDE_CD)
 907 #define CFA_OK (1u << IDE_CFATA)
 908 #define HD_CFA_OK (HD_OK | CFA_OK)
 909 #define ALL_OK (HD_OK | CD_OK | CFA_OK)
 910
 911 /* See ACS-2 T13/2015-D Table B.2 Command codes */
 912 static const uint8_t ide_cmd_table[0x100] = {
 913     /* NOP not implemented, mandatory for CD */
 914     [CFA_REQ_EXT_ERROR_CODE]            = CFA_OK,
 915     [WIN_DSM]                           = ALL_OK,
 916     [WIN_DEVICE_RESET]                  = CD_OK,
 917     [WIN_RECAL]                         = HD_CFA_OK,
 918     [WIN_READ]                          = ALL_OK,
 919     [WIN_READ_ONCE]                     = ALL_OK,
 920     [WIN_READ_EXT]                      = HD_CFA_OK,
 921     [WIN_READDMA_EXT]                   = HD_CFA_OK,
 922     [WIN_READ_NATIVE_MAX_EXT]           = HD_CFA_OK,
 923     [WIN_MULTREAD_EXT]                  = HD_CFA_OK,
 924     [WIN_WRITE]                         = HD_CFA_OK,
 925     [WIN_WRITE_ONCE]                    = HD_CFA_OK,
 926     [WIN_WRITE_EXT]                     = HD_CFA_OK,
 927     [WIN_WRITEDMA_EXT]                  = HD_CFA_OK,
 928     [CFA_WRITE_SECT_WO_ERASE]           = CFA_OK,
 929     [WIN_MULTWRITE_EXT]                 = HD_CFA_OK,
 930     [WIN_WRITE_VERIFY]                  = HD_CFA_OK,
 931     [WIN_VERIFY]                        = HD_CFA_OK,
 932     [WIN_VERIFY_ONCE]                   = HD_CFA_OK,
 933     [WIN_VERIFY_EXT]                    = HD_CFA_OK,
 934     [WIN_SEEK]                          = HD_CFA_OK,
 935     [CFA_TRANSLATE_SECTOR]              = CFA_OK,
 936     [WIN_DIAGNOSE]                      = ALL_OK,
 937     [WIN_SPECIFY]                       = HD_CFA_OK,
 938     [WIN_STANDBYNOW2]                   = ALL_OK,
 939     [WIN_IDLEIMMEDIATE2]                = ALL_OK,
 940     [WIN_STANDBY2]                      = ALL_OK,
 941     [WIN_SETIDLE2]                      = ALL_OK,
 942     [WIN_CHECKPOWERMODE2]               = ALL_OK,
 943     [WIN_SLEEPNOW2]                     = ALL_OK,
 944     [WIN_PACKETCMD]                     = CD_OK,
 945     [WIN_PIDENTIFY]                     = CD_OK,
 946     [WIN_SMART]                         = HD_CFA_OK,
 947     [CFA_ACCESS_METADATA_STORAGE]       = CFA_OK,
 948     [CFA_ERASE_SECTORS]                 = CFA_OK,
 949     [WIN_MULTREAD]                      = HD_CFA_OK,
 950     [WIN_MULTWRITE]                     = HD_CFA_OK,
 951     [WIN_SETMULT]                       = HD_CFA_OK,
 952     [WIN_READDMA]                       = HD_CFA_OK,
 953     [WIN_READDMA_ONCE]                  = HD_CFA_OK,
 954     [WIN_WRITEDMA]                      = HD_CFA_OK,
 955     [WIN_WRITEDMA_ONCE]                 = HD_CFA_OK,
 956     [CFA_WRITE_MULTI_WO_ERASE]          = CFA_OK,
 957     [WIN_STANDBYNOW1]                   = ALL_OK,
 958     [WIN_IDLEIMMEDIATE]                 = ALL_OK,
 959     [WIN_STANDBY]                       = ALL_OK,
 960     [WIN_SETIDLE1]                      = ALL_OK,
 961     [WIN_CHECKPOWERMODE1]               = ALL_OK,
 962     [WIN_SLEEPNOW1]                     = ALL_OK,
 963     [WIN_FLUSH_CACHE]                   = ALL_OK,
 964     [WIN_FLUSH_CACHE_EXT]               = HD_CFA_OK,
 965     [WIN_IDENTIFY]                      = ALL_OK,
 966     [WIN_SETFEATURES]                   = ALL_OK,
 967     [IBM_SENSE_CONDITION]               = CFA_OK,
 968     [CFA_WEAR_LEVEL]                    = CFA_OK,
 969     [WIN_READ_NATIVE_MAX]               = ALL_OK,
 970 };
 971
 972 static bool ide_cmd_permitted(IDEState *s, uint32_t cmd)
 973 {
 974     return cmd < ARRAY_SIZE(ide_cmd_table)
 975         && (ide_cmd_table[cmd] & (1u << s->drive_kind));
 976 }
 977
 978 void ide_exec_cmd(IDEBus *bus, uint32_t val)
 979 {
 980     IDEState *s;
 981     int n;
 982     int lba48 = 0;
 983
 984 #if defined(DEBUG_IDE)
 985     printf("ide: CMD=%02x\n", val);
 986 #endif
 987     s = idebus_active_if(bus);
 988     /* ignore commands to non existant slave */
 989     if (s != bus->ifs && !s->bs)
 990         return;
 991
 992     /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
 993     if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET)
 994         return;
 995
 996     if (!ide_cmd_permitted(s, val)) {
 997         goto abort_cmd;
 998     }
 999
1000     switch(val) {
1001     case WIN_DSM:
1002         switch (s->feature) {
1003         case DSM_TRIM:
1004             if (!s->bs) {
1005                 goto abort_cmd;
1006             }
1007             ide_sector_start_dma(s, IDE_DMA_TRIM);
1008             break;
1009         default:
1010             goto abort_cmd;
1011         }
1012         break;
1013     case WIN_IDENTIFY:
1014         if (s->bs && s->drive_kind != IDE_CD) {
1015             if (s->drive_kind != IDE_CFATA)
1016                 ide_identify(s);
1017             else
1018                 ide_cfata_identify(s);
1019             s->status = READY_STAT | SEEK_STAT;
1020             ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1021         } else {
1022             if (s->drive_kind == IDE_CD) {
1023                 ide_set_signature(s);
1024             }
1025             ide_abort_command(s);
1026         }
1027         ide_set_irq(s->bus);
1028         break;
1029     case WIN_SPECIFY:
1030     case WIN_RECAL:
1031         s->error = 0;
1032         s->status = READY_STAT | SEEK_STAT;
1033         ide_set_irq(s->bus);
1034         break;
1035     case WIN_SETMULT:
1036         if (s->drive_kind == IDE_CFATA && s->nsector == 0) {
1037             /* Disable Read and Write Multiple */
1038             s->mult_sectors = 0;
1039             s->status = READY_STAT | SEEK_STAT;
1040         } else if ((s->nsector & 0xff) != 0 &&
1041             ((s->nsector & 0xff) > MAX_MULT_SECTORS ||
1042              (s->nsector & (s->nsector - 1)) != 0)) {
1043             ide_abort_command(s);
1044         } else {
1045             s->mult_sectors = s->nsector & 0xff;
1046             s->status = READY_STAT | SEEK_STAT;
1047         }
1048         ide_set_irq(s->bus);
1049         break;
1050     case WIN_VERIFY_EXT:
1051         lba48 = 1;
1052     case WIN_VERIFY:
1053     case WIN_VERIFY_ONCE:
1054         /* do sector number check ? */
1055         ide_cmd_lba48_transform(s, lba48);
1056         s->status = READY_STAT | SEEK_STAT;
1057         ide_set_irq(s->bus);
1058         break;
1059     case WIN_READ_EXT:
1060         lba48 = 1;
1061     case WIN_READ:
1062     case WIN_READ_ONCE:
1063         if (s->drive_kind == IDE_CD) {
1064             ide_set_signature(s); /* odd, but ATA4 8.27.5.2 requires it */
1065             goto abort_cmd;
1066         }
1067         ide_cmd_lba48_transform(s, lba48);
1068         s->req_nb_sectors = 1;
1069         ide_sector_read(s);
1070         break;
1071     case WIN_WRITE_EXT:
1072         lba48 = 1;
1073     case WIN_WRITE:
1074     case WIN_WRITE_ONCE:
1075     case CFA_WRITE_SECT_WO_ERASE:
1076     case WIN_WRITE_VERIFY:
1077         ide_cmd_lba48_transform(s, lba48);
1078         s->error = 0;
1079         s->status = SEEK_STAT | READY_STAT;
1080         s->req_nb_sectors = 1;
1081         ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
1082         s->media_changed = 1;
1083         break;
1084     case WIN_MULTREAD_EXT:
1085         lba48 = 1;
1086     case WIN_MULTREAD:
1087         if (!s->mult_sectors)
1088             goto abort_cmd;
1089         ide_cmd_lba48_transform(s, lba48);
1090         s->req_nb_sectors = s->mult_sectors;
1091         ide_sector_read(s);
1092         break;
1093     case WIN_MULTWRITE_EXT:
1094         lba48 = 1;
1095     case WIN_MULTWRITE:
1096     case CFA_WRITE_MULTI_WO_ERASE:
1097         if (!s->mult_sectors)
1098             goto abort_cmd;
1099         ide_cmd_lba48_transform(s, lba48);
1100         s->error = 0;
1101         s->status = SEEK_STAT | READY_STAT;
1102         s->req_nb_sectors = s->mult_sectors;
1103         n = s->nsector;
1104         if (n > s->req_nb_sectors)
1105             n = s->req_nb_sectors;
1106         ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
1107         s->media_changed = 1;
1108         break;
1109     case WIN_READDMA_EXT:
1110         lba48 = 1;
1111     case WIN_READDMA:
1112     case WIN_READDMA_ONCE:
1113         if (!s->bs)
1114             goto abort_cmd;
1115         ide_cmd_lba48_transform(s, lba48);
1116         ide_sector_start_dma(s, IDE_DMA_READ);
1117         break;
1118     case WIN_WRITEDMA_EXT:
1119         lba48 = 1;
1120     case WIN_WRITEDMA:
1121     case WIN_WRITEDMA_ONCE:
1122         if (!s->bs)
1123             goto abort_cmd;
1124         ide_cmd_lba48_transform(s, lba48);
1125         ide_sector_start_dma(s, IDE_DMA_WRITE);
1126         s->media_changed = 1;
1127         break;
1128     case WIN_READ_NATIVE_MAX_EXT:
1129         lba48 = 1;
1130     case WIN_READ_NATIVE_MAX:
1131         ide_cmd_lba48_transform(s, lba48);
1132         ide_set_sector(s, s->nb_sectors - 1);
1133         s->status = READY_STAT | SEEK_STAT;
1134         ide_set_irq(s->bus);
1135         break;
1136     case WIN_CHECKPOWERMODE1:
1137     case WIN_CHECKPOWERMODE2:
1138         s->error = 0;
1139         s->nsector = 0xff; /* device active or idle */
1140         s->status = READY_STAT | SEEK_STAT;
1141         ide_set_irq(s->bus);
1142         break;
1143     case WIN_SETFEATURES:
1144         if (!s->bs)
1145             goto abort_cmd;
1146         /* XXX: valid for CDROM ? */
1147         switch(s->feature) {
1148         case 0xcc: /* reverting to power-on defaults enable */
1149         case 0x66: /* reverting to power-on defaults disable */
1150         case 0x02: /* write cache enable */
1151         case 0x82: /* write cache disable */
1152         case 0xaa: /* read look-ahead enable */
1153         case 0x55: /* read look-ahead disable */
1154         case 0x05: /* set advanced power management mode */
1155         case 0x85: /* disable advanced power management mode */
1156         case 0x69: /* NOP */
1157         case 0x67: /* NOP */
1158         case 0x96: /* NOP */
1159         case 0x9a: /* NOP */
1160         case 0x42: /* enable Automatic Acoustic Mode */
1161         case 0xc2: /* disable Automatic Acoustic Mode */
1162             s->status = READY_STAT | SEEK_STAT;
1163             ide_set_irq(s->bus);
1164             break;
1165         case 0x03: { /* set transfer mode */
1166                 uint8_t val = s->nsector & 0x07;
1167             uint16_t *identify_data = (uint16_t *)s->identify_data;
1168
1169                 switch (s->nsector >> 3) {
1170                 case 0x00: /* pio default */
1171                 case 0x01: /* pio mode */
1172                         put_le16(identify_data + 62,0x07);
1173                         put_le16(identify_data + 63,0x07);
1174                         put_le16(identify_data + 88,0x3f);
1175                         break;
1176                 case 0x02: /* sigle word dma mode*/
1177                         put_le16(identify_data + 62,0x07 | (1 << (val + 8)));
1178                         put_le16(identify_data + 63,0x07);
1179                         put_le16(identify_data + 88,0x3f);
1180                         break;
1181                 case 0x04: /* mdma mode */
1182                         put_le16(identify_data + 62,0x07);
1183                         put_le16(identify_data + 63,0x07 | (1 << (val + 8)));
1184                         put_le16(identify_data + 88,0x3f);
1185                         break;
1186                 case 0x08: /* udma mode */
1187                         put_le16(identify_data + 62,0x07);
1188                         put_le16(identify_data + 63,0x07);
1189                         put_le16(identify_data + 88,0x3f | (1 << (val + 8)));
1190                         break;
1191                 default:
1192                         goto abort_cmd;
1193                 }
1194             s->status = READY_STAT | SEEK_STAT;
1195             ide_set_irq(s->bus);
1196             break;
1197         }
1198         default:
1199             goto abort_cmd;
1200         }
1201         break;
1202     case WIN_FLUSH_CACHE:
1203     case WIN_FLUSH_CACHE_EXT:
1204         ide_flush_cache(s);
1205         break;
1206     case WIN_STANDBY:
1207     case WIN_STANDBY2:
1208     case WIN_STANDBYNOW1:
1209     case WIN_STANDBYNOW2:
1210     case WIN_IDLEIMMEDIATE:
1211     case WIN_IDLEIMMEDIATE2:
1212     case WIN_SETIDLE1:
1213     case WIN_SETIDLE2:
1214     case WIN_SLEEPNOW1:
1215     case WIN_SLEEPNOW2:
1216         s->status = READY_STAT;
1217         ide_set_irq(s->bus);
1218         break;
1219     case WIN_SEEK:
1220         /* XXX: Check that seek is within bounds */
1221         s->status = READY_STAT | SEEK_STAT;
1222         ide_set_irq(s->bus);
1223         break;
1224         /* ATAPI commands */
1225     case WIN_PIDENTIFY:
1226         ide_atapi_identify(s);
1227         s->status = READY_STAT | SEEK_STAT;
1228         ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1229         ide_set_irq(s->bus);
1230         break;
1231     case WIN_DIAGNOSE:
1232         ide_set_signature(s);
1233         if (s->drive_kind == IDE_CD)
1234             s->status = 0; /* ATAPI spec (v6) section 9.10 defines packet
1235                             * devices to return a clear status register
1236                             * with READY_STAT *not* set. */
1237         else
1238             s->status = READY_STAT | SEEK_STAT;
1239         s->error = 0x01; /* Device 0 passed, Device 1 passed or not
1240                           * present.
1241                           */
1242         ide_set_irq(s->bus);
1243         break;
1244     case WIN_DEVICE_RESET:
1245         ide_set_signature(s);
1246         s->status = 0x00; /* NOTE: READY is _not_ set */
1247         s->error = 0x01;
1248         break;
1249     case WIN_PACKETCMD:
1250         /* overlapping commands not supported */
1251         if (s->feature & 0x02)
1252             goto abort_cmd;
1253         s->status = READY_STAT | SEEK_STAT;
1254         s->atapi_dma = s->feature & 1;
1255         s->nsector = 1;
1256         ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
1257                            ide_atapi_cmd);
1258         break;
1259     /* CF-ATA commands */
1260     case CFA_REQ_EXT_ERROR_CODE:
1261         s->error = 0x09;    /* miscellaneous error */
1262         s->status = READY_STAT | SEEK_STAT;
1263         ide_set_irq(s->bus);
1264         break;
1265     case CFA_ERASE_SECTORS:
1266     case CFA_WEAR_LEVEL:
1267         if (val == CFA_WEAR_LEVEL)
1268             s->nsector = 0;
1269         if (val == CFA_ERASE_SECTORS)
1270             s->media_changed = 1;
1271         s->error = 0x00;
1272         s->status = READY_STAT | SEEK_STAT;
1273         ide_set_irq(s->bus);
1274         break;
1275     case CFA_TRANSLATE_SECTOR:
1276         s->error = 0x00;
1277         s->status = READY_STAT | SEEK_STAT;
1278         memset(s->io_buffer, 0, 0x200);
1279         s->io_buffer[0x00] = s->hcyl;                   /* Cyl MSB */
1280         s->io_buffer[0x01] = s->lcyl;                   /* Cyl LSB */
1281         s->io_buffer[0x02] = s->select;                 /* Head */
1282         s->io_buffer[0x03] = s->sector;                 /* Sector */
1283         s->io_buffer[0x04] = ide_get_sector(s) >> 16;   /* LBA MSB */
1284         s->io_buffer[0x05] = ide_get_sector(s) >> 8;    /* LBA */
1285         s->io_buffer[0x06] = ide_get_sector(s) >> 0;    /* LBA LSB */
1286         s->io_buffer[0x13] = 0x00;                              /* Erase flag */
1287         s->io_buffer[0x18] = 0x00;                              /* Hot count */
1288         s->io_buffer[0x19] = 0x00;                              /* Hot count */
1289         s->io_buffer[0x1a] = 0x01;                              /* Hot count */
1290         ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1291         ide_set_irq(s->bus);
1292         break;
1293     case CFA_ACCESS_METADATA_STORAGE:
1294         switch (s->feature) {
1295         case 0x02:      /* Inquiry Metadata Storage */
1296             ide_cfata_metadata_inquiry(s);
1297             break;
1298         case 0x03:      /* Read Metadata Storage */
1299             ide_cfata_metadata_read(s);
1300             break;
1301         case 0x04:      /* Write Metadata Storage */
1302             ide_cfata_metadata_write(s);
1303             break;
1304         default:
1305             goto abort_cmd;
1306         }
1307         ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1308         s->status = 0x00; /* NOTE: READY is _not_ set */
1309         ide_set_irq(s->bus);
1310         break;
1311     case IBM_SENSE_CONDITION:
1312         switch (s->feature) {
1313         case 0x01:  /* sense temperature in device */
1314             s->nsector = 0x50;      /* +20 C */
1315             break;
1316         default:
1317             goto abort_cmd;
1318         }
1319         s->status = READY_STAT | SEEK_STAT;
1320         ide_set_irq(s->bus);
1321         break;
1322
1323     case WIN_SMART:
1324         if (s->hcyl != 0xc2 || s->lcyl != 0x4f)
1325                 goto abort_cmd;
1326         if (!s->smart_enabled && s->feature != SMART_ENABLE)
1327                 goto abort_cmd;
1328         switch (s->feature) {
1329         case SMART_DISABLE:
1330                 s->smart_enabled = 0;
1331                 s->status = READY_STAT | SEEK_STAT;
1332                 ide_set_irq(s->bus);
1333                 break;
1334         case SMART_ENABLE:
1335                 s->smart_enabled = 1;
1336                 s->status = READY_STAT | SEEK_STAT;
1337                 ide_set_irq(s->bus);
1338                 break;
1339         case SMART_ATTR_AUTOSAVE:
1340                 switch (s->sector) {
1341                 case 0x00:
1342                 s->smart_autosave = 0;
1343                 break;
1344                 case 0xf1:
1345                 s->smart_autosave = 1;
1346                 break;
1347                 default:
1348                 goto abort_cmd;
1349                 }
1350                 s->status = READY_STAT | SEEK_STAT;
1351                 ide_set_irq(s->bus);
1352                 break;
1353         case SMART_STATUS:
1354                 if (!s->smart_errors) {
1355                 s->hcyl = 0xc2;
1356                 s->lcyl = 0x4f;
1357                 } else {
1358                 s->hcyl = 0x2c;
1359                 s->lcyl = 0xf4;
1360                 }
1361                 s->status = READY_STAT | SEEK_STAT;
1362                 ide_set_irq(s->bus);
1363                 break;
1364         case SMART_READ_THRESH:
1365                 memset(s->io_buffer, 0, 0x200);
1366                 s->io_buffer[0] = 0x01; /* smart struct version */
1367                 for (n=0; n<30; n++) {
1368                 if (smart_attributes[n][0] == 0)
1369                         break;
1370                 s->io_buffer[2+0+(n*12)] = smart_attributes[n][0];
1371                 s->io_buffer[2+1+(n*12)] = smart_attributes[n][11];
1372                 }
1373                 for (n=0; n<511; n++) /* checksum */
1374                 s->io_buffer[511] += s->io_buffer[n];
1375                 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1376                 s->status = READY_STAT | SEEK_STAT;
1377                 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1378                 ide_set_irq(s->bus);
1379                 break;
1380         case SMART_READ_DATA:
1381                 memset(s->io_buffer, 0, 0x200);
1382                 s->io_buffer[0] = 0x01; /* smart struct version */
1383                 for (n=0; n<30; n++) {
1384                     if (smart_attributes[n][0] == 0) {
1385                         break;
1386                     }
1387                     int i;
1388                     for(i = 0; i < 11; i++) {
1389                         s->io_buffer[2+i+(n*12)] = smart_attributes[n][i];
1390                     }
1391                 }
1392                 s->io_buffer[362] = 0x02 | (s->smart_autosave?0x80:0x00);
1393                 if (s->smart_selftest_count == 0) {
1394                 s->io_buffer[363] = 0;
1395                 } else {
1396                 s->io_buffer[363] =
1397                         s->smart_selftest_data[3 +
1398                                            (s->smart_selftest_count - 1) *
1399                                            24];
1400                 }
1401                 s->io_buffer[364] = 0x20;
1402                 s->io_buffer[365] = 0x01;
1403                 /* offline data collection capacity: execute + self-test*/
1404                 s->io_buffer[367] = (1<<4 | 1<<3 | 1);
1405                 s->io_buffer[368] = 0x03; /* smart capability (1) */
1406                 s->io_buffer[369] = 0x00; /* smart capability (2) */
1407                 s->io_buffer[370] = 0x01; /* error logging supported */
1408                 s->io_buffer[372] = 0x02; /* minutes for poll short test */
1409                 s->io_buffer[373] = 0x36; /* minutes for poll ext test */
1410                 s->io_buffer[374] = 0x01; /* minutes for poll conveyance */
1411
1412                 for (n=0; n<511; n++)
1413                 s->io_buffer[511] += s->io_buffer[n];
1414                 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1415                 s->status = READY_STAT | SEEK_STAT;
1416                 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1417                 ide_set_irq(s->bus);
1418                 break;
1419         case SMART_READ_LOG:
1420                 switch (s->sector) {
1421                 case 0x01: /* summary smart error log */
1422                 memset(s->io_buffer, 0, 0x200);
1423                 s->io_buffer[0] = 0x01;
1424                 s->io_buffer[1] = 0x00; /* no error entries */
1425                 s->io_buffer[452] = s->smart_errors & 0xff;
1426                 s->io_buffer[453] = (s->smart_errors & 0xff00) >> 8;
1427
1428                 for (n=0; n<511; n++)
1429                         s->io_buffer[511] += s->io_buffer[n];
1430                 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1431                 break;
1432                 case 0x06: /* smart self test log */
1433                 memset(s->io_buffer, 0, 0x200);
1434                 s->io_buffer[0] = 0x01;
1435                 if (s->smart_selftest_count == 0) {
1436                         s->io_buffer[508] = 0;
1437                 } else {
1438                         s->io_buffer[508] = s->smart_selftest_count;
1439                         for (n=2; n<506; n++)
1440                         s->io_buffer[n] = s->smart_selftest_data[n];
1441                 }
1442                 for (n=0; n<511; n++)
1443                         s->io_buffer[511] += s->io_buffer[n];
1444                 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1445                 break;
1446                 default:
1447                 goto abort_cmd;
1448                 }
1449                 s->status = READY_STAT | SEEK_STAT;
1450                 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1451                 ide_set_irq(s->bus);
1452                 break;
1453         case SMART_EXECUTE_OFFLINE:
1454                 switch (s->sector) {
1455                 case 0: /* off-line routine */
1456                 case 1: /* short self test */
1457                 case 2: /* extended self test */
1458                 s->smart_selftest_count++;
1459                 if(s->smart_selftest_count > 21)
1460                         s->smart_selftest_count = 0;
1461                 n = 2 + (s->smart_selftest_count - 1) * 24;
1462                 s->smart_selftest_data[n] = s->sector;
1463                 s->smart_selftest_data[n+1] = 0x00; /* OK and finished */
1464                 s->smart_selftest_data[n+2] = 0x34; /* hour count lsb */
1465                 s->smart_selftest_data[n+3] = 0x12; /* hour count msb */
1466                 s->status = READY_STAT | SEEK_STAT;
1467                 ide_set_irq(s->bus);
1468                 break;
1469                 default:
1470                 goto abort_cmd;
1471                 }
1472                 break;
1473         default:
1474                 goto abort_cmd;
1475         }
1476         break;
1477     default:
1478         /* should not be reachable */
1479     abort_cmd:
1480         ide_abort_command(s);
1481         ide_set_irq(s->bus);
1482         break;
1483     }
1484 }
1485
1486 uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
1487 {
1488     IDEBus *bus = opaque;
1489     IDEState *s = idebus_active_if(bus);
1490     uint32_t addr;
1491     int ret, hob;
1492
1493     addr = addr1 & 7;
1494     /* FIXME: HOB readback uses bit 7, but it's always set right now */
1495     //hob = s->select & (1 << 7);
1496     hob = 0;
1497     switch(addr) {
1498     case 0:
1499         ret = 0xff;
1500         break;
1501     case 1:
1502         if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1503             (s != bus->ifs && !s->bs))
1504             ret = 0;
1505         else if (!hob)
1506             ret = s->error;
1507         else
1508             ret = s->hob_feature;
1509         break;
1510     case 2:
1511         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1512             ret = 0;
1513         else if (!hob)
1514             ret = s->nsector & 0xff;
1515         else
1516             ret = s->hob_nsector;
1517         break;
1518     case 3:
1519         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1520             ret = 0;
1521         else if (!hob)
1522             ret = s->sector;
1523         else
1524             ret = s->hob_sector;
1525         break;
1526     case 4:
1527         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1528             ret = 0;
1529         else if (!hob)
1530             ret = s->lcyl;
1531         else
1532             ret = s->hob_lcyl;
1533         break;
1534     case 5:
1535         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1536             ret = 0;
1537         else if (!hob)
1538             ret = s->hcyl;
1539         else
1540             ret = s->hob_hcyl;
1541         break;
1542     case 6:
1543         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1544             ret = 0;
1545         else
1546             ret = s->select;
1547         break;
1548     default:
1549     case 7:
1550         if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1551             (s != bus->ifs && !s->bs))
1552             ret = 0;
1553         else
1554             ret = s->status;
1555         qemu_irq_lower(bus->irq);
1556         break;
1557     }
1558 #ifdef DEBUG_IDE
1559     printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
1560 #endif
1561     return ret;
1562 }
1563
1564 uint32_t ide_status_read(void *opaque, uint32_t addr)
1565 {
1566     IDEBus *bus = opaque;
1567     IDEState *s = idebus_active_if(bus);
1568     int ret;
1569
1570     if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1571         (s != bus->ifs && !s->bs))
1572         ret = 0;
1573     else
1574         ret = s->status;
1575 #ifdef DEBUG_IDE
1576     printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
1577 #endif
1578     return ret;
1579 }
1580
1581 void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
1582 {
1583     IDEBus *bus = opaque;
1584     IDEState *s;
1585     int i;
1586
1587 #ifdef DEBUG_IDE
1588     printf("ide: write control addr=0x%x val=%02x\n", addr, val);
1589 #endif
1590     /* common for both drives */
1591     if (!(bus->cmd & IDE_CMD_RESET) &&
1592         (val & IDE_CMD_RESET)) {
1593         /* reset low to high */
1594         for(i = 0;i < 2; i++) {
1595             s = &bus->ifs[i];
1596             s->status = BUSY_STAT | SEEK_STAT;
1597             s->error = 0x01;
1598         }
1599     } else if ((bus->cmd & IDE_CMD_RESET) &&
1600                !(val & IDE_CMD_RESET)) {
1601         /* high to low */
1602         for(i = 0;i < 2; i++) {
1603             s = &bus->ifs[i];
1604             if (s->drive_kind == IDE_CD)
1605                 s->status = 0x00; /* NOTE: READY is _not_ set */
1606             else
1607                 s->status = READY_STAT | SEEK_STAT;
1608             ide_set_signature(s);
1609         }
1610     }
1611
1612     bus->cmd = val;
1613 }
1614
1615 /*
1616  * Returns true if the running PIO transfer is a PIO out (i.e. data is
1617  * transferred from the device to the guest), false if it's a PIO in
1618  */
1619 static bool ide_is_pio_out(IDEState *s)
1620 {
1621     if (s->end_transfer_func == ide_sector_write ||
1622         s->end_transfer_func == ide_atapi_cmd) {
1623         return false;
1624     } else if (s->end_transfer_func == ide_sector_read ||
1625                s->end_transfer_func == ide_transfer_stop ||
1626                s->end_transfer_func == ide_atapi_cmd_reply_end ||
1627                s->end_transfer_func == ide_dummy_transfer_stop) {
1628         return true;
1629     }
1630
1631     abort();
1632 }
1633
1634 void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
1635 {
1636     IDEBus *bus = opaque;
1637     IDEState *s = idebus_active_if(bus);
1638     uint8_t *p;
1639
1640     /* PIO data access allowed only when DRQ bit is set. The result of a write
1641      * during PIO out is indeterminate, just ignore it. */
1642     if (!(s->status & DRQ_STAT) || ide_is_pio_out(s)) {
1643         return;
1644     }
1645
1646     p = s->data_ptr;
1647     *(uint16_t *)p = le16_to_cpu(val);
1648     p += 2;
1649     s->data_ptr = p;
1650     if (p >= s->data_end)
1651         s->end_transfer_func(s);
1652 }
1653
1654 uint32_t ide_data_readw(void *opaque, uint32_t addr)
1655 {
1656     IDEBus *bus = opaque;
1657     IDEState *s = idebus_active_if(bus);
1658     uint8_t *p;
1659     int ret;
1660
1661     /* PIO data access allowed only when DRQ bit is set. The result of a read
1662      * during PIO in is indeterminate, return 0 and don't move forward. */
1663     if (!(s->status & DRQ_STAT) || !ide_is_pio_out(s)) {
1664         return 0;
1665     }
1666
1667     p = s->data_ptr;
1668     ret = cpu_to_le16(*(uint16_t *)p);
1669     p += 2;
1670     s->data_ptr = p;
1671     if (p >= s->data_end)
1672         s->end_transfer_func(s);
1673     return ret;
1674 }
1675
1676 void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
1677 {
1678     IDEBus *bus = opaque;
1679     IDEState *s = idebus_active_if(bus);
1680     uint8_t *p;
1681
1682     /* PIO data access allowed only when DRQ bit is set. The result of a write
1683      * during PIO out is indeterminate, just ignore it. */
1684     if (!(s->status & DRQ_STAT) || ide_is_pio_out(s)) {
1685         return;
1686     }
1687
1688     p = s->data_ptr;
1689     *(uint32_t *)p = le32_to_cpu(val);
1690     p += 4;
1691     s->data_ptr = p;
1692     if (p >= s->data_end)
1693         s->end_transfer_func(s);
1694 }
1695
1696 uint32_t ide_data_readl(void *opaque, uint32_t addr)
1697 {
1698     IDEBus *bus = opaque;
1699     IDEState *s = idebus_active_if(bus);
1700     uint8_t *p;
1701     int ret;
1702
1703     /* PIO data access allowed only when DRQ bit is set. The result of a read
1704      * during PIO in is indeterminate, return 0 and don't move forward. */
1705     if (!(s->status & DRQ_STAT) || !ide_is_pio_out(s)) {
1706         return 0;
1707     }
1708
1709     p = s->data_ptr;
1710     ret = cpu_to_le32(*(uint32_t *)p);
1711     p += 4;
1712     s->data_ptr = p;
1713     if (p >= s->data_end)
1714         s->end_transfer_func(s);
1715     return ret;
1716 }
1717
1718 static void ide_dummy_transfer_stop(IDEState *s)
1719 {
1720     s->data_ptr = s->io_buffer;
1721     s->data_end = s->io_buffer;
1722     s->io_buffer[0] = 0xff;
1723     s->io_buffer[1] = 0xff;
1724     s->io_buffer[2] = 0xff;
1725     s->io_buffer[3] = 0xff;
1726 }
1727
1728 static void ide_reset(IDEState *s)
1729 {
1730 #ifdef DEBUG_IDE
1731     printf("ide: reset\n");
1732 #endif
1733     if (s->drive_kind == IDE_CFATA)
1734         s->mult_sectors = 0;
1735     else
1736         s->mult_sectors = MAX_MULT_SECTORS;
1737     /* ide regs */
1738     s->feature = 0;
1739     s->error = 0;
1740     s->nsector = 0;
1741     s->sector = 0;
1742     s->lcyl = 0;
1743     s->hcyl = 0;
1744
1745     /* lba48 */
1746     s->hob_feature = 0;
1747     s->hob_sector = 0;
1748     s->hob_nsector = 0;
1749     s->hob_lcyl = 0;
1750     s->hob_hcyl = 0;
1751
1752     s->select = 0xa0;
1753     s->status = READY_STAT | SEEK_STAT;
1754
1755     s->lba48 = 0;
1756
1757     /* ATAPI specific */
1758     s->sense_key = 0;
1759     s->asc = 0;
1760     s->cdrom_changed = 0;
1761     s->packet_transfer_size = 0;
1762     s->elementary_transfer_size = 0;
1763     s->io_buffer_index = 0;
1764     s->cd_sector_size = 0;
1765     s->atapi_dma = 0;
1766     /* ATA DMA state */
1767     s->io_buffer_size = 0;
1768     s->req_nb_sectors = 0;
1769
1770     ide_set_signature(s);
1771     /* init the transfer handler so that 0xffff is returned on data
1772        accesses */
1773     s->end_transfer_func = ide_dummy_transfer_stop;
1774     ide_dummy_transfer_stop(s);
1775     s->media_changed = 0;
1776 }
1777
1778 void ide_bus_reset(IDEBus *bus)
1779 {
1780     bus->unit = 0;
1781     bus->cmd = 0;
1782     ide_reset(&bus->ifs[0]);
1783     ide_reset(&bus->ifs[1]);
1784     ide_clear_hob(bus);
1785
1786     /* pending async DMA */
1787     if (bus->dma->aiocb) {
1788 #ifdef DEBUG_AIO
1789         printf("aio_cancel\n");
1790 #endif
1791         bdrv_aio_cancel(bus->dma->aiocb);
1792         bus->dma->aiocb = NULL;
1793     }
1794
1795     /* reset dma provider too */
1796     bus->dma->ops->reset(bus->dma);
1797 }
1798
1799 static bool ide_cd_is_tray_open(void *opaque)
1800 {
1801     return ((IDEState *)opaque)->tray_open;
1802 }
1803
1804 static bool ide_cd_is_medium_locked(void *opaque)
1805 {
1806     return ((IDEState *)opaque)->tray_locked;
1807 }
1808
1809 static const BlockDevOps ide_cd_block_ops = {
1810     .change_media_cb = ide_cd_change_cb,
1811     .is_tray_open = ide_cd_is_tray_open,
1812     .is_medium_locked = ide_cd_is_medium_locked,
1813 };
1814
1815 int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind,
1816                    const char *version, const char *serial)
1817 {
1818     int cylinders, heads, secs;
1819     uint64_t nb_sectors;
1820
1821     s->bs = bs;
1822     s->drive_kind = kind;
1823
1824     bdrv_get_geometry(bs, &nb_sectors);
1825     bdrv_guess_geometry(bs, &cylinders, &heads, &secs);
1826     if (cylinders < 1 || cylinders > 16383) {
1827         error_report("cyls must be between 1 and 16383");
1828         return -1;
1829     }
1830     if (heads < 1 || heads > 16) {
1831         error_report("heads must be between 1 and 16");
1832         return -1;
1833     }
1834     if (secs < 1 || secs > 63) {
1835         error_report("secs must be between 1 and 63");
1836         return -1;
1837     }
1838     s->cylinders = cylinders;
1839     s->heads = heads;
1840     s->sectors = secs;
1841     s->nb_sectors = nb_sectors;
1842     /* The SMART values should be preserved across power cycles
1843        but they aren't.  */
1844     s->smart_enabled = 1;
1845     s->smart_autosave = 1;
1846     s->smart_errors = 0;
1847     s->smart_selftest_count = 0;
1848     if (kind == IDE_CD) {
1849         bdrv_set_dev_ops(bs, &ide_cd_block_ops, s);
1850         bdrv_set_buffer_alignment(bs, 2048);
1851     } else {
1852         if (!bdrv_is_inserted(s->bs)) {
1853             error_report("Device needs media, but drive is empty");
1854             return -1;
1855         }
1856         if (bdrv_is_read_only(bs)) {
1857             error_report("Can't use a read-only drive");
1858             return -1;
1859         }
1860     }
1861     if (serial) {
1862         strncpy(s->drive_serial_str, serial, sizeof(s->drive_serial_str));
1863     } else {
1864         snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),
1865                  "QM%05d", s->drive_serial);
1866     }
1867     if (version) {
1868         pstrcpy(s->version, sizeof(s->version), version);
1869     } else {
1870         pstrcpy(s->version, sizeof(s->version), QEMU_VERSION);
1871     }
1872
1873     ide_reset(s);
1874     return 0;
1875 }
1876
1877 static void ide_init1(IDEBus *bus, int unit)
1878 {
1879     static int drive_serial = 1;
1880     IDEState *s = &bus->ifs[unit];
1881
1882     s->bus = bus;
1883     s->unit = unit;
1884     s->drive_serial = drive_serial++;
1885     /* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
1886     s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
1887     s->io_buffer = qemu_memalign(2048, s->io_buffer_total_len);
1888     memset(s->io_buffer, 0, s->io_buffer_total_len);
1889
1890     s->smart_selftest_data = qemu_blockalign(s->bs, 512);
1891     memset(s->smart_selftest_data, 0, 512);
1892
1893     s->sector_write_timer = qemu_new_timer_ns(vm_clock,
1894                                            ide_sector_write_timer_cb, s);
1895 }
1896
1897 static void ide_nop_start(IDEDMA *dma, IDEState *s,
1898                           BlockDriverCompletionFunc *cb)
1899 {
1900 }
1901
1902 static int ide_nop(IDEDMA *dma)
1903 {
1904     return 0;
1905 }
1906
1907 static int ide_nop_int(IDEDMA *dma, int x)
1908 {
1909     return 0;
1910 }
1911
1912 static void ide_nop_restart(void *opaque, int x, int y)
1913 {
1914 }
1915
1916 static const IDEDMAOps ide_dma_nop_ops = {
1917     .start_dma      = ide_nop_start,
1918     .start_transfer = ide_nop,
1919     .prepare_buf    = ide_nop_int,
1920     .rw_buf         = ide_nop_int,
1921     .set_unit       = ide_nop_int,
1922     .add_status     = ide_nop_int,
1923     .set_inactive   = ide_nop,
1924     .restart_cb     = ide_nop_restart,
1925     .reset          = ide_nop,
1926 };
1927
1928 static IDEDMA ide_dma_nop = {
1929     .ops = &ide_dma_nop_ops,
1930     .aiocb = NULL,
1931 };
1932
1933 void ide_init2(IDEBus *bus, qemu_irq irq)
1934 {
1935     int i;
1936
1937     for(i = 0; i < 2; i++) {
1938         ide_init1(bus, i);
1939         ide_reset(&bus->ifs[i]);
1940     }
1941     bus->irq = irq;
1942     bus->dma = &ide_dma_nop;
1943 }
1944
1945 /* TODO convert users to qdev and remove */
1946 void ide_init2_with_non_qdev_drives(IDEBus *bus, DriveInfo *hd0,
1947                                     DriveInfo *hd1, qemu_irq irq)
1948 {
1949     int i;
1950     DriveInfo *dinfo;
1951
1952     for(i = 0; i < 2; i++) {
1953         dinfo = i == 0 ? hd0 : hd1;
1954         ide_init1(bus, i);
1955         if (dinfo) {
1956             if (ide_init_drive(&bus->ifs[i], dinfo->bdrv,
1957                                dinfo->media_cd ? IDE_CD : IDE_HD, NULL,
1958                                *dinfo->serial ? dinfo->serial : NULL) < 0) {
1959                 error_report("Can't set up IDE drive %s", dinfo->id);
1960                 exit(1);
1961             }
1962             bdrv_attach_dev_nofail(dinfo->bdrv, &bus->ifs[i]);
1963         } else {
1964             ide_reset(&bus->ifs[i]);
1965         }
1966     }
1967     bus->irq = irq;
1968     bus->dma = &ide_dma_nop;
1969 }
1970
1971 void ide_init_ioport(IDEBus *bus, int iobase, int iobase2)
1972 {
1973     register_ioport_write(iobase, 8, 1, ide_ioport_write, bus);
1974     register_ioport_read(iobase, 8, 1, ide_ioport_read, bus);
1975     if (iobase2) {
1976         register_ioport_read(iobase2, 1, 1, ide_status_read, bus);
1977         register_ioport_write(iobase2, 1, 1, ide_cmd_write, bus);
1978     }
1979
1980     /* data ports */
1981     register_ioport_write(iobase, 2, 2, ide_data_writew, bus);
1982     register_ioport_read(iobase, 2, 2, ide_data_readw, bus);
1983     register_ioport_write(iobase, 4, 4, ide_data_writel, bus);
1984     register_ioport_read(iobase, 4, 4, ide_data_readl, bus);
1985 }
1986
1987 static bool is_identify_set(void *opaque, int version_id)
1988 {
1989     IDEState *s = opaque;
1990
1991     return s->identify_set != 0;
1992 }
1993
1994 static EndTransferFunc* transfer_end_table[] = {
1995         ide_sector_read,
1996         ide_sector_write,
1997         ide_transfer_stop,
1998         ide_atapi_cmd_reply_end,
1999         ide_atapi_cmd,
2000         ide_dummy_transfer_stop,
2001 };
2002
2003 static int transfer_end_table_idx(EndTransferFunc *fn)
2004 {
2005     int i;
2006
2007     for (i = 0; i < ARRAY_SIZE(transfer_end_table); i++)
2008         if (transfer_end_table[i] == fn)
2009             return i;
2010
2011     return -1;
2012 }
2013
2014 static int ide_drive_post_load(void *opaque, int version_id)
2015 {
2016     IDEState *s = opaque;
2017
2018     if (version_id < 3) {
2019         if (s->sense_key == SENSE_UNIT_ATTENTION &&
2020             s->asc == ASC_MEDIUM_MAY_HAVE_CHANGED) {
2021             s->cdrom_changed = 1;
2022         }
2023     }
2024     return 0;
2025 }
2026
2027 static int ide_drive_pio_post_load(void *opaque, int version_id)
2028 {
2029     IDEState *s = opaque;
2030
2031     if (s->end_transfer_fn_idx > ARRAY_SIZE(transfer_end_table)) {
2032         return -EINVAL;
2033     }
2034     s->end_transfer_func = transfer_end_table[s->end_transfer_fn_idx];
2035     s->data_ptr = s->io_buffer + s->cur_io_buffer_offset;
2036     s->data_end = s->data_ptr + s->cur_io_buffer_len;
2037
2038     return 0;
2039 }
2040
2041 static void ide_drive_pio_pre_save(void *opaque)
2042 {
2043     IDEState *s = opaque;
2044     int idx;
2045
2046     s->cur_io_buffer_offset = s->data_ptr - s->io_buffer;
2047     s->cur_io_buffer_len = s->data_end - s->data_ptr;
2048
2049     idx = transfer_end_table_idx(s->end_transfer_func);
2050     if (idx == -1) {
2051         fprintf(stderr, "%s: invalid end_transfer_func for DRQ_STAT\n",
2052                         __func__);
2053         s->end_transfer_fn_idx = 2;
2054     } else {
2055         s->end_transfer_fn_idx = idx;
2056     }
2057 }
2058
2059 static bool ide_drive_pio_state_needed(void *opaque)
2060 {
2061     IDEState *s = opaque;
2062
2063     return ((s->status & DRQ_STAT) != 0)
2064         || (s->bus->error_status & BM_STATUS_PIO_RETRY);
2065 }
2066
2067 static int ide_tray_state_post_load(void *opaque, int version_id)
2068 {
2069     IDEState *s = opaque;
2070
2071     bdrv_eject(s->bs, s->tray_open);
2072     bdrv_lock_medium(s->bs, s->tray_locked);
2073     return 0;
2074 }
2075
2076 static bool ide_tray_state_needed(void *opaque)
2077 {
2078     IDEState *s = opaque;
2079
2080     return s->tray_open || s->tray_locked;
2081 }
2082
2083 static bool ide_atapi_gesn_needed(void *opaque)
2084 {
2085     IDEState *s = opaque;
2086
2087     return s->events.new_media || s->events.eject_request;
2088 }
2089
2090 static bool ide_error_needed(void *opaque)
2091 {
2092     IDEBus *bus = opaque;
2093
2094     return (bus->error_status != 0);
2095 }
2096
2097 /* Fields for GET_EVENT_STATUS_NOTIFICATION ATAPI command */
2098 static const VMStateDescription vmstate_ide_atapi_gesn_state = {
2099     .name ="ide_drive/atapi/gesn_state",
2100     .version_id = 1,
2101     .minimum_version_id = 1,
2102     .minimum_version_id_old = 1,
2103     .fields = (VMStateField []) {
2104         VMSTATE_BOOL(events.new_media, IDEState),
2105         VMSTATE_BOOL(events.eject_request, IDEState),
2106         VMSTATE_END_OF_LIST()
2107     }
2108 };
2109
2110 static const VMStateDescription vmstate_ide_tray_state = {
2111     .name = "ide_drive/tray_state",
2112     .version_id = 1,
2113     .minimum_version_id = 1,
2114     .minimum_version_id_old = 1,
2115     .post_load = ide_tray_state_post_load,
2116     .fields = (VMStateField[]) {
2117         VMSTATE_BOOL(tray_open, IDEState),
2118         VMSTATE_BOOL(tray_locked, IDEState),
2119         VMSTATE_END_OF_LIST()
2120     }
2121 };
2122
2123 static const VMStateDescription vmstate_ide_drive_pio_state = {
2124     .name = "ide_drive/pio_state",
2125     .version_id = 1,
2126     .minimum_version_id = 1,
2127     .minimum_version_id_old = 1,
2128     .pre_save = ide_drive_pio_pre_save,
2129     .post_load = ide_drive_pio_post_load,
2130     .fields      = (VMStateField []) {
2131         VMSTATE_INT32(req_nb_sectors, IDEState),
2132         VMSTATE_VARRAY_INT32(io_buffer, IDEState, io_buffer_total_len, 1,
2133                              vmstate_info_uint8, uint8_t),
2134         VMSTATE_INT32(cur_io_buffer_offset, IDEState),
2135         VMSTATE_INT32(cur_io_buffer_len, IDEState),
2136         VMSTATE_UINT8(end_transfer_fn_idx, IDEState),
2137         VMSTATE_INT32(elementary_transfer_size, IDEState),
2138         VMSTATE_INT32(packet_transfer_size, IDEState),
2139         VMSTATE_END_OF_LIST()
2140     }
2141 };
2142
2143 const VMStateDescription vmstate_ide_drive = {
2144     .name = "ide_drive",
2145     .version_id = 3,
2146     .minimum_version_id = 0,
2147     .minimum_version_id_old = 0,
2148     .post_load = ide_drive_post_load,
2149     .fields      = (VMStateField []) {
2150         VMSTATE_INT32(mult_sectors, IDEState),
2151         VMSTATE_INT32(identify_set, IDEState),
2152         VMSTATE_BUFFER_TEST(identify_data, IDEState, is_identify_set),
2153         VMSTATE_UINT8(feature, IDEState),
2154         VMSTATE_UINT8(error, IDEState),
2155         VMSTATE_UINT32(nsector, IDEState),
2156         VMSTATE_UINT8(sector, IDEState),
2157         VMSTATE_UINT8(lcyl, IDEState),
2158         VMSTATE_UINT8(hcyl, IDEState),
2159         VMSTATE_UINT8(hob_feature, IDEState),
2160         VMSTATE_UINT8(hob_sector, IDEState),
2161         VMSTATE_UINT8(hob_nsector, IDEState),
2162         VMSTATE_UINT8(hob_lcyl, IDEState),
2163         VMSTATE_UINT8(hob_hcyl, IDEState),
2164         VMSTATE_UINT8(select, IDEState),
2165         VMSTATE_UINT8(status, IDEState),
2166         VMSTATE_UINT8(lba48, IDEState),
2167         VMSTATE_UINT8(sense_key, IDEState),
2168         VMSTATE_UINT8(asc, IDEState),
2169         VMSTATE_UINT8_V(cdrom_changed, IDEState, 3),
2170         VMSTATE_END_OF_LIST()
2171     },
2172     .subsections = (VMStateSubsection []) {
2173         {
2174             .vmsd = &vmstate_ide_drive_pio_state,
2175             .needed = ide_drive_pio_state_needed,
2176         }, {
2177             .vmsd = &vmstate_ide_tray_state,
2178             .needed = ide_tray_state_needed,
2179         }, {
2180             .vmsd = &vmstate_ide_atapi_gesn_state,
2181             .needed = ide_atapi_gesn_needed,
2182         }, {
2183             /* empty */
2184         }
2185     }
2186 };
2187
2188 static const VMStateDescription vmstate_ide_error_status = {
2189     .name ="ide_bus/error",
2190     .version_id = 1,
2191     .minimum_version_id = 1,
2192     .minimum_version_id_old = 1,
2193     .fields = (VMStateField []) {
2194         VMSTATE_INT32(error_status, IDEBus),
2195         VMSTATE_END_OF_LIST()
2196     }
2197 };
2198
2199 const VMStateDescription vmstate_ide_bus = {
2200     .name = "ide_bus",
2201     .version_id = 1,
2202     .minimum_version_id = 1,
2203     .minimum_version_id_old = 1,
2204     .fields      = (VMStateField []) {
2205         VMSTATE_UINT8(cmd, IDEBus),
2206         VMSTATE_UINT8(unit, IDEBus),
2207         VMSTATE_END_OF_LIST()
2208     },
2209     .subsections = (VMStateSubsection []) {
2210         {
2211             .vmsd = &vmstate_ide_error_status,
2212             .needed = ide_error_needed,
2213         }, {
2214             /* empty */
2215         }
2216     }
2217 };
2218
2219 void ide_drive_get(DriveInfo **hd, int max_bus)
2220 {
2221     int i;
2222
2223     if (drive_get_max_bus(IF_IDE) >= max_bus) {
2224         fprintf(stderr, "qemu: too many IDE bus: %d\n", max_bus);
2225         exit(1);
2226     }
2227
2228     for(i = 0; i < max_bus * MAX_IDE_DEVS; i++) {
2229         hd[i] = drive_get(IF_IDE, i / MAX_IDE_DEVS, i % MAX_IDE_DEVS);
2230     }
2231 }