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 <hw/scsi.h>
  29 #include "qemu-error.h"
  30 #include "qemu-timer.h"
  31 #include "sysemu.h"
  32 #include "dma.h"
  33 #include "blockdev.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 /* XXX: DVDs that could fit on a CD will be reported as a CD */
  60 static inline int media_present(IDEState *s)
  61 {
  62     return (s->nb_sectors > 0);
  63 }
  64
  65 static inline int media_is_dvd(IDEState *s)
  66 {
  67     return (media_present(s) && s->nb_sectors > CD_MAX_SECTORS);
  68 }
  69
  70 static inline int media_is_cd(IDEState *s)
  71 {
  72     return (media_present(s) && s->nb_sectors <= CD_MAX_SECTORS);
  73 }
  74
  75 static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);
  76 static int ide_handle_rw_error(IDEState *s, int error, int op);
  77
  78 static void padstr(char *str, const char *src, int len)
  79 {
  80     int i, v;
  81     for(i = 0; i < len; i++) {
  82         if (*src)
  83             v = *src++;
  84         else
  85             v = ' ';
  86         str[i^1] = v;
  87     }
  88 }
  89
  90 static void padstr8(uint8_t *buf, int buf_size, const char *src)
  91 {
  92     int i;
  93     for(i = 0; i < buf_size; i++) {
  94         if (*src)
  95             buf[i] = *src++;
  96         else
  97             buf[i] = ' ';
  98     }
  99 }
 100
 101 static void put_le16(uint16_t *p, unsigned int v)
 102 {
 103     *p = cpu_to_le16(v);
 104 }
 105
 106 static void ide_identify(IDEState *s)
 107 {
 108     uint16_t *p;
 109     unsigned int oldsize;
 110     IDEDevice *dev;
 111
 112     if (s->identify_set) {
 113         memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
 114         return;
 115     }
 116
 117     memset(s->io_buffer, 0, 512);
 118     p = (uint16_t *)s->io_buffer;
 119     put_le16(p + 0, 0x0040);
 120     put_le16(p + 1, s->cylinders);
 121     put_le16(p + 3, s->heads);
 122     put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
 123     put_le16(p + 5, 512); /* XXX: retired, remove ? */
 124     put_le16(p + 6, s->sectors);
 125     padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
 126     put_le16(p + 20, 3); /* XXX: retired, remove ? */
 127     put_le16(p + 21, 512); /* cache size in sectors */
 128     put_le16(p + 22, 4); /* ecc bytes */
 129     padstr((char *)(p + 23), s->version, 8); /* firmware version */
 130     padstr((char *)(p + 27), "QEMU HARDDISK", 40); /* model */
 131 #if MAX_MULT_SECTORS > 1
 132     put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
 133 #endif
 134     put_le16(p + 48, 1); /* dword I/O */
 135     put_le16(p + 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
 136     put_le16(p + 51, 0x200); /* PIO transfer cycle */
 137     put_le16(p + 52, 0x200); /* DMA transfer cycle */
 138     put_le16(p + 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
 139     put_le16(p + 54, s->cylinders);
 140     put_le16(p + 55, s->heads);
 141     put_le16(p + 56, s->sectors);
 142     oldsize = s->cylinders * s->heads * s->sectors;
 143     put_le16(p + 57, oldsize);
 144     put_le16(p + 58, oldsize >> 16);
 145     if (s->mult_sectors)
 146         put_le16(p + 59, 0x100 | s->mult_sectors);
 147     put_le16(p + 60, s->nb_sectors);
 148     put_le16(p + 61, s->nb_sectors >> 16);
 149     put_le16(p + 62, 0x07); /* single word dma0-2 supported */
 150     put_le16(p + 63, 0x07); /* mdma0-2 supported */
 151     put_le16(p + 64, 0x03); /* pio3-4 supported */
 152     put_le16(p + 65, 120);
 153     put_le16(p + 66, 120);
 154     put_le16(p + 67, 120);
 155     put_le16(p + 68, 120);
 156
 157     if (s->ncq_queues) {
 158         put_le16(p + 75, s->ncq_queues - 1);
 159         /* NCQ supported */
 160         put_le16(p + 76, (1 << 8));
 161     }
 162
 163     put_le16(p + 80, 0xf0); /* ata3 -> ata6 supported */
 164     put_le16(p + 81, 0x16); /* conforms to ata5 */
 165     /* 14=NOP supported, 5=WCACHE supported, 0=SMART supported */
 166     put_le16(p + 82, (1 << 14) | (1 << 5) | 1);
 167     /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
 168     put_le16(p + 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
 169     /* 14=set to 1, 1=SMART self test, 0=SMART error logging */
 170     put_le16(p + 84, (1 << 14) | 0);
 171     /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
 172     if (bdrv_enable_write_cache(s->bs))
 173          put_le16(p + 85, (1 << 14) | (1 << 5) | 1);
 174     else
 175          put_le16(p + 85, (1 << 14) | 1);
 176     /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
 177     put_le16(p + 86, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
 178     /* 14=set to 1, 1=smart self test, 0=smart error logging */
 179     put_le16(p + 87, (1 << 14) | 0);
 180     put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
 181     put_le16(p + 93, 1 | (1 << 14) | 0x2000);
 182     put_le16(p + 100, s->nb_sectors);
 183     put_le16(p + 101, s->nb_sectors >> 16);
 184     put_le16(p + 102, s->nb_sectors >> 32);
 185     put_le16(p + 103, s->nb_sectors >> 48);
 186     dev = s->unit ? s->bus->slave : s->bus->master;
 187     if (dev && dev->conf.physical_block_size)
 188         put_le16(p + 106, 0x6000 | get_physical_block_exp(&dev->conf));
 189
 190     memcpy(s->identify_data, p, sizeof(s->identify_data));
 191     s->identify_set = 1;
 192 }
 193
 194 static void ide_atapi_identify(IDEState *s)
 195 {
 196     uint16_t *p;
 197
 198     if (s->identify_set) {
 199         memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
 200         return;
 201     }
 202
 203     memset(s->io_buffer, 0, 512);
 204     p = (uint16_t *)s->io_buffer;
 205     /* Removable CDROM, 50us response, 12 byte packets */
 206     put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
 207     padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
 208     put_le16(p + 20, 3); /* buffer type */
 209     put_le16(p + 21, 512); /* cache size in sectors */
 210     put_le16(p + 22, 4); /* ecc bytes */
 211     padstr((char *)(p + 23), s->version, 8); /* firmware version */
 212     padstr((char *)(p + 27), "QEMU DVD-ROM", 40); /* model */
 213     put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
 214 #ifdef USE_DMA_CDROM
 215     put_le16(p + 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
 216     put_le16(p + 53, 7); /* words 64-70, 54-58, 88 valid */
 217     put_le16(p + 62, 7);  /* single word dma0-2 supported */
 218     put_le16(p + 63, 7);  /* mdma0-2 supported */
 219 #else
 220     put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
 221     put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
 222     put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
 223 #endif
 224     put_le16(p + 64, 3); /* pio3-4 supported */
 225     put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
 226     put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
 227     put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
 228     put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
 229
 230     put_le16(p + 71, 30); /* in ns */
 231     put_le16(p + 72, 30); /* in ns */
 232
 233     if (s->ncq_queues) {
 234         put_le16(p + 75, s->ncq_queues - 1);
 235         /* NCQ supported */
 236         put_le16(p + 76, (1 << 8));
 237     }
 238
 239     put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
 240 #ifdef USE_DMA_CDROM
 241     put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
 242 #endif
 243     memcpy(s->identify_data, p, sizeof(s->identify_data));
 244     s->identify_set = 1;
 245 }
 246
 247 static void ide_cfata_identify(IDEState *s)
 248 {
 249     uint16_t *p;
 250     uint32_t cur_sec;
 251
 252     p = (uint16_t *) s->identify_data;
 253     if (s->identify_set)
 254         goto fill_buffer;
 255
 256     memset(p, 0, sizeof(s->identify_data));
 257
 258     cur_sec = s->cylinders * s->heads * s->sectors;
 259
 260     put_le16(p + 0, 0x848a);                    /* CF Storage Card signature */
 261     put_le16(p + 1, s->cylinders);              /* Default cylinders */
 262     put_le16(p + 3, s->heads);                  /* Default heads */
 263     put_le16(p + 6, s->sectors);                /* Default sectors per track */
 264     put_le16(p + 7, s->nb_sectors >> 16);       /* Sectors per card */
 265     put_le16(p + 8, s->nb_sectors);             /* Sectors per card */
 266     padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
 267     put_le16(p + 22, 0x0004);                   /* ECC bytes */
 268     padstr((char *) (p + 23), s->version, 8);   /* Firmware Revision */
 269     padstr((char *) (p + 27), "QEMU MICRODRIVE", 40);/* Model number */
 270 #if MAX_MULT_SECTORS > 1
 271     put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
 272 #else
 273     put_le16(p + 47, 0x0000);
 274 #endif
 275     put_le16(p + 49, 0x0f00);                   /* Capabilities */
 276     put_le16(p + 51, 0x0002);                   /* PIO cycle timing mode */
 277     put_le16(p + 52, 0x0001);                   /* DMA cycle timing mode */
 278     put_le16(p + 53, 0x0003);                   /* Translation params valid */
 279     put_le16(p + 54, s->cylinders);             /* Current cylinders */
 280     put_le16(p + 55, s->heads);                 /* Current heads */
 281     put_le16(p + 56, s->sectors);               /* Current sectors */
 282     put_le16(p + 57, cur_sec);                  /* Current capacity */
 283     put_le16(p + 58, cur_sec >> 16);            /* Current capacity */
 284     if (s->mult_sectors)                        /* Multiple sector setting */
 285         put_le16(p + 59, 0x100 | s->mult_sectors);
 286     put_le16(p + 60, s->nb_sectors);            /* Total LBA sectors */
 287     put_le16(p + 61, s->nb_sectors >> 16);      /* Total LBA sectors */
 288     put_le16(p + 63, 0x0203);                   /* Multiword DMA capability */
 289     put_le16(p + 64, 0x0001);                   /* Flow Control PIO support */
 290     put_le16(p + 65, 0x0096);                   /* Min. Multiword DMA cycle */
 291     put_le16(p + 66, 0x0096);                   /* Rec. Multiword DMA cycle */
 292     put_le16(p + 68, 0x00b4);                   /* Min. PIO cycle time */
 293     put_le16(p + 82, 0x400c);                   /* Command Set supported */
 294     put_le16(p + 83, 0x7068);                   /* Command Set supported */
 295     put_le16(p + 84, 0x4000);                   /* Features supported */
 296     put_le16(p + 85, 0x000c);                   /* Command Set enabled */
 297     put_le16(p + 86, 0x7044);                   /* Command Set enabled */
 298     put_le16(p + 87, 0x4000);                   /* Features enabled */
 299     put_le16(p + 91, 0x4060);                   /* Current APM level */
 300     put_le16(p + 129, 0x0002);                  /* Current features option */
 301     put_le16(p + 130, 0x0005);                  /* Reassigned sectors */
 302     put_le16(p + 131, 0x0001);                  /* Initial power mode */
 303     put_le16(p + 132, 0x0000);                  /* User signature */
 304     put_le16(p + 160, 0x8100);                  /* Power requirement */
 305     put_le16(p + 161, 0x8001);                  /* CF command set */
 306
 307     s->identify_set = 1;
 308
 309 fill_buffer:
 310     memcpy(s->io_buffer, p, sizeof(s->identify_data));
 311 }
 312
 313 static void ide_set_signature(IDEState *s)
 314 {
 315     s->select &= 0xf0; /* clear head */
 316     /* put signature */
 317     s->nsector = 1;
 318     s->sector = 1;
 319     if (s->drive_kind == IDE_CD) {
 320         s->lcyl = 0x14;
 321         s->hcyl = 0xeb;
 322     } else if (s->bs) {
 323         s->lcyl = 0;
 324         s->hcyl = 0;
 325     } else {
 326         s->lcyl = 0xff;
 327         s->hcyl = 0xff;
 328     }
 329 }
 330
 331 static inline void ide_abort_command(IDEState *s)
 332 {
 333     s->status = READY_STAT | ERR_STAT;
 334     s->error = ABRT_ERR;
 335 }
 336
 337 /* prepare data transfer and tell what to do after */
 338 static void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
 339                                EndTransferFunc *end_transfer_func)
 340 {
 341     s->end_transfer_func = end_transfer_func;
 342     s->data_ptr = buf;
 343     s->data_end = buf + size;
 344     if (!(s->status & ERR_STAT)) {
 345         s->status |= DRQ_STAT;
 346     }
 347     s->bus->dma->ops->start_transfer(s->bus->dma);
 348 }
 349
 350 static void ide_transfer_stop(IDEState *s)
 351 {
 352     s->end_transfer_func = ide_transfer_stop;
 353     s->data_ptr = s->io_buffer;
 354     s->data_end = s->io_buffer;
 355     s->status &= ~DRQ_STAT;
 356 }
 357
 358 int64_t ide_get_sector(IDEState *s)
 359 {
 360     int64_t sector_num;
 361     if (s->select & 0x40) {
 362         /* lba */
 363         if (!s->lba48) {
 364             sector_num = ((s->select & 0x0f) << 24) | (s->hcyl << 16) |
 365                 (s->lcyl << 8) | s->sector;
 366         } else {
 367             sector_num = ((int64_t)s->hob_hcyl << 40) |
 368                 ((int64_t) s->hob_lcyl << 32) |
 369                 ((int64_t) s->hob_sector << 24) |
 370                 ((int64_t) s->hcyl << 16) |
 371                 ((int64_t) s->lcyl << 8) | s->sector;
 372         }
 373     } else {
 374         sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
 375             (s->select & 0x0f) * s->sectors + (s->sector - 1);
 376     }
 377     return sector_num;
 378 }
 379
 380 void ide_set_sector(IDEState *s, int64_t sector_num)
 381 {
 382     unsigned int cyl, r;
 383     if (s->select & 0x40) {
 384         if (!s->lba48) {
 385             s->select = (s->select & 0xf0) | (sector_num >> 24);
 386             s->hcyl = (sector_num >> 16);
 387             s->lcyl = (sector_num >> 8);
 388             s->sector = (sector_num);
 389         } else {
 390             s->sector = sector_num;
 391             s->lcyl = sector_num >> 8;
 392             s->hcyl = sector_num >> 16;
 393             s->hob_sector = sector_num >> 24;
 394             s->hob_lcyl = sector_num >> 32;
 395             s->hob_hcyl = sector_num >> 40;
 396         }
 397     } else {
 398         cyl = sector_num / (s->heads * s->sectors);
 399         r = sector_num % (s->heads * s->sectors);
 400         s->hcyl = cyl >> 8;
 401         s->lcyl = cyl;
 402         s->select = (s->select & 0xf0) | ((r / s->sectors) & 0x0f);
 403         s->sector = (r % s->sectors) + 1;
 404     }
 405 }
 406
 407 static void ide_rw_error(IDEState *s) {
 408     ide_abort_command(s);
 409     ide_set_irq(s->bus);
 410 }
 411
 412 void ide_sector_read(IDEState *s)
 413 {
 414     int64_t sector_num;
 415     int ret, n;
 416
 417     s->status = READY_STAT | SEEK_STAT;
 418     s->error = 0; /* not needed by IDE spec, but needed by Windows */
 419     sector_num = ide_get_sector(s);
 420     n = s->nsector;
 421     if (n == 0) {
 422         /* no more sector to read from disk */
 423         ide_transfer_stop(s);
 424     } else {
 425 #if defined(DEBUG_IDE)
 426         printf("read sector=%" PRId64 "\n", sector_num);
 427 #endif
 428         if (n > s->req_nb_sectors)
 429             n = s->req_nb_sectors;
 430         ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
 431         if (ret != 0) {
 432             if (ide_handle_rw_error(s, -ret,
 433                 BM_STATUS_PIO_RETRY | BM_STATUS_RETRY_READ))
 434             {
 435                 return;
 436             }
 437         }
 438         ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_read);
 439         ide_set_irq(s->bus);
 440         ide_set_sector(s, sector_num + n);
 441         s->nsector -= n;
 442     }
 443 }
 444
 445 static void dma_buf_commit(IDEState *s, int is_write)
 446 {
 447     qemu_sglist_destroy(&s->sg);
 448 }
 449
 450 static void ide_set_inactive(IDEState *s)
 451 {
 452     s->bus->dma->aiocb = NULL;
 453     s->bus->dma->ops->set_inactive(s->bus->dma);
 454 }
 455
 456 void ide_dma_error(IDEState *s)
 457 {
 458     ide_transfer_stop(s);
 459     s->error = ABRT_ERR;
 460     s->status = READY_STAT | ERR_STAT;
 461     ide_set_inactive(s);
 462     s->bus->dma->ops->add_status(s->bus->dma, BM_STATUS_INT);
 463     ide_set_irq(s->bus);
 464 }
 465
 466 static int ide_handle_rw_error(IDEState *s, int error, int op)
 467 {
 468     int is_read = (op & BM_STATUS_RETRY_READ);
 469     BlockErrorAction action = bdrv_get_on_error(s->bs, is_read);
 470
 471     if (action == BLOCK_ERR_IGNORE) {
 472         bdrv_mon_event(s->bs, BDRV_ACTION_IGNORE, is_read);
 473         return 0;
 474     }
 475
 476     if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
 477             || action == BLOCK_ERR_STOP_ANY) {
 478         s->bus->dma->ops->set_unit(s->bus->dma, s->unit);
 479         s->bus->dma->ops->add_status(s->bus->dma, op);
 480         bdrv_mon_event(s->bs, BDRV_ACTION_STOP, is_read);
 481         vm_stop(VMSTOP_DISKFULL);
 482     } else {
 483         if (op & BM_STATUS_DMA_RETRY) {
 484             dma_buf_commit(s, 0);
 485             ide_dma_error(s);
 486         } else {
 487             ide_rw_error(s);
 488         }
 489         bdrv_mon_event(s->bs, BDRV_ACTION_REPORT, is_read);
 490     }
 491
 492     return 1;
 493 }
 494
 495 void ide_dma_cb(void *opaque, int ret)
 496 {
 497     IDEState *s = opaque;
 498     int n;
 499     int64_t sector_num;
 500
 501 handle_rw_error:
 502     if (ret < 0) {
 503         int op = BM_STATUS_DMA_RETRY;
 504
 505         if (s->is_read)
 506             op |= BM_STATUS_RETRY_READ;
 507         if (ide_handle_rw_error(s, -ret, op)) {
 508             return;
 509         }
 510     }
 511
 512     n = s->io_buffer_size >> 9;
 513     sector_num = ide_get_sector(s);
 514     if (n > 0) {
 515         dma_buf_commit(s, s->is_read);
 516         sector_num += n;
 517         ide_set_sector(s, sector_num);
 518         s->nsector -= n;
 519     }
 520
 521     /* end of transfer ? */
 522     if (s->nsector == 0) {
 523         s->status = READY_STAT | SEEK_STAT;
 524         ide_set_irq(s->bus);
 525         goto eot;
 526     }
 527
 528     /* launch next transfer */
 529     n = s->nsector;
 530     s->io_buffer_index = 0;
 531     s->io_buffer_size = n * 512;
 532     if (s->bus->dma->ops->prepare_buf(s->bus->dma, s->is_read) == 0)
 533         goto eot;
 534
 535 #ifdef DEBUG_AIO
 536     printf("ide_dma_cb: sector_num=%" PRId64 " n=%d, is_read=%d\n",
 537            sector_num, n, s->is_read);
 538 #endif
 539
 540     if (s->is_read) {
 541         s->bus->dma->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num,
 542                                            ide_dma_cb, s);
 543     } else {
 544         s->bus->dma->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num,
 545                                             ide_dma_cb, s);
 546     }
 547
 548     if (!s->bus->dma->aiocb) {
 549         ret = -1;
 550         goto handle_rw_error;
 551     }
 552     return;
 553
 554 eot:
 555    s->bus->dma->ops->add_status(s->bus->dma, BM_STATUS_INT);
 556    ide_set_inactive(s);
 557 }
 558
 559 static void ide_sector_start_dma(IDEState *s, int is_read)
 560 {
 561     s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
 562     s->io_buffer_index = 0;
 563     s->io_buffer_size = 0;
 564     s->is_read = is_read;
 565     s->bus->dma->ops->start_dma(s->bus->dma, s, ide_dma_cb);
 566 }
 567
 568 static void ide_sector_write_timer_cb(void *opaque)
 569 {
 570     IDEState *s = opaque;
 571     ide_set_irq(s->bus);
 572 }
 573
 574 void ide_sector_write(IDEState *s)
 575 {
 576     int64_t sector_num;
 577     int ret, n, n1;
 578
 579     s->status = READY_STAT | SEEK_STAT;
 580     sector_num = ide_get_sector(s);
 581 #if defined(DEBUG_IDE)
 582     printf("write sector=%" PRId64 "\n", sector_num);
 583 #endif
 584     n = s->nsector;
 585     if (n > s->req_nb_sectors)
 586         n = s->req_nb_sectors;
 587     ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
 588
 589     if (ret != 0) {
 590         if (ide_handle_rw_error(s, -ret, BM_STATUS_PIO_RETRY))
 591             return;
 592     }
 593
 594     s->nsector -= n;
 595     if (s->nsector == 0) {
 596         /* no more sectors to write */
 597         ide_transfer_stop(s);
 598     } else {
 599         n1 = s->nsector;
 600         if (n1 > s->req_nb_sectors)
 601             n1 = s->req_nb_sectors;
 602         ide_transfer_start(s, s->io_buffer, 512 * n1, ide_sector_write);
 603     }
 604     ide_set_sector(s, sector_num + n);
 605
 606     if (win2k_install_hack && ((++s->irq_count % 16) == 0)) {
 607         /* It seems there is a bug in the Windows 2000 installer HDD
 608            IDE driver which fills the disk with empty logs when the
 609            IDE write IRQ comes too early. This hack tries to correct
 610            that at the expense of slower write performances. Use this
 611            option _only_ to install Windows 2000. You must disable it
 612            for normal use. */
 613         qemu_mod_timer(s->sector_write_timer,
 614                        qemu_get_clock_ns(vm_clock) + (get_ticks_per_sec() / 1000));
 615     } else {
 616         ide_set_irq(s->bus);
 617     }
 618 }
 619
 620 void ide_atapi_cmd_ok(IDEState *s)
 621 {
 622     s->error = 0;
 623     s->status = READY_STAT | SEEK_STAT;
 624     s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 625     ide_set_irq(s->bus);
 626 }
 627
 628 void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc)
 629 {
 630 #ifdef DEBUG_IDE_ATAPI
 631     printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key, asc);
 632 #endif
 633     s->error = sense_key << 4;
 634     s->status = READY_STAT | ERR_STAT;
 635     s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 636     s->sense_key = sense_key;
 637     s->asc = asc;
 638     ide_set_irq(s->bus);
 639 }
 640
 641 static void ide_atapi_cmd_check_status(IDEState *s)
 642 {
 643 #ifdef DEBUG_IDE_ATAPI
 644     printf("atapi_cmd_check_status\n");
 645 #endif
 646     s->error = MC_ERR | (SENSE_UNIT_ATTENTION << 4);
 647     s->status = ERR_STAT;
 648     s->nsector = 0;
 649     ide_set_irq(s->bus);
 650 }
 651
 652 static void ide_flush_cb(void *opaque, int ret)
 653 {
 654     IDEState *s = opaque;
 655
 656     if (ret < 0) {
 657         /* XXX: What sector number to set here? */
 658         if (ide_handle_rw_error(s, -ret, BM_STATUS_RETRY_FLUSH)) {
 659             return;
 660         }
 661     }
 662
 663     s->status = READY_STAT | SEEK_STAT;
 664     ide_set_irq(s->bus);
 665 }
 666
 667 void ide_flush_cache(IDEState *s)
 668 {
 669     BlockDriverAIOCB *acb;
 670
 671     if (s->bs == NULL) {
 672         ide_flush_cb(s, 0);
 673         return;
 674     }
 675
 676     acb = bdrv_aio_flush(s->bs, ide_flush_cb, s);
 677     if (acb == NULL) {
 678         ide_flush_cb(s, -EIO);
 679     }
 680 }
 681
 682 static inline void cpu_to_ube16(uint8_t *buf, int val)
 683 {
 684     buf[0] = val >> 8;
 685     buf[1] = val & 0xff;
 686 }
 687
 688 static inline void cpu_to_ube32(uint8_t *buf, unsigned int val)
 689 {
 690     buf[0] = val >> 24;
 691     buf[1] = val >> 16;
 692     buf[2] = val >> 8;
 693     buf[3] = val & 0xff;
 694 }
 695
 696 static inline int ube16_to_cpu(const uint8_t *buf)
 697 {
 698     return (buf[0] << 8) | buf[1];
 699 }
 700
 701 static inline int ube32_to_cpu(const uint8_t *buf)
 702 {
 703     return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 704 }
 705
 706 static void lba_to_msf(uint8_t *buf, int lba)
 707 {
 708     lba += 150;
 709     buf[0] = (lba / 75) / 60;
 710     buf[1] = (lba / 75) % 60;
 711     buf[2] = lba % 75;
 712 }
 713
 714 static void cd_data_to_raw(uint8_t *buf, int lba)
 715 {
 716     /* sync bytes */
 717     buf[0] = 0x00;
 718     memset(buf + 1, 0xff, 10);
 719     buf[11] = 0x00;
 720     buf += 12;
 721     /* MSF */
 722     lba_to_msf(buf, lba);
 723     buf[3] = 0x01; /* mode 1 data */
 724     buf += 4;
 725     /* data */
 726     buf += 2048;
 727     /* XXX: ECC not computed */
 728     memset(buf, 0, 288);
 729 }
 730
 731 static int cd_read_sector(BlockDriverState *bs, int lba, uint8_t *buf,
 732                            int sector_size)
 733 {
 734     int ret;
 735
 736     switch(sector_size) {
 737     case 2048:
 738         ret = bdrv_read(bs, (int64_t)lba << 2, buf, 4);
 739         break;
 740     case 2352:
 741         ret = bdrv_read(bs, (int64_t)lba << 2, buf + 16, 4);
 742         if (ret < 0)
 743             return ret;
 744         cd_data_to_raw(buf, lba);
 745         break;
 746     default:
 747         ret = -EIO;
 748         break;
 749     }
 750     return ret;
 751 }
 752
 753 void ide_atapi_io_error(IDEState *s, int ret)
 754 {
 755     /* XXX: handle more errors */
 756     if (ret == -ENOMEDIUM) {
 757         ide_atapi_cmd_error(s, SENSE_NOT_READY,
 758                             ASC_MEDIUM_NOT_PRESENT);
 759     } else {
 760         ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
 761                             ASC_LOGICAL_BLOCK_OOR);
 762     }
 763 }
 764
 765 /* The whole ATAPI transfer logic is handled in this function */
 766 static void ide_atapi_cmd_reply_end(IDEState *s)
 767 {
 768     int byte_count_limit, size, ret;
 769 #ifdef DEBUG_IDE_ATAPI
 770     printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
 771            s->packet_transfer_size,
 772            s->elementary_transfer_size,
 773            s->io_buffer_index);
 774 #endif
 775     if (s->packet_transfer_size <= 0) {
 776         /* end of transfer */
 777         ide_transfer_stop(s);
 778         s->status = READY_STAT | SEEK_STAT;
 779         s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 780         ide_set_irq(s->bus);
 781 #ifdef DEBUG_IDE_ATAPI
 782         printf("status=0x%x\n", s->status);
 783 #endif
 784     } else {
 785         /* see if a new sector must be read */
 786         if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
 787             ret = cd_read_sector(s->bs, s->lba, s->io_buffer, s->cd_sector_size);
 788             if (ret < 0) {
 789                 ide_transfer_stop(s);
 790                 ide_atapi_io_error(s, ret);
 791                 return;
 792             }
 793             s->lba++;
 794             s->io_buffer_index = 0;
 795         }
 796         if (s->elementary_transfer_size > 0) {
 797             /* there are some data left to transmit in this elementary
 798                transfer */
 799             size = s->cd_sector_size - s->io_buffer_index;
 800             if (size > s->elementary_transfer_size)
 801                 size = s->elementary_transfer_size;
 802             s->packet_transfer_size -= size;
 803             s->elementary_transfer_size -= size;
 804             s->io_buffer_index += size;
 805             ide_transfer_start(s, s->io_buffer + s->io_buffer_index - size,
 806                                size, ide_atapi_cmd_reply_end);
 807         } else {
 808             /* a new transfer is needed */
 809             s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
 810             byte_count_limit = s->lcyl | (s->hcyl << 8);
 811 #ifdef DEBUG_IDE_ATAPI
 812             printf("byte_count_limit=%d\n", byte_count_limit);
 813 #endif
 814             if (byte_count_limit == 0xffff)
 815                 byte_count_limit--;
 816             size = s->packet_transfer_size;
 817             if (size > byte_count_limit) {
 818                 /* byte count limit must be even if this case */
 819                 if (byte_count_limit & 1)
 820                     byte_count_limit--;
 821                 size = byte_count_limit;
 822             }
 823             s->lcyl = size;
 824             s->hcyl = size >> 8;
 825             s->elementary_transfer_size = size;
 826             /* we cannot transmit more than one sector at a time */
 827             if (s->lba != -1) {
 828                 if (size > (s->cd_sector_size - s->io_buffer_index))
 829                     size = (s->cd_sector_size - s->io_buffer_index);
 830             }
 831             s->packet_transfer_size -= size;
 832             s->elementary_transfer_size -= size;
 833             s->io_buffer_index += size;
 834             ide_transfer_start(s, s->io_buffer + s->io_buffer_index - size,
 835                                size, ide_atapi_cmd_reply_end);
 836             ide_set_irq(s->bus);
 837 #ifdef DEBUG_IDE_ATAPI
 838             printf("status=0x%x\n", s->status);
 839 #endif
 840         }
 841     }
 842 }
 843
 844 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
 845 static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
 846 {
 847     if (size > max_size)
 848         size = max_size;
 849     s->lba = -1; /* no sector read */
 850     s->packet_transfer_size = size;
 851     s->io_buffer_size = size;    /* dma: send the reply data as one chunk */
 852     s->elementary_transfer_size = 0;
 853     s->io_buffer_index = 0;
 854
 855     if (s->atapi_dma) {
 856         s->status = READY_STAT | SEEK_STAT | DRQ_STAT;
 857         s->bus->dma->ops->start_dma(s->bus->dma, s,
 858                                    ide_atapi_cmd_read_dma_cb);
 859     } else {
 860         s->status = READY_STAT | SEEK_STAT;
 861         ide_atapi_cmd_reply_end(s);
 862     }
 863 }
 864
 865 /* start a CD-CDROM read command */
 866 static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
 867                                    int sector_size)
 868 {
 869     s->lba = lba;
 870     s->packet_transfer_size = nb_sectors * sector_size;
 871     s->elementary_transfer_size = 0;
 872     s->io_buffer_index = sector_size;
 873     s->cd_sector_size = sector_size;
 874
 875     s->status = READY_STAT | SEEK_STAT;
 876     ide_atapi_cmd_reply_end(s);
 877 }
 878
 879 /* ATAPI DMA support */
 880
 881 /* XXX: handle read errors */
 882 static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
 883 {
 884     IDEState *s = opaque;
 885     int data_offset, n;
 886
 887     if (ret < 0) {
 888         ide_atapi_io_error(s, ret);
 889         goto eot;
 890     }
 891
 892     if (s->io_buffer_size > 0) {
 893         /*
 894          * For a cdrom read sector command (s->lba != -1),
 895          * adjust the lba for the next s->io_buffer_size chunk
 896          * and dma the current chunk.
 897          * For a command != read (s->lba == -1), just transfer
 898          * the reply data.
 899          */
 900         if (s->lba != -1) {
 901             if (s->cd_sector_size == 2352) {
 902                 n = 1;
 903                 cd_data_to_raw(s->io_buffer, s->lba);
 904             } else {
 905                 n = s->io_buffer_size >> 11;
 906             }
 907             s->lba += n;
 908         }
 909         s->packet_transfer_size -= s->io_buffer_size;
 910         if (s->bus->dma->ops->rw_buf(s->bus->dma, 1) == 0)
 911             goto eot;
 912     }
 913
 914     if (s->packet_transfer_size <= 0) {
 915         s->status = READY_STAT | SEEK_STAT;
 916         s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 917         ide_set_irq(s->bus);
 918     eot:
 919         s->bus->dma->ops->add_status(s->bus->dma, BM_STATUS_INT);
 920         ide_set_inactive(s);
 921         return;
 922     }
 923
 924     s->io_buffer_index = 0;
 925     if (s->cd_sector_size == 2352) {
 926         n = 1;
 927         s->io_buffer_size = s->cd_sector_size;
 928         data_offset = 16;
 929     } else {
 930         n = s->packet_transfer_size >> 11;
 931         if (n > (IDE_DMA_BUF_SECTORS / 4))
 932             n = (IDE_DMA_BUF_SECTORS / 4);
 933         s->io_buffer_size = n * 2048;
 934         data_offset = 0;
 935     }
 936 #ifdef DEBUG_AIO
 937     printf("aio_read_cd: lba=%u n=%d\n", s->lba, n);
 938 #endif
 939     s->bus->dma->iov.iov_base = (void *)(s->io_buffer + data_offset);
 940     s->bus->dma->iov.iov_len = n * 4 * 512;
 941     qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1);
 942     s->bus->dma->aiocb = bdrv_aio_readv(s->bs, (int64_t)s->lba << 2,
 943                                        &s->bus->dma->qiov, n * 4,
 944                                        ide_atapi_cmd_read_dma_cb, s);
 945     if (!s->bus->dma->aiocb) {
 946         /* Note: media not present is the most likely case */
 947         ide_atapi_cmd_error(s, SENSE_NOT_READY,
 948                             ASC_MEDIUM_NOT_PRESENT);
 949         goto eot;
 950     }
 951 }
 952
 953 /* start a CD-CDROM read command with DMA */
 954 /* XXX: test if DMA is available */
 955 static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors,
 956                                    int sector_size)
 957 {
 958     s->lba = lba;
 959     s->packet_transfer_size = nb_sectors * sector_size;
 960     s->io_buffer_index = 0;
 961     s->io_buffer_size = 0;
 962     s->cd_sector_size = sector_size;
 963
 964     /* XXX: check if BUSY_STAT should be set */
 965     s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
 966     s->bus->dma->ops->start_dma(s->bus->dma, s,
 967                                ide_atapi_cmd_read_dma_cb);
 968 }
 969
 970 static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors,
 971                                int sector_size)
 972 {
 973 #ifdef DEBUG_IDE_ATAPI
 974     printf("read %s: LBA=%d nb_sectors=%d\n", s->atapi_dma ? "dma" : "pio",
 975         lba, nb_sectors);
 976 #endif
 977     if (s->atapi_dma) {
 978         ide_atapi_cmd_read_dma(s, lba, nb_sectors, sector_size);
 979     } else {
 980         ide_atapi_cmd_read_pio(s, lba, nb_sectors, sector_size);
 981     }
 982 }
 983
 984 static inline uint8_t ide_atapi_set_profile(uint8_t *buf, uint8_t *index,
 985                                             uint16_t profile)
 986 {
 987     uint8_t *buf_profile = buf + 12; /* start of profiles */
 988
 989     buf_profile += ((*index) * 4); /* start of indexed profile */
 990     cpu_to_ube16 (buf_profile, profile);
 991     buf_profile[2] = ((buf_profile[0] == buf[6]) && (buf_profile[1] == buf[7]));
 992
 993     /* each profile adds 4 bytes to the response */
 994     (*index)++;
 995     buf[11] += 4; /* Additional Length */
 996
 997     return 4;
 998 }
 999
1000 static int ide_dvd_read_structure(IDEState *s, int format,
1001                                   const uint8_t *packet, uint8_t *buf)
1002 {
1003     switch (format) {
1004         case 0x0: /* Physical format information */
1005             {
1006                 int layer = packet[6];
1007                 uint64_t total_sectors;
1008
1009                 if (layer != 0)
1010                     return -ASC_INV_FIELD_IN_CMD_PACKET;
1011
1012                 bdrv_get_geometry(s->bs, &total_sectors);
1013                 total_sectors >>= 2;
1014                 if (total_sectors == 0)
1015                     return -ASC_MEDIUM_NOT_PRESENT;
1016
1017                 buf[4] = 1;   /* DVD-ROM, part version 1 */
1018                 buf[5] = 0xf; /* 120mm disc, minimum rate unspecified */
1019                 buf[6] = 1;   /* one layer, read-only (per MMC-2 spec) */
1020                 buf[7] = 0;   /* default densities */
1021
1022                 /* FIXME: 0x30000 per spec? */
1023                 cpu_to_ube32(buf + 8, 0); /* start sector */
1024                 cpu_to_ube32(buf + 12, total_sectors - 1); /* end sector */
1025                 cpu_to_ube32(buf + 16, total_sectors - 1); /* l0 end sector */
1026
1027                 /* Size of buffer, not including 2 byte size field */
1028                 cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
1029
1030                 /* 2k data + 4 byte header */
1031                 return (2048 + 4);
1032             }
1033
1034         case 0x01: /* DVD copyright information */
1035             buf[4] = 0; /* no copyright data */
1036             buf[5] = 0; /* no region restrictions */
1037
1038             /* Size of buffer, not including 2 byte size field */
1039             cpu_to_be16wu((uint16_t *)buf, 4 + 2);
1040
1041             /* 4 byte header + 4 byte data */
1042             return (4 + 4);
1043
1044         case 0x03: /* BCA information - invalid field for no BCA info */
1045             return -ASC_INV_FIELD_IN_CMD_PACKET;
1046
1047         case 0x04: /* DVD disc manufacturing information */
1048             /* Size of buffer, not including 2 byte size field */
1049             cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
1050
1051             /* 2k data + 4 byte header */
1052             return (2048 + 4);
1053
1054         case 0xff:
1055             /*
1056              * This lists all the command capabilities above.  Add new ones
1057              * in order and update the length and buffer return values.
1058              */
1059
1060             buf[4] = 0x00; /* Physical format */
1061             buf[5] = 0x40; /* Not writable, is readable */
1062             cpu_to_be16wu((uint16_t *)(buf + 6), 2048 + 4);
1063
1064             buf[8] = 0x01; /* Copyright info */
1065             buf[9] = 0x40; /* Not writable, is readable */
1066             cpu_to_be16wu((uint16_t *)(buf + 10), 4 + 4);
1067
1068             buf[12] = 0x03; /* BCA info */
1069             buf[13] = 0x40; /* Not writable, is readable */
1070             cpu_to_be16wu((uint16_t *)(buf + 14), 188 + 4);
1071
1072             buf[16] = 0x04; /* Manufacturing info */
1073             buf[17] = 0x40; /* Not writable, is readable */
1074             cpu_to_be16wu((uint16_t *)(buf + 18), 2048 + 4);
1075
1076             /* Size of buffer, not including 2 byte size field */
1077             cpu_to_be16wu((uint16_t *)buf, 16 + 2);
1078
1079             /* data written + 4 byte header */
1080             return (16 + 4);
1081
1082         default: /* TODO: formats beyond DVD-ROM requires */
1083             return -ASC_INV_FIELD_IN_CMD_PACKET;
1084     }
1085 }
1086
1087 static void ide_atapi_cmd(IDEState *s)
1088 {
1089     const uint8_t *packet;
1090     uint8_t *buf;
1091     int max_len;
1092
1093     packet = s->io_buffer;
1094     buf = s->io_buffer;
1095 #ifdef DEBUG_IDE_ATAPI
1096     {
1097         int i;
1098         printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8));
1099         for(i = 0; i < ATAPI_PACKET_SIZE; i++) {
1100             printf(" %02x", packet[i]);
1101         }
1102         printf("\n");
1103     }
1104 #endif
1105     /*
1106      * If there's a UNIT_ATTENTION condition pending, only
1107      * REQUEST_SENSE, INQUIRY, GET_CONFIGURATION and
1108      * GET_EVENT_STATUS_NOTIFICATION commands are allowed to complete.
1109      * MMC-5, section 4.1.6.1 lists only these commands being allowed
1110      * to complete, with other commands getting a CHECK condition
1111      * response unless a higher priority status, defined by the drive
1112      * here, is pending.
1113      */
1114     if (s->sense_key == SENSE_UNIT_ATTENTION &&
1115         s->io_buffer[0] != GPCMD_REQUEST_SENSE &&
1116         s->io_buffer[0] != GPCMD_INQUIRY &&
1117         s->io_buffer[0] != GPCMD_GET_EVENT_STATUS_NOTIFICATION) {
1118         ide_atapi_cmd_check_status(s);
1119         return;
1120     }
1121     switch(s->io_buffer[0]) {
1122     case GPCMD_TEST_UNIT_READY:
1123         if (bdrv_is_inserted(s->bs) && !s->cdrom_changed) {
1124             ide_atapi_cmd_ok(s);
1125         } else {
1126             s->cdrom_changed = 0;
1127             ide_atapi_cmd_error(s, SENSE_NOT_READY,
1128                                 ASC_MEDIUM_NOT_PRESENT);
1129         }
1130         break;
1131     case GPCMD_MODE_SENSE_6:
1132     case GPCMD_MODE_SENSE_10:
1133         {
1134             int action, code;
1135             if (packet[0] == GPCMD_MODE_SENSE_10)
1136                 max_len = ube16_to_cpu(packet + 7);
1137             else
1138                 max_len = packet[4];
1139             action = packet[2] >> 6;
1140             code = packet[2] & 0x3f;
1141             switch(action) {
1142             case 0: /* current values */
1143                 switch(code) {
1144                 case GPMODE_R_W_ERROR_PAGE: /* error recovery */
1145                     cpu_to_ube16(&buf[0], 16 + 6);
1146                     buf[2] = 0x70;
1147                     buf[3] = 0;
1148                     buf[4] = 0;
1149                     buf[5] = 0;
1150                     buf[6] = 0;
1151                     buf[7] = 0;
1152
1153                     buf[8] = 0x01;
1154                     buf[9] = 0x06;
1155                     buf[10] = 0x00;
1156                     buf[11] = 0x05;
1157                     buf[12] = 0x00;
1158                     buf[13] = 0x00;
1159                     buf[14] = 0x00;
1160                     buf[15] = 0x00;
1161                     ide_atapi_cmd_reply(s, 16, max_len);
1162                     break;
1163                 case GPMODE_AUDIO_CTL_PAGE:
1164                     cpu_to_ube16(&buf[0], 24 + 6);
1165                     buf[2] = 0x70;
1166                     buf[3] = 0;
1167                     buf[4] = 0;
1168                     buf[5] = 0;
1169                     buf[6] = 0;
1170                     buf[7] = 0;
1171
1172                     /* Fill with CDROM audio volume */
1173                     buf[17] = 0;
1174                     buf[19] = 0;
1175                     buf[21] = 0;
1176                     buf[23] = 0;
1177
1178                     ide_atapi_cmd_reply(s, 24, max_len);
1179                     break;
1180                 case GPMODE_CAPABILITIES_PAGE:
1181                     cpu_to_ube16(&buf[0], 28 + 6);
1182                     buf[2] = 0x70;
1183                     buf[3] = 0;
1184                     buf[4] = 0;
1185                     buf[5] = 0;
1186                     buf[6] = 0;
1187                     buf[7] = 0;
1188
1189                     buf[8] = 0x2a;
1190                     buf[9] = 0x12;
1191                     buf[10] = 0x00;
1192                     buf[11] = 0x00;
1193
1194                     /* Claim PLAY_AUDIO capability (0x01) since some Linux
1195                        code checks for this to automount media. */
1196                     buf[12] = 0x71;
1197                     buf[13] = 3 << 5;
1198                     buf[14] = (1 << 0) | (1 << 3) | (1 << 5);
1199                     if (bdrv_is_locked(s->bs))
1200                         buf[6] |= 1 << 1;
1201                     buf[15] = 0x00;
1202                     cpu_to_ube16(&buf[16], 706);
1203                     buf[18] = 0;
1204                     buf[19] = 2;
1205                     cpu_to_ube16(&buf[20], 512);
1206                     cpu_to_ube16(&buf[22], 706);
1207                     buf[24] = 0;
1208                     buf[25] = 0;
1209                     buf[26] = 0;
1210                     buf[27] = 0;
1211                     ide_atapi_cmd_reply(s, 28, max_len);
1212                     break;
1213                 default:
1214                     goto error_cmd;
1215                 }
1216                 break;
1217             case 1: /* changeable values */
1218                 goto error_cmd;
1219             case 2: /* default values */
1220                 goto error_cmd;
1221             default:
1222             case 3: /* saved values */
1223                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1224                                     ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
1225                 break;
1226             }
1227         }
1228         break;
1229     case GPCMD_REQUEST_SENSE:
1230         max_len = packet[4];
1231         memset(buf, 0, 18);
1232         buf[0] = 0x70 | (1 << 7);
1233         buf[2] = s->sense_key;
1234         buf[7] = 10;
1235         buf[12] = s->asc;
1236         if (s->sense_key == SENSE_UNIT_ATTENTION)
1237             s->sense_key = SENSE_NONE;
1238         ide_atapi_cmd_reply(s, 18, max_len);
1239         break;
1240     case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
1241         bdrv_set_locked(s->bs, packet[4] & 1);
1242         ide_atapi_cmd_ok(s);
1243         break;
1244     case GPCMD_READ_10:
1245     case GPCMD_READ_12:
1246         {
1247             int nb_sectors, lba;
1248
1249             if (packet[0] == GPCMD_READ_10)
1250                 nb_sectors = ube16_to_cpu(packet + 7);
1251             else
1252                 nb_sectors = ube32_to_cpu(packet + 6);
1253             lba = ube32_to_cpu(packet + 2);
1254             if (nb_sectors == 0) {
1255                 ide_atapi_cmd_ok(s);
1256                 break;
1257             }
1258             ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
1259         }
1260         break;
1261     case GPCMD_READ_CD:
1262         {
1263             int nb_sectors, lba, transfer_request;
1264
1265             nb_sectors = (packet[6] << 16) | (packet[7] << 8) | packet[8];
1266             lba = ube32_to_cpu(packet + 2);
1267             if (nb_sectors == 0) {
1268                 ide_atapi_cmd_ok(s);
1269                 break;
1270             }
1271             transfer_request = packet[9];
1272             switch(transfer_request & 0xf8) {
1273             case 0x00:
1274                 /* nothing */
1275                 ide_atapi_cmd_ok(s);
1276                 break;
1277             case 0x10:
1278                 /* normal read */
1279                 ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
1280                 break;
1281             case 0xf8:
1282                 /* read all data */
1283                 ide_atapi_cmd_read(s, lba, nb_sectors, 2352);
1284                 break;
1285             default:
1286                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1287                                     ASC_INV_FIELD_IN_CMD_PACKET);
1288                 break;
1289             }
1290         }
1291         break;
1292     case GPCMD_SEEK:
1293         {
1294             unsigned int lba;
1295             uint64_t total_sectors;
1296
1297             bdrv_get_geometry(s->bs, &total_sectors);
1298             total_sectors >>= 2;
1299             if (total_sectors == 0) {
1300                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1301                                     ASC_MEDIUM_NOT_PRESENT);
1302                 break;
1303             }
1304             lba = ube32_to_cpu(packet + 2);
1305             if (lba >= total_sectors) {
1306                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1307                                     ASC_LOGICAL_BLOCK_OOR);
1308                 break;
1309             }
1310             ide_atapi_cmd_ok(s);
1311         }
1312         break;
1313     case GPCMD_START_STOP_UNIT:
1314         {
1315             int start, eject, sense, err = 0;
1316             start = packet[4] & 1;
1317             eject = (packet[4] >> 1) & 1;
1318
1319             if (eject) {
1320                 err = bdrv_eject(s->bs, !start);
1321             }
1322
1323             switch (err) {
1324             case 0:
1325                 ide_atapi_cmd_ok(s);
1326                 break;
1327             case -EBUSY:
1328                 sense = SENSE_NOT_READY;
1329                 if (bdrv_is_inserted(s->bs)) {
1330                     sense = SENSE_ILLEGAL_REQUEST;
1331                 }
1332                 ide_atapi_cmd_error(s, sense,
1333                                     ASC_MEDIA_REMOVAL_PREVENTED);
1334                 break;
1335             default:
1336                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1337                                     ASC_MEDIUM_NOT_PRESENT);
1338                 break;
1339             }
1340         }
1341         break;
1342     case GPCMD_MECHANISM_STATUS:
1343         {
1344             max_len = ube16_to_cpu(packet + 8);
1345             cpu_to_ube16(buf, 0);
1346             /* no current LBA */
1347             buf[2] = 0;
1348             buf[3] = 0;
1349             buf[4] = 0;
1350             buf[5] = 1;
1351             cpu_to_ube16(buf + 6, 0);
1352             ide_atapi_cmd_reply(s, 8, max_len);
1353         }
1354         break;
1355     case GPCMD_READ_TOC_PMA_ATIP:
1356         {
1357             int format, msf, start_track, len;
1358             uint64_t total_sectors;
1359
1360             bdrv_get_geometry(s->bs, &total_sectors);
1361             total_sectors >>= 2;
1362             if (total_sectors == 0) {
1363                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1364                                     ASC_MEDIUM_NOT_PRESENT);
1365                 break;
1366             }
1367             max_len = ube16_to_cpu(packet + 7);
1368             format = packet[9] >> 6;
1369             msf = (packet[1] >> 1) & 1;
1370             start_track = packet[6];
1371             switch(format) {
1372             case 0:
1373                 len = cdrom_read_toc(total_sectors, buf, msf, start_track);
1374                 if (len < 0)
1375                     goto error_cmd;
1376                 ide_atapi_cmd_reply(s, len, max_len);
1377                 break;
1378             case 1:
1379                 /* multi session : only a single session defined */
1380                 memset(buf, 0, 12);
1381                 buf[1] = 0x0a;
1382                 buf[2] = 0x01;
1383                 buf[3] = 0x01;
1384                 ide_atapi_cmd_reply(s, 12, max_len);
1385                 break;
1386             case 2:
1387                 len = cdrom_read_toc_raw(total_sectors, buf, msf, start_track);
1388                 if (len < 0)
1389                     goto error_cmd;
1390                 ide_atapi_cmd_reply(s, len, max_len);
1391                 break;
1392             default:
1393             error_cmd:
1394                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1395                                     ASC_INV_FIELD_IN_CMD_PACKET);
1396                 break;
1397             }
1398         }
1399         break;
1400     case GPCMD_READ_CDVD_CAPACITY:
1401         {
1402             uint64_t total_sectors;
1403
1404             bdrv_get_geometry(s->bs, &total_sectors);
1405             total_sectors >>= 2;
1406             if (total_sectors == 0) {
1407                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1408                                     ASC_MEDIUM_NOT_PRESENT);
1409                 break;
1410             }
1411             /* NOTE: it is really the number of sectors minus 1 */
1412             cpu_to_ube32(buf, total_sectors - 1);
1413             cpu_to_ube32(buf + 4, 2048);
1414             ide_atapi_cmd_reply(s, 8, 8);
1415         }
1416         break;
1417     case GPCMD_READ_DVD_STRUCTURE:
1418         {
1419             int media = packet[1];
1420             int format = packet[7];
1421             int ret;
1422
1423             max_len = ube16_to_cpu(packet + 8);
1424
1425             if (format < 0xff) {
1426                 if (media_is_cd(s)) {
1427                     ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1428                                         ASC_INCOMPATIBLE_FORMAT);
1429                     break;
1430                 } else if (!media_present(s)) {
1431                     ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1432                                         ASC_INV_FIELD_IN_CMD_PACKET);
1433                     break;
1434                 }
1435             }
1436
1437             memset(buf, 0, max_len > IDE_DMA_BUF_SECTORS * 512 + 4 ?
1438                    IDE_DMA_BUF_SECTORS * 512 + 4 : max_len);
1439
1440             switch (format) {
1441                 case 0x00 ... 0x7f:
1442                 case 0xff:
1443                     if (media == 0) {
1444                         ret = ide_dvd_read_structure(s, format, packet, buf);
1445
1446                         if (ret < 0)
1447                             ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST, -ret);
1448                         else
1449                             ide_atapi_cmd_reply(s, ret, max_len);
1450
1451                         break;
1452                     }
1453                     /* TODO: BD support, fall through for now */
1454
1455                 /* Generic disk structures */
1456                 case 0x80: /* TODO: AACS volume identifier */
1457                 case 0x81: /* TODO: AACS media serial number */
1458                 case 0x82: /* TODO: AACS media identifier */
1459                 case 0x83: /* TODO: AACS media key block */
1460                 case 0x90: /* TODO: List of recognized format layers */
1461                 case 0xc0: /* TODO: Write protection status */
1462                 default:
1463                     ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1464                                         ASC_INV_FIELD_IN_CMD_PACKET);
1465                     break;
1466             }
1467         }
1468         break;
1469     case GPCMD_SET_SPEED:
1470         ide_atapi_cmd_ok(s);
1471         break;
1472     case GPCMD_INQUIRY:
1473         max_len = packet[4];
1474         buf[0] = 0x05; /* CD-ROM */
1475         buf[1] = 0x80; /* removable */
1476         buf[2] = 0x00; /* ISO */
1477         buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1478         buf[4] = 31; /* additional length */
1479         buf[5] = 0; /* reserved */
1480         buf[6] = 0; /* reserved */
1481         buf[7] = 0; /* reserved */
1482         padstr8(buf + 8, 8, "QEMU");
1483         padstr8(buf + 16, 16, "QEMU DVD-ROM");
1484         padstr8(buf + 32, 4, s->version);
1485         ide_atapi_cmd_reply(s, 36, max_len);
1486         break;
1487     case GPCMD_GET_CONFIGURATION:
1488         {
1489             uint32_t len;
1490             uint8_t index = 0;
1491
1492             /* only feature 0 is supported */
1493             if (packet[2] != 0 || packet[3] != 0) {
1494                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1495                                     ASC_INV_FIELD_IN_CMD_PACKET);
1496                 break;
1497             }
1498
1499             /* XXX: could result in alignment problems in some architectures */
1500             max_len = ube16_to_cpu(packet + 7);
1501
1502             /*
1503              * XXX: avoid overflow for io_buffer if max_len is bigger than
1504              *      the size of that buffer (dimensioned to max number of
1505              *      sectors to transfer at once)
1506              *
1507              *      Only a problem if the feature/profiles grow.
1508              */
1509             if (max_len > 512) /* XXX: assume 1 sector */
1510                 max_len = 512;
1511
1512             memset(buf, 0, max_len);
1513             /*
1514              * the number of sectors from the media tells us which profile
1515              * to use as current.  0 means there is no media
1516              */
1517             if (media_is_dvd(s))
1518                 cpu_to_ube16(buf + 6, MMC_PROFILE_DVD_ROM);
1519             else if (media_is_cd(s))
1520                 cpu_to_ube16(buf + 6, MMC_PROFILE_CD_ROM);
1521
1522             buf[10] = 0x02 | 0x01; /* persistent and current */
1523             len = 12; /* headers: 8 + 4 */
1524             len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_DVD_ROM);
1525             len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_CD_ROM);
1526             cpu_to_ube32(buf, len - 4); /* data length */
1527
1528             ide_atapi_cmd_reply(s, len, max_len);
1529             break;
1530         }
1531     case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
1532         max_len = ube16_to_cpu(packet + 7);
1533
1534         if (packet[1] & 0x01) { /* polling */
1535             /* We don't support any event class (yet). */
1536             cpu_to_ube16(buf, 0x00); /* No event descriptor returned */
1537             buf[2] = 0x80;           /* No Event Available (NEA) */
1538             buf[3] = 0x00;           /* Empty supported event classes */
1539             ide_atapi_cmd_reply(s, 4, max_len);
1540         } else { /* asynchronous mode */
1541             /* Only polling is supported, asynchronous mode is not. */
1542             ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1543                                 ASC_INV_FIELD_IN_CMD_PACKET);
1544         }
1545         break;
1546     default:
1547         ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1548                             ASC_ILLEGAL_OPCODE);
1549         break;
1550     }
1551 }
1552
1553 static void ide_cfata_metadata_inquiry(IDEState *s)
1554 {
1555     uint16_t *p;
1556     uint32_t spd;
1557
1558     p = (uint16_t *) s->io_buffer;
1559     memset(p, 0, 0x200);
1560     spd = ((s->mdata_size - 1) >> 9) + 1;
1561
1562     put_le16(p + 0, 0x0001);                    /* Data format revision */
1563     put_le16(p + 1, 0x0000);                    /* Media property: silicon */
1564     put_le16(p + 2, s->media_changed);          /* Media status */
1565     put_le16(p + 3, s->mdata_size & 0xffff);    /* Capacity in bytes (low) */
1566     put_le16(p + 4, s->mdata_size >> 16);       /* Capacity in bytes (high) */
1567     put_le16(p + 5, spd & 0xffff);              /* Sectors per device (low) */
1568     put_le16(p + 6, spd >> 16);                 /* Sectors per device (high) */
1569 }
1570
1571 static void ide_cfata_metadata_read(IDEState *s)
1572 {
1573     uint16_t *p;
1574
1575     if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
1576         s->status = ERR_STAT;
1577         s->error = ABRT_ERR;
1578         return;
1579     }
1580
1581     p = (uint16_t *) s->io_buffer;
1582     memset(p, 0, 0x200);
1583
1584     put_le16(p + 0, s->media_changed);          /* Media status */
1585     memcpy(p + 1, s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
1586                     MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
1587                                     s->nsector << 9), 0x200 - 2));
1588 }
1589
1590 static void ide_cfata_metadata_write(IDEState *s)
1591 {
1592     if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
1593         s->status = ERR_STAT;
1594         s->error = ABRT_ERR;
1595         return;
1596     }
1597
1598     s->media_changed = 0;
1599
1600     memcpy(s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
1601                     s->io_buffer + 2,
1602                     MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
1603                                     s->nsector << 9), 0x200 - 2));
1604 }
1605
1606 /* called when the inserted state of the media has changed */
1607 static void cdrom_change_cb(void *opaque, int reason)
1608 {
1609     IDEState *s = opaque;
1610     uint64_t nb_sectors;
1611
1612     if (!(reason & CHANGE_MEDIA)) {
1613         return;
1614     }
1615
1616     bdrv_get_geometry(s->bs, &nb_sectors);
1617     s->nb_sectors = nb_sectors;
1618
1619     s->sense_key = SENSE_UNIT_ATTENTION;
1620     s->asc = ASC_MEDIUM_MAY_HAVE_CHANGED;
1621     s->cdrom_changed = 1;
1622     ide_set_irq(s->bus);
1623 }
1624
1625 static void ide_cmd_lba48_transform(IDEState *s, int lba48)
1626 {
1627     s->lba48 = lba48;
1628
1629     /* handle the 'magic' 0 nsector count conversion here. to avoid
1630      * fiddling with the rest of the read logic, we just store the
1631      * full sector count in ->nsector and ignore ->hob_nsector from now
1632      */
1633     if (!s->lba48) {
1634         if (!s->nsector)
1635             s->nsector = 256;
1636     } else {
1637         if (!s->nsector && !s->hob_nsector)
1638             s->nsector = 65536;
1639         else {
1640             int lo = s->nsector;
1641             int hi = s->hob_nsector;
1642
1643             s->nsector = (hi << 8) | lo;
1644         }
1645     }
1646 }
1647
1648 static void ide_clear_hob(IDEBus *bus)
1649 {
1650     /* any write clears HOB high bit of device control register */
1651     bus->ifs[0].select &= ~(1 << 7);
1652     bus->ifs[1].select &= ~(1 << 7);
1653 }
1654
1655 void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
1656 {
1657     IDEBus *bus = opaque;
1658
1659 #ifdef DEBUG_IDE
1660     printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
1661 #endif
1662
1663     addr &= 7;
1664
1665     /* ignore writes to command block while busy with previous command */
1666     if (addr != 7 && (idebus_active_if(bus)->status & (BUSY_STAT|DRQ_STAT)))
1667         return;
1668
1669     switch(addr) {
1670     case 0:
1671         break;
1672     case 1:
1673         ide_clear_hob(bus);
1674         /* NOTE: data is written to the two drives */
1675         bus->ifs[0].hob_feature = bus->ifs[0].feature;
1676         bus->ifs[1].hob_feature = bus->ifs[1].feature;
1677         bus->ifs[0].feature = val;
1678         bus->ifs[1].feature = val;
1679         break;
1680     case 2:
1681         ide_clear_hob(bus);
1682         bus->ifs[0].hob_nsector = bus->ifs[0].nsector;
1683         bus->ifs[1].hob_nsector = bus->ifs[1].nsector;
1684         bus->ifs[0].nsector = val;
1685         bus->ifs[1].nsector = val;
1686         break;
1687     case 3:
1688         ide_clear_hob(bus);
1689         bus->ifs[0].hob_sector = bus->ifs[0].sector;
1690         bus->ifs[1].hob_sector = bus->ifs[1].sector;
1691         bus->ifs[0].sector = val;
1692         bus->ifs[1].sector = val;
1693         break;
1694     case 4:
1695         ide_clear_hob(bus);
1696         bus->ifs[0].hob_lcyl = bus->ifs[0].lcyl;
1697         bus->ifs[1].hob_lcyl = bus->ifs[1].lcyl;
1698         bus->ifs[0].lcyl = val;
1699         bus->ifs[1].lcyl = val;
1700         break;
1701     case 5:
1702         ide_clear_hob(bus);
1703         bus->ifs[0].hob_hcyl = bus->ifs[0].hcyl;
1704         bus->ifs[1].hob_hcyl = bus->ifs[1].hcyl;
1705         bus->ifs[0].hcyl = val;
1706         bus->ifs[1].hcyl = val;
1707         break;
1708     case 6:
1709         /* FIXME: HOB readback uses bit 7 */
1710         bus->ifs[0].select = (val & ~0x10) | 0xa0;
1711         bus->ifs[1].select = (val | 0x10) | 0xa0;
1712         /* select drive */
1713         bus->unit = (val >> 4) & 1;
1714         break;
1715     default:
1716     case 7:
1717         /* command */
1718         ide_exec_cmd(bus, val);
1719         break;
1720     }
1721 }
1722
1723
1724 void ide_exec_cmd(IDEBus *bus, uint32_t val)
1725 {
1726     IDEState *s;
1727     int n;
1728     int lba48 = 0;
1729
1730 #if defined(DEBUG_IDE)
1731     printf("ide: CMD=%02x\n", val);
1732 #endif
1733     s = idebus_active_if(bus);
1734     /* ignore commands to non existant slave */
1735     if (s != bus->ifs && !s->bs)
1736         return;
1737
1738     /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
1739     if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET)
1740         return;
1741
1742     switch(val) {
1743     case WIN_IDENTIFY:
1744         if (s->bs && s->drive_kind != IDE_CD) {
1745             if (s->drive_kind != IDE_CFATA)
1746                 ide_identify(s);
1747             else
1748                 ide_cfata_identify(s);
1749             s->status = READY_STAT | SEEK_STAT;
1750             ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1751         } else {
1752             if (s->drive_kind == IDE_CD) {
1753                 ide_set_signature(s);
1754             }
1755             ide_abort_command(s);
1756         }
1757         ide_set_irq(s->bus);
1758         break;
1759     case WIN_SPECIFY:
1760     case WIN_RECAL:
1761         s->error = 0;
1762         s->status = READY_STAT | SEEK_STAT;
1763         ide_set_irq(s->bus);
1764         break;
1765     case WIN_SETMULT:
1766         if (s->drive_kind == IDE_CFATA && s->nsector == 0) {
1767             /* Disable Read and Write Multiple */
1768             s->mult_sectors = 0;
1769             s->status = READY_STAT | SEEK_STAT;
1770         } else if ((s->nsector & 0xff) != 0 &&
1771             ((s->nsector & 0xff) > MAX_MULT_SECTORS ||
1772              (s->nsector & (s->nsector - 1)) != 0)) {
1773             ide_abort_command(s);
1774         } else {
1775             s->mult_sectors = s->nsector & 0xff;
1776             s->status = READY_STAT | SEEK_STAT;
1777         }
1778         ide_set_irq(s->bus);
1779         break;
1780     case WIN_VERIFY_EXT:
1781         lba48 = 1;
1782     case WIN_VERIFY:
1783     case WIN_VERIFY_ONCE:
1784         /* do sector number check ? */
1785         ide_cmd_lba48_transform(s, lba48);
1786         s->status = READY_STAT | SEEK_STAT;
1787         ide_set_irq(s->bus);
1788         break;
1789         case WIN_READ_EXT:
1790         lba48 = 1;
1791     case WIN_READ:
1792     case WIN_READ_ONCE:
1793         if (!s->bs)
1794             goto abort_cmd;
1795         ide_cmd_lba48_transform(s, lba48);
1796         s->req_nb_sectors = 1;
1797         ide_sector_read(s);
1798         break;
1799         case WIN_WRITE_EXT:
1800         lba48 = 1;
1801     case WIN_WRITE:
1802     case WIN_WRITE_ONCE:
1803     case CFA_WRITE_SECT_WO_ERASE:
1804     case WIN_WRITE_VERIFY:
1805         ide_cmd_lba48_transform(s, lba48);
1806         s->error = 0;
1807         s->status = SEEK_STAT | READY_STAT;
1808         s->req_nb_sectors = 1;
1809         ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
1810         s->media_changed = 1;
1811         break;
1812         case WIN_MULTREAD_EXT:
1813         lba48 = 1;
1814     case WIN_MULTREAD:
1815         if (!s->mult_sectors)
1816             goto abort_cmd;
1817         ide_cmd_lba48_transform(s, lba48);
1818         s->req_nb_sectors = s->mult_sectors;
1819         ide_sector_read(s);
1820         break;
1821     case WIN_MULTWRITE_EXT:
1822         lba48 = 1;
1823     case WIN_MULTWRITE:
1824     case CFA_WRITE_MULTI_WO_ERASE:
1825         if (!s->mult_sectors)
1826             goto abort_cmd;
1827         ide_cmd_lba48_transform(s, lba48);
1828         s->error = 0;
1829         s->status = SEEK_STAT | READY_STAT;
1830         s->req_nb_sectors = s->mult_sectors;
1831         n = s->nsector;
1832         if (n > s->req_nb_sectors)
1833             n = s->req_nb_sectors;
1834         ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
1835         s->media_changed = 1;
1836         break;
1837         case WIN_READDMA_EXT:
1838         lba48 = 1;
1839     case WIN_READDMA:
1840     case WIN_READDMA_ONCE:
1841         if (!s->bs)
1842             goto abort_cmd;
1843         ide_cmd_lba48_transform(s, lba48);
1844         ide_sector_start_dma(s, 1);
1845         break;
1846         case WIN_WRITEDMA_EXT:
1847         lba48 = 1;
1848     case WIN_WRITEDMA:
1849     case WIN_WRITEDMA_ONCE:
1850         if (!s->bs)
1851             goto abort_cmd;
1852         ide_cmd_lba48_transform(s, lba48);
1853         ide_sector_start_dma(s, 0);
1854         s->media_changed = 1;
1855         break;
1856     case WIN_READ_NATIVE_MAX_EXT:
1857         lba48 = 1;
1858     case WIN_READ_NATIVE_MAX:
1859         ide_cmd_lba48_transform(s, lba48);
1860         ide_set_sector(s, s->nb_sectors - 1);
1861         s->status = READY_STAT | SEEK_STAT;
1862         ide_set_irq(s->bus);
1863         break;
1864     case WIN_CHECKPOWERMODE1:
1865     case WIN_CHECKPOWERMODE2:
1866         s->error = 0;
1867         s->nsector = 0xff; /* device active or idle */
1868         s->status = READY_STAT | SEEK_STAT;
1869         ide_set_irq(s->bus);
1870         break;
1871     case WIN_SETFEATURES:
1872         if (!s->bs)
1873             goto abort_cmd;
1874         /* XXX: valid for CDROM ? */
1875         switch(s->feature) {
1876         case 0xcc: /* reverting to power-on defaults enable */
1877         case 0x66: /* reverting to power-on defaults disable */
1878         case 0x02: /* write cache enable */
1879         case 0x82: /* write cache disable */
1880         case 0xaa: /* read look-ahead enable */
1881         case 0x55: /* read look-ahead disable */
1882         case 0x05: /* set advanced power management mode */
1883         case 0x85: /* disable advanced power management mode */
1884         case 0x69: /* NOP */
1885         case 0x67: /* NOP */
1886         case 0x96: /* NOP */
1887         case 0x9a: /* NOP */
1888         case 0x42: /* enable Automatic Acoustic Mode */
1889         case 0xc2: /* disable Automatic Acoustic Mode */
1890             s->status = READY_STAT | SEEK_STAT;
1891             ide_set_irq(s->bus);
1892             break;
1893         case 0x03: { /* set transfer mode */
1894                 uint8_t val = s->nsector & 0x07;
1895             uint16_t *identify_data = (uint16_t *)s->identify_data;
1896
1897                 switch (s->nsector >> 3) {
1898                 case 0x00: /* pio default */
1899                 case 0x01: /* pio mode */
1900                         put_le16(identify_data + 62,0x07);
1901                         put_le16(identify_data + 63,0x07);
1902                         put_le16(identify_data + 88,0x3f);
1903                         break;
1904                 case 0x02: /* sigle word dma mode*/
1905                         put_le16(identify_data + 62,0x07 | (1 << (val + 8)));
1906                         put_le16(identify_data + 63,0x07);
1907                         put_le16(identify_data + 88,0x3f);
1908                         break;
1909                 case 0x04: /* mdma mode */
1910                         put_le16(identify_data + 62,0x07);
1911                         put_le16(identify_data + 63,0x07 | (1 << (val + 8)));
1912                         put_le16(identify_data + 88,0x3f);
1913                         break;
1914                 case 0x08: /* udma mode */
1915                         put_le16(identify_data + 62,0x07);
1916                         put_le16(identify_data + 63,0x07);
1917                         put_le16(identify_data + 88,0x3f | (1 << (val + 8)));
1918                         break;
1919                 default:
1920                         goto abort_cmd;
1921                 }
1922             s->status = READY_STAT | SEEK_STAT;
1923             ide_set_irq(s->bus);
1924             break;
1925         }
1926         default:
1927             goto abort_cmd;
1928         }
1929         break;
1930     case WIN_FLUSH_CACHE:
1931     case WIN_FLUSH_CACHE_EXT:
1932         ide_flush_cache(s);
1933         break;
1934     case WIN_STANDBY:
1935     case WIN_STANDBY2:
1936     case WIN_STANDBYNOW1:
1937     case WIN_STANDBYNOW2:
1938     case WIN_IDLEIMMEDIATE:
1939     case CFA_IDLEIMMEDIATE:
1940     case WIN_SETIDLE1:
1941     case WIN_SETIDLE2:
1942     case WIN_SLEEPNOW1:
1943     case WIN_SLEEPNOW2:
1944         s->status = READY_STAT;
1945         ide_set_irq(s->bus);
1946         break;
1947     case WIN_SEEK:
1948         if(s->drive_kind == IDE_CD)
1949             goto abort_cmd;
1950         /* XXX: Check that seek is within bounds */
1951         s->status = READY_STAT | SEEK_STAT;
1952         ide_set_irq(s->bus);
1953         break;
1954         /* ATAPI commands */
1955     case WIN_PIDENTIFY:
1956         if (s->drive_kind == IDE_CD) {
1957             ide_atapi_identify(s);
1958             s->status = READY_STAT | SEEK_STAT;
1959             ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1960         } else {
1961             ide_abort_command(s);
1962         }
1963         ide_set_irq(s->bus);
1964         break;
1965     case WIN_DIAGNOSE:
1966         ide_set_signature(s);
1967         if (s->drive_kind == IDE_CD)
1968             s->status = 0; /* ATAPI spec (v6) section 9.10 defines packet
1969                             * devices to return a clear status register
1970                             * with READY_STAT *not* set. */
1971         else
1972             s->status = READY_STAT | SEEK_STAT;
1973         s->error = 0x01; /* Device 0 passed, Device 1 passed or not
1974                           * present.
1975                           */
1976         ide_set_irq(s->bus);
1977         break;
1978     case WIN_SRST:
1979         if (s->drive_kind != IDE_CD)
1980             goto abort_cmd;
1981         ide_set_signature(s);
1982         s->status = 0x00; /* NOTE: READY is _not_ set */
1983         s->error = 0x01;
1984         break;
1985     case WIN_PACKETCMD:
1986         if (s->drive_kind != IDE_CD)
1987             goto abort_cmd;
1988         /* overlapping commands not supported */
1989         if (s->feature & 0x02)
1990             goto abort_cmd;
1991         s->status = READY_STAT | SEEK_STAT;
1992         s->atapi_dma = s->feature & 1;
1993         s->nsector = 1;
1994         ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
1995                            ide_atapi_cmd);
1996         break;
1997     /* CF-ATA commands */
1998     case CFA_REQ_EXT_ERROR_CODE:
1999         if (s->drive_kind != IDE_CFATA)
2000             goto abort_cmd;
2001         s->error = 0x09;    /* miscellaneous error */
2002         s->status = READY_STAT | SEEK_STAT;
2003         ide_set_irq(s->bus);
2004         break;
2005     case CFA_ERASE_SECTORS:
2006     case CFA_WEAR_LEVEL:
2007         if (s->drive_kind != IDE_CFATA)
2008             goto abort_cmd;
2009         if (val == CFA_WEAR_LEVEL)
2010             s->nsector = 0;
2011         if (val == CFA_ERASE_SECTORS)
2012             s->media_changed = 1;
2013         s->error = 0x00;
2014         s->status = READY_STAT | SEEK_STAT;
2015         ide_set_irq(s->bus);
2016         break;
2017     case CFA_TRANSLATE_SECTOR:
2018         if (s->drive_kind != IDE_CFATA)
2019             goto abort_cmd;
2020         s->error = 0x00;
2021         s->status = READY_STAT | SEEK_STAT;
2022         memset(s->io_buffer, 0, 0x200);
2023         s->io_buffer[0x00] = s->hcyl;                   /* Cyl MSB */
2024         s->io_buffer[0x01] = s->lcyl;                   /* Cyl LSB */
2025         s->io_buffer[0x02] = s->select;                 /* Head */
2026         s->io_buffer[0x03] = s->sector;                 /* Sector */
2027         s->io_buffer[0x04] = ide_get_sector(s) >> 16;   /* LBA MSB */
2028         s->io_buffer[0x05] = ide_get_sector(s) >> 8;    /* LBA */
2029         s->io_buffer[0x06] = ide_get_sector(s) >> 0;    /* LBA LSB */
2030         s->io_buffer[0x13] = 0x00;                              /* Erase flag */
2031         s->io_buffer[0x18] = 0x00;                              /* Hot count */
2032         s->io_buffer[0x19] = 0x00;                              /* Hot count */
2033         s->io_buffer[0x1a] = 0x01;                              /* Hot count */
2034         ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2035         ide_set_irq(s->bus);
2036         break;
2037     case CFA_ACCESS_METADATA_STORAGE:
2038         if (s->drive_kind != IDE_CFATA)
2039             goto abort_cmd;
2040         switch (s->feature) {
2041         case 0x02:      /* Inquiry Metadata Storage */
2042             ide_cfata_metadata_inquiry(s);
2043             break;
2044         case 0x03:      /* Read Metadata Storage */
2045             ide_cfata_metadata_read(s);
2046             break;
2047         case 0x04:      /* Write Metadata Storage */
2048             ide_cfata_metadata_write(s);
2049             break;
2050         default:
2051             goto abort_cmd;
2052         }
2053         ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2054         s->status = 0x00; /* NOTE: READY is _not_ set */
2055         ide_set_irq(s->bus);
2056         break;
2057     case IBM_SENSE_CONDITION:
2058         if (s->drive_kind != IDE_CFATA)
2059             goto abort_cmd;
2060         switch (s->feature) {
2061         case 0x01:  /* sense temperature in device */
2062             s->nsector = 0x50;      /* +20 C */
2063             break;
2064         default:
2065             goto abort_cmd;
2066         }
2067         s->status = READY_STAT | SEEK_STAT;
2068         ide_set_irq(s->bus);
2069         break;
2070
2071         case WIN_SMART:
2072         if (s->drive_kind == IDE_CD)
2073                 goto abort_cmd;
2074         if (s->hcyl != 0xc2 || s->lcyl != 0x4f)
2075                 goto abort_cmd;
2076         if (!s->smart_enabled && s->feature != SMART_ENABLE)
2077                 goto abort_cmd;
2078         switch (s->feature) {
2079         case SMART_DISABLE:
2080                 s->smart_enabled = 0;
2081                 s->status = READY_STAT | SEEK_STAT;
2082                 ide_set_irq(s->bus);
2083                 break;
2084         case SMART_ENABLE:
2085                 s->smart_enabled = 1;
2086                 s->status = READY_STAT | SEEK_STAT;
2087                 ide_set_irq(s->bus);
2088                 break;
2089         case SMART_ATTR_AUTOSAVE:
2090                 switch (s->sector) {
2091                 case 0x00:
2092                 s->smart_autosave = 0;
2093                 break;
2094                 case 0xf1:
2095                 s->smart_autosave = 1;
2096                 break;
2097                 default:
2098                 goto abort_cmd;
2099                 }
2100                 s->status = READY_STAT | SEEK_STAT;
2101                 ide_set_irq(s->bus);
2102                 break;
2103         case SMART_STATUS:
2104                 if (!s->smart_errors) {
2105                 s->hcyl = 0xc2;
2106                 s->lcyl = 0x4f;
2107                 } else {
2108                 s->hcyl = 0x2c;
2109                 s->lcyl = 0xf4;
2110                 }
2111                 s->status = READY_STAT | SEEK_STAT;
2112                 ide_set_irq(s->bus);
2113                 break;
2114         case SMART_READ_THRESH:
2115                 memset(s->io_buffer, 0, 0x200);
2116                 s->io_buffer[0] = 0x01; /* smart struct version */
2117                 for (n=0; n<30; n++) {
2118                 if (smart_attributes[n][0] == 0)
2119                         break;
2120                 s->io_buffer[2+0+(n*12)] = smart_attributes[n][0];
2121                 s->io_buffer[2+1+(n*12)] = smart_attributes[n][11];
2122                 }
2123                 for (n=0; n<511; n++) /* checksum */
2124                 s->io_buffer[511] += s->io_buffer[n];
2125                 s->io_buffer[511] = 0x100 - s->io_buffer[511];
2126                 s->status = READY_STAT | SEEK_STAT;
2127                 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2128                 ide_set_irq(s->bus);
2129                 break;
2130         case SMART_READ_DATA:
2131                 memset(s->io_buffer, 0, 0x200);
2132                 s->io_buffer[0] = 0x01; /* smart struct version */
2133                 for (n=0; n<30; n++) {
2134                     if (smart_attributes[n][0] == 0) {
2135                         break;
2136                     }
2137                     int i;
2138                     for(i = 0; i < 11; i++) {
2139                         s->io_buffer[2+i+(n*12)] = smart_attributes[n][i];
2140                     }
2141                 }
2142                 s->io_buffer[362] = 0x02 | (s->smart_autosave?0x80:0x00);
2143                 if (s->smart_selftest_count == 0) {
2144                 s->io_buffer[363] = 0;
2145                 } else {
2146                 s->io_buffer[363] =
2147                         s->smart_selftest_data[3 +
2148                                            (s->smart_selftest_count - 1) *
2149                                            24];
2150                 }
2151                 s->io_buffer[364] = 0x20;
2152                 s->io_buffer[365] = 0x01;
2153                 /* offline data collection capacity: execute + self-test*/
2154                 s->io_buffer[367] = (1<<4 | 1<<3 | 1);
2155                 s->io_buffer[368] = 0x03; /* smart capability (1) */
2156                 s->io_buffer[369] = 0x00; /* smart capability (2) */
2157                 s->io_buffer[370] = 0x01; /* error logging supported */
2158                 s->io_buffer[372] = 0x02; /* minutes for poll short test */
2159                 s->io_buffer[373] = 0x36; /* minutes for poll ext test */
2160                 s->io_buffer[374] = 0x01; /* minutes for poll conveyance */
2161
2162                 for (n=0; n<511; n++)
2163                 s->io_buffer[511] += s->io_buffer[n];
2164                 s->io_buffer[511] = 0x100 - s->io_buffer[511];
2165                 s->status = READY_STAT | SEEK_STAT;
2166                 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2167                 ide_set_irq(s->bus);
2168                 break;
2169         case SMART_READ_LOG:
2170                 switch (s->sector) {
2171                 case 0x01: /* summary smart error log */
2172                 memset(s->io_buffer, 0, 0x200);
2173                 s->io_buffer[0] = 0x01;
2174                 s->io_buffer[1] = 0x00; /* no error entries */
2175                 s->io_buffer[452] = s->smart_errors & 0xff;
2176                 s->io_buffer[453] = (s->smart_errors & 0xff00) >> 8;
2177
2178                 for (n=0; n<511; n++)
2179                         s->io_buffer[511] += s->io_buffer[n];
2180                 s->io_buffer[511] = 0x100 - s->io_buffer[511];
2181                 break;
2182                 case 0x06: /* smart self test log */
2183                 memset(s->io_buffer, 0, 0x200);
2184                 s->io_buffer[0] = 0x01;
2185                 if (s->smart_selftest_count == 0) {
2186                         s->io_buffer[508] = 0;
2187                 } else {
2188                         s->io_buffer[508] = s->smart_selftest_count;
2189                         for (n=2; n<506; n++)
2190                         s->io_buffer[n] = s->smart_selftest_data[n];
2191                 }
2192                 for (n=0; n<511; n++)
2193                         s->io_buffer[511] += s->io_buffer[n];
2194                 s->io_buffer[511] = 0x100 - s->io_buffer[511];
2195                 break;
2196                 default:
2197                 goto abort_cmd;
2198                 }
2199                 s->status = READY_STAT | SEEK_STAT;
2200                 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2201                 ide_set_irq(s->bus);
2202                 break;
2203         case SMART_EXECUTE_OFFLINE:
2204                 switch (s->sector) {
2205                 case 0: /* off-line routine */
2206                 case 1: /* short self test */
2207                 case 2: /* extended self test */
2208                 s->smart_selftest_count++;
2209                 if(s->smart_selftest_count > 21)
2210                         s->smart_selftest_count = 0;
2211                 n = 2 + (s->smart_selftest_count - 1) * 24;
2212                 s->smart_selftest_data[n] = s->sector;
2213                 s->smart_selftest_data[n+1] = 0x00; /* OK and finished */
2214                 s->smart_selftest_data[n+2] = 0x34; /* hour count lsb */
2215                 s->smart_selftest_data[n+3] = 0x12; /* hour count msb */
2216                 s->status = READY_STAT | SEEK_STAT;
2217                 ide_set_irq(s->bus);
2218                 break;
2219                 default:
2220                 goto abort_cmd;
2221                 }
2222                 break;
2223         default:
2224                 goto abort_cmd;
2225         }
2226         break;
2227     default:
2228     abort_cmd:
2229         ide_abort_command(s);
2230         ide_set_irq(s->bus);
2231         break;
2232     }
2233 }
2234
2235 uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
2236 {
2237     IDEBus *bus = opaque;
2238     IDEState *s = idebus_active_if(bus);
2239     uint32_t addr;
2240     int ret, hob;
2241
2242     addr = addr1 & 7;
2243     /* FIXME: HOB readback uses bit 7, but it's always set right now */
2244     //hob = s->select & (1 << 7);
2245     hob = 0;
2246     switch(addr) {
2247     case 0:
2248         ret = 0xff;
2249         break;
2250     case 1:
2251         if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
2252             (s != bus->ifs && !s->bs))
2253             ret = 0;
2254         else if (!hob)
2255             ret = s->error;
2256         else
2257             ret = s->hob_feature;
2258         break;
2259     case 2:
2260         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
2261             ret = 0;
2262         else if (!hob)
2263             ret = s->nsector & 0xff;
2264         else
2265             ret = s->hob_nsector;
2266         break;
2267     case 3:
2268         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
2269             ret = 0;
2270         else if (!hob)
2271             ret = s->sector;
2272         else
2273             ret = s->hob_sector;
2274         break;
2275     case 4:
2276         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
2277             ret = 0;
2278         else if (!hob)
2279             ret = s->lcyl;
2280         else
2281             ret = s->hob_lcyl;
2282         break;
2283     case 5:
2284         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
2285             ret = 0;
2286         else if (!hob)
2287             ret = s->hcyl;
2288         else
2289             ret = s->hob_hcyl;
2290         break;
2291     case 6:
2292         if (!bus->ifs[0].bs && !bus->ifs[1].bs)
2293             ret = 0;
2294         else
2295             ret = s->select;
2296         break;
2297     default:
2298     case 7:
2299         if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
2300             (s != bus->ifs && !s->bs))
2301             ret = 0;
2302         else
2303             ret = s->status;
2304         qemu_irq_lower(bus->irq);
2305         break;
2306     }
2307 #ifdef DEBUG_IDE
2308     printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
2309 #endif
2310     return ret;
2311 }
2312
2313 uint32_t ide_status_read(void *opaque, uint32_t addr)
2314 {
2315     IDEBus *bus = opaque;
2316     IDEState *s = idebus_active_if(bus);
2317     int ret;
2318
2319     if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
2320         (s != bus->ifs && !s->bs))
2321         ret = 0;
2322     else
2323         ret = s->status;
2324 #ifdef DEBUG_IDE
2325     printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
2326 #endif
2327     return ret;
2328 }
2329
2330 void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
2331 {
2332     IDEBus *bus = opaque;
2333     IDEState *s;
2334     int i;
2335
2336 #ifdef DEBUG_IDE
2337     printf("ide: write control addr=0x%x val=%02x\n", addr, val);
2338 #endif
2339     /* common for both drives */
2340     if (!(bus->cmd & IDE_CMD_RESET) &&
2341         (val & IDE_CMD_RESET)) {
2342         /* reset low to high */
2343         for(i = 0;i < 2; i++) {
2344             s = &bus->ifs[i];
2345             s->status = BUSY_STAT | SEEK_STAT;
2346             s->error = 0x01;
2347         }
2348     } else if ((bus->cmd & IDE_CMD_RESET) &&
2349                !(val & IDE_CMD_RESET)) {
2350         /* high to low */
2351         for(i = 0;i < 2; i++) {
2352             s = &bus->ifs[i];
2353             if (s->drive_kind == IDE_CD)
2354                 s->status = 0x00; /* NOTE: READY is _not_ set */
2355             else
2356                 s->status = READY_STAT | SEEK_STAT;
2357             ide_set_signature(s);
2358         }
2359     }
2360
2361     bus->cmd = val;
2362 }
2363
2364 void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
2365 {
2366     IDEBus *bus = opaque;
2367     IDEState *s = idebus_active_if(bus);
2368     uint8_t *p;
2369
2370     /* PIO data access allowed only when DRQ bit is set */
2371     if (!(s->status & DRQ_STAT))
2372         return;
2373
2374     p = s->data_ptr;
2375     *(uint16_t *)p = le16_to_cpu(val);
2376     p += 2;
2377     s->data_ptr = p;
2378     if (p >= s->data_end)
2379         s->end_transfer_func(s);
2380 }
2381
2382 uint32_t ide_data_readw(void *opaque, uint32_t addr)
2383 {
2384     IDEBus *bus = opaque;
2385     IDEState *s = idebus_active_if(bus);
2386     uint8_t *p;
2387     int ret;
2388
2389     /* PIO data access allowed only when DRQ bit is set */
2390     if (!(s->status & DRQ_STAT))
2391         return 0;
2392
2393     p = s->data_ptr;
2394     ret = cpu_to_le16(*(uint16_t *)p);
2395     p += 2;
2396     s->data_ptr = p;
2397     if (p >= s->data_end)
2398         s->end_transfer_func(s);
2399     return ret;
2400 }
2401
2402 void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
2403 {
2404     IDEBus *bus = opaque;
2405     IDEState *s = idebus_active_if(bus);
2406     uint8_t *p;
2407
2408     /* PIO data access allowed only when DRQ bit is set */
2409     if (!(s->status & DRQ_STAT))
2410         return;
2411
2412     p = s->data_ptr;
2413     *(uint32_t *)p = le32_to_cpu(val);
2414     p += 4;
2415     s->data_ptr = p;
2416     if (p >= s->data_end)
2417         s->end_transfer_func(s);
2418 }
2419
2420 uint32_t ide_data_readl(void *opaque, uint32_t addr)
2421 {
2422     IDEBus *bus = opaque;
2423     IDEState *s = idebus_active_if(bus);
2424     uint8_t *p;
2425     int ret;
2426
2427     /* PIO data access allowed only when DRQ bit is set */
2428     if (!(s->status & DRQ_STAT))
2429         return 0;
2430
2431     p = s->data_ptr;
2432     ret = cpu_to_le32(*(uint32_t *)p);
2433     p += 4;
2434     s->data_ptr = p;
2435     if (p >= s->data_end)
2436         s->end_transfer_func(s);
2437     return ret;
2438 }
2439
2440 static void ide_dummy_transfer_stop(IDEState *s)
2441 {
2442     s->data_ptr = s->io_buffer;
2443     s->data_end = s->io_buffer;
2444     s->io_buffer[0] = 0xff;
2445     s->io_buffer[1] = 0xff;
2446     s->io_buffer[2] = 0xff;
2447     s->io_buffer[3] = 0xff;
2448 }
2449
2450 static void ide_reset(IDEState *s)
2451 {
2452 #ifdef DEBUG_IDE
2453     printf("ide: reset\n");
2454 #endif
2455     if (s->drive_kind == IDE_CFATA)
2456         s->mult_sectors = 0;
2457     else
2458         s->mult_sectors = MAX_MULT_SECTORS;
2459     /* ide regs */
2460     s->feature = 0;
2461     s->error = 0;
2462     s->nsector = 0;
2463     s->sector = 0;
2464     s->lcyl = 0;
2465     s->hcyl = 0;
2466
2467     /* lba48 */
2468     s->hob_feature = 0;
2469     s->hob_sector = 0;
2470     s->hob_nsector = 0;
2471     s->hob_lcyl = 0;
2472     s->hob_hcyl = 0;
2473
2474     s->select = 0xa0;
2475     s->status = READY_STAT | SEEK_STAT;
2476
2477     s->lba48 = 0;
2478
2479     /* ATAPI specific */
2480     s->sense_key = 0;
2481     s->asc = 0;
2482     s->cdrom_changed = 0;
2483     s->packet_transfer_size = 0;
2484     s->elementary_transfer_size = 0;
2485     s->io_buffer_index = 0;
2486     s->cd_sector_size = 0;
2487     s->atapi_dma = 0;
2488     /* ATA DMA state */
2489     s->io_buffer_size = 0;
2490     s->req_nb_sectors = 0;
2491
2492     ide_set_signature(s);
2493     /* init the transfer handler so that 0xffff is returned on data
2494        accesses */
2495     s->end_transfer_func = ide_dummy_transfer_stop;
2496     ide_dummy_transfer_stop(s);
2497     s->media_changed = 0;
2498 }
2499
2500 void ide_bus_reset(IDEBus *bus)
2501 {
2502     bus->unit = 0;
2503     bus->cmd = 0;
2504     ide_reset(&bus->ifs[0]);
2505     ide_reset(&bus->ifs[1]);
2506     ide_clear_hob(bus);
2507
2508     /* pending async DMA */
2509     if (bus->dma->aiocb) {
2510 #ifdef DEBUG_AIO
2511         printf("aio_cancel\n");
2512 #endif
2513         bdrv_aio_cancel(bus->dma->aiocb);
2514         bus->dma->aiocb = NULL;
2515     }
2516
2517     /* reset dma provider too */
2518     bus->dma->ops->reset(bus->dma);
2519 }
2520
2521 int ide_init_drive(IDEState *s, BlockDriverState *bs,
2522                    const char *version, const char *serial)
2523 {
2524     int cylinders, heads, secs;
2525     uint64_t nb_sectors;
2526
2527     s->bs = bs;
2528     bdrv_get_geometry(bs, &nb_sectors);
2529     bdrv_guess_geometry(bs, &cylinders, &heads, &secs);
2530     if (cylinders < 1 || cylinders > 16383) {
2531         error_report("cyls must be between 1 and 16383");
2532         return -1;
2533     }
2534     if (heads < 1 || heads > 16) {
2535         error_report("heads must be between 1 and 16");
2536         return -1;
2537     }
2538     if (secs < 1 || secs > 63) {
2539         error_report("secs must be between 1 and 63");
2540         return -1;
2541     }
2542     s->cylinders = cylinders;
2543     s->heads = heads;
2544     s->sectors = secs;
2545     s->nb_sectors = nb_sectors;
2546     /* The SMART values should be preserved across power cycles
2547        but they aren't.  */
2548     s->smart_enabled = 1;
2549     s->smart_autosave = 1;
2550     s->smart_errors = 0;
2551     s->smart_selftest_count = 0;
2552     if (bdrv_get_type_hint(bs) == BDRV_TYPE_CDROM) {
2553         s->drive_kind = IDE_CD;
2554         bdrv_set_change_cb(bs, cdrom_change_cb, s);
2555         bs->buffer_alignment = 2048;
2556     } else {
2557         if (!bdrv_is_inserted(s->bs)) {
2558             error_report("Device needs media, but drive is empty");
2559             return -1;
2560         }
2561         if (bdrv_is_read_only(bs)) {
2562             error_report("Can't use a read-only drive");
2563             return -1;
2564         }
2565     }
2566     if (serial) {
2567         strncpy(s->drive_serial_str, serial, sizeof(s->drive_serial_str));
2568     } else {
2569         snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),
2570                  "QM%05d", s->drive_serial);
2571     }
2572     if (version) {
2573         pstrcpy(s->version, sizeof(s->version), version);
2574     } else {
2575         pstrcpy(s->version, sizeof(s->version), QEMU_VERSION);
2576     }
2577
2578     ide_reset(s);
2579     bdrv_set_removable(bs, s->drive_kind == IDE_CD);
2580     return 0;
2581 }
2582
2583 static void ide_init1(IDEBus *bus, int unit)
2584 {
2585     static int drive_serial = 1;
2586     IDEState *s = &bus->ifs[unit];
2587
2588     s->bus = bus;
2589     s->unit = unit;
2590     s->drive_serial = drive_serial++;
2591     /* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
2592     s->io_buffer = qemu_memalign(2048, IDE_DMA_BUF_SECTORS*512 + 4);
2593     s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
2594     s->smart_selftest_data = qemu_blockalign(s->bs, 512);
2595     s->sector_write_timer = qemu_new_timer_ns(vm_clock,
2596                                            ide_sector_write_timer_cb, s);
2597 }
2598
2599 static void ide_nop_start(IDEDMA *dma, IDEState *s,
2600                           BlockDriverCompletionFunc *cb)
2601 {
2602 }
2603
2604 static int ide_nop(IDEDMA *dma)
2605 {
2606     return 0;
2607 }
2608
2609 static int ide_nop_int(IDEDMA *dma, int x)
2610 {
2611     return 0;
2612 }
2613
2614 static void ide_nop_restart(void *opaque, int x, int y)
2615 {
2616 }
2617
2618 static const IDEDMAOps ide_dma_nop_ops = {
2619     .start_dma      = ide_nop_start,
2620     .start_transfer = ide_nop,
2621     .prepare_buf    = ide_nop_int,
2622     .rw_buf         = ide_nop_int,
2623     .set_unit       = ide_nop_int,
2624     .add_status     = ide_nop_int,
2625     .set_inactive   = ide_nop,
2626     .restart_cb     = ide_nop_restart,
2627     .reset          = ide_nop,
2628 };
2629
2630 static IDEDMA ide_dma_nop = {
2631     .ops = &ide_dma_nop_ops,
2632     .aiocb = NULL,
2633 };
2634
2635 void ide_init2(IDEBus *bus, qemu_irq irq)
2636 {
2637     int i;
2638
2639     for(i = 0; i < 2; i++) {
2640         ide_init1(bus, i);
2641         ide_reset(&bus->ifs[i]);
2642     }
2643     bus->irq = irq;
2644     bus->dma = &ide_dma_nop;
2645 }
2646
2647 /* TODO convert users to qdev and remove */
2648 void ide_init2_with_non_qdev_drives(IDEBus *bus, DriveInfo *hd0,
2649                                     DriveInfo *hd1, qemu_irq irq)
2650 {
2651     int i;
2652     DriveInfo *dinfo;
2653
2654     for(i = 0; i < 2; i++) {
2655         dinfo = i == 0 ? hd0 : hd1;
2656         ide_init1(bus, i);
2657         if (dinfo) {
2658             if (ide_init_drive(&bus->ifs[i], dinfo->bdrv, NULL,
2659                                *dinfo->serial ? dinfo->serial : NULL) < 0) {
2660                 error_report("Can't set up IDE drive %s", dinfo->id);
2661                 exit(1);
2662             }
2663         } else {
2664             ide_reset(&bus->ifs[i]);
2665         }
2666     }
2667     bus->irq = irq;
2668     bus->dma = &ide_dma_nop;
2669 }
2670
2671 void ide_init_ioport(IDEBus *bus, int iobase, int iobase2)
2672 {
2673     register_ioport_write(iobase, 8, 1, ide_ioport_write, bus);
2674     register_ioport_read(iobase, 8, 1, ide_ioport_read, bus);
2675     if (iobase2) {
2676         register_ioport_read(iobase2, 1, 1, ide_status_read, bus);
2677         register_ioport_write(iobase2, 1, 1, ide_cmd_write, bus);
2678     }
2679
2680     /* data ports */
2681     register_ioport_write(iobase, 2, 2, ide_data_writew, bus);
2682     register_ioport_read(iobase, 2, 2, ide_data_readw, bus);
2683     register_ioport_write(iobase, 4, 4, ide_data_writel, bus);
2684     register_ioport_read(iobase, 4, 4, ide_data_readl, bus);
2685 }
2686
2687 static bool is_identify_set(void *opaque, int version_id)
2688 {
2689     IDEState *s = opaque;
2690
2691     return s->identify_set != 0;
2692 }
2693
2694 static EndTransferFunc* transfer_end_table[] = {
2695         ide_sector_read,
2696         ide_sector_write,
2697         ide_transfer_stop,
2698         ide_atapi_cmd_reply_end,
2699         ide_atapi_cmd,
2700         ide_dummy_transfer_stop,
2701 };
2702
2703 static int transfer_end_table_idx(EndTransferFunc *fn)
2704 {
2705     int i;
2706
2707     for (i = 0; i < ARRAY_SIZE(transfer_end_table); i++)
2708         if (transfer_end_table[i] == fn)
2709             return i;
2710
2711     return -1;
2712 }
2713
2714 static int ide_drive_post_load(void *opaque, int version_id)
2715 {
2716     IDEState *s = opaque;
2717
2718     if (version_id < 3) {
2719         if (s->sense_key == SENSE_UNIT_ATTENTION &&
2720             s->asc == ASC_MEDIUM_MAY_HAVE_CHANGED) {
2721             s->cdrom_changed = 1;
2722         }
2723     }
2724     return 0;
2725 }
2726
2727 static int ide_drive_pio_post_load(void *opaque, int version_id)
2728 {
2729     IDEState *s = opaque;
2730
2731     if (s->end_transfer_fn_idx > ARRAY_SIZE(transfer_end_table)) {
2732         return -EINVAL;
2733     }
2734     s->end_transfer_func = transfer_end_table[s->end_transfer_fn_idx];
2735     s->data_ptr = s->io_buffer + s->cur_io_buffer_offset;
2736     s->data_end = s->data_ptr + s->cur_io_buffer_len;
2737
2738     return 0;
2739 }
2740
2741 static void ide_drive_pio_pre_save(void *opaque)
2742 {
2743     IDEState *s = opaque;
2744     int idx;
2745
2746     s->cur_io_buffer_offset = s->data_ptr - s->io_buffer;
2747     s->cur_io_buffer_len = s->data_end - s->data_ptr;
2748
2749     idx = transfer_end_table_idx(s->end_transfer_func);
2750     if (idx == -1) {
2751         fprintf(stderr, "%s: invalid end_transfer_func for DRQ_STAT\n",
2752                         __func__);
2753         s->end_transfer_fn_idx = 2;
2754     } else {
2755         s->end_transfer_fn_idx = idx;
2756     }
2757 }
2758
2759 static bool ide_drive_pio_state_needed(void *opaque)
2760 {
2761     IDEState *s = opaque;
2762
2763     return (s->status & DRQ_STAT) != 0;
2764 }
2765
2766 const VMStateDescription vmstate_ide_drive_pio_state = {
2767     .name = "ide_drive/pio_state",
2768     .version_id = 1,
2769     .minimum_version_id = 1,
2770     .minimum_version_id_old = 1,
2771     .pre_save = ide_drive_pio_pre_save,
2772     .post_load = ide_drive_pio_post_load,
2773     .fields      = (VMStateField []) {
2774         VMSTATE_INT32(req_nb_sectors, IDEState),
2775         VMSTATE_VARRAY_INT32(io_buffer, IDEState, io_buffer_total_len, 1,
2776                              vmstate_info_uint8, uint8_t),
2777         VMSTATE_INT32(cur_io_buffer_offset, IDEState),
2778         VMSTATE_INT32(cur_io_buffer_len, IDEState),
2779         VMSTATE_UINT8(end_transfer_fn_idx, IDEState),
2780         VMSTATE_INT32(elementary_transfer_size, IDEState),
2781         VMSTATE_INT32(packet_transfer_size, IDEState),
2782         VMSTATE_END_OF_LIST()
2783     }
2784 };
2785
2786 const VMStateDescription vmstate_ide_drive = {
2787     .name = "ide_drive",
2788     .version_id = 3,
2789     .minimum_version_id = 0,
2790     .minimum_version_id_old = 0,
2791     .post_load = ide_drive_post_load,
2792     .fields      = (VMStateField []) {
2793         VMSTATE_INT32(mult_sectors, IDEState),
2794         VMSTATE_INT32(identify_set, IDEState),
2795         VMSTATE_BUFFER_TEST(identify_data, IDEState, is_identify_set),
2796         VMSTATE_UINT8(feature, IDEState),
2797         VMSTATE_UINT8(error, IDEState),
2798         VMSTATE_UINT32(nsector, IDEState),
2799         VMSTATE_UINT8(sector, IDEState),
2800         VMSTATE_UINT8(lcyl, IDEState),
2801         VMSTATE_UINT8(hcyl, IDEState),
2802         VMSTATE_UINT8(hob_feature, IDEState),
2803         VMSTATE_UINT8(hob_sector, IDEState),
2804         VMSTATE_UINT8(hob_nsector, IDEState),
2805         VMSTATE_UINT8(hob_lcyl, IDEState),
2806         VMSTATE_UINT8(hob_hcyl, IDEState),
2807         VMSTATE_UINT8(select, IDEState),
2808         VMSTATE_UINT8(status, IDEState),
2809         VMSTATE_UINT8(lba48, IDEState),
2810         VMSTATE_UINT8(sense_key, IDEState),
2811         VMSTATE_UINT8(asc, IDEState),
2812         VMSTATE_UINT8_V(cdrom_changed, IDEState, 3),
2813         VMSTATE_END_OF_LIST()
2814     },
2815     .subsections = (VMStateSubsection []) {
2816         {
2817             .vmsd = &vmstate_ide_drive_pio_state,
2818             .needed = ide_drive_pio_state_needed,
2819         }, {
2820             /* empty */
2821         }
2822     }
2823 };
2824
2825 const VMStateDescription vmstate_ide_bus = {
2826     .name = "ide_bus",
2827     .version_id = 1,
2828     .minimum_version_id = 1,
2829     .minimum_version_id_old = 1,
2830     .fields      = (VMStateField []) {
2831         VMSTATE_UINT8(cmd, IDEBus),
2832         VMSTATE_UINT8(unit, IDEBus),
2833         VMSTATE_END_OF_LIST()
2834     }
2835 };
2836
2837 void ide_drive_get(DriveInfo **hd, int max_bus)
2838 {
2839     int i;
2840
2841     if (drive_get_max_bus(IF_IDE) >= max_bus) {
2842         fprintf(stderr, "qemu: too many IDE bus: %d\n", max_bus);
2843         exit(1);
2844     }
2845
2846     for(i = 0; i < max_bus * MAX_IDE_DEVS; i++) {
2847         hd[i] = drive_get(IF_IDE, i / MAX_IDE_DEVS, i % MAX_IDE_DEVS);
2848     }
2849 }