vcs.maemo.org Git - qemu/blob - hw/ide.c

   1 /*
   2  * QEMU IDE disk and CD-ROM Emulator
   3  *
   4  * Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "vl.h"
  25
  26 /* debug IDE devices */
  27 //#define DEBUG_IDE
  28 //#define DEBUG_IDE_ATAPI
  29
  30 /* Bits of HD_STATUS */
  31 #define ERR_STAT                0x01
  32 #define INDEX_STAT              0x02
  33 #define ECC_STAT                0x04    /* Corrected error */
  34 #define DRQ_STAT                0x08
  35 #define SEEK_STAT               0x10
  36 #define SRV_STAT                0x10
  37 #define WRERR_STAT              0x20
  38 #define READY_STAT              0x40
  39 #define BUSY_STAT               0x80
  40
  41 /* Bits for HD_ERROR */
  42 #define MARK_ERR                0x01    /* Bad address mark */
  43 #define TRK0_ERR                0x02    /* couldn't find track 0 */
  44 #define ABRT_ERR                0x04    /* Command aborted */
  45 #define MCR_ERR                 0x08    /* media change request */
  46 #define ID_ERR                  0x10    /* ID field not found */
  47 #define MC_ERR                  0x20    /* media changed */
  48 #define ECC_ERR                 0x40    /* Uncorrectable ECC error */
  49 #define BBD_ERR                 0x80    /* pre-EIDE meaning:  block marked bad */
  50 #define ICRC_ERR                0x80    /* new meaning:  CRC error during transfer */
  51
  52 /* Bits of HD_NSECTOR */
  53 #define CD                      0x01
  54 #define IO                      0x02
  55 #define REL                     0x04
  56 #define TAG_MASK                0xf8
  57
  58 #define IDE_CMD_RESET           0x04
  59 #define IDE_CMD_DISABLE_IRQ     0x02
  60
  61 /* ATA/ATAPI Commands pre T13 Spec */
  62 #define WIN_NOP                         0x00
  63 /*
  64  *      0x01->0x02 Reserved
  65  */
  66 #define CFA_REQ_EXT_ERROR_CODE          0x03 /* CFA Request Extended Error Code */
  67 /*
  68  *      0x04->0x07 Reserved
  69  */
  70 #define WIN_SRST                        0x08 /* ATAPI soft reset command */
  71 #define WIN_DEVICE_RESET                0x08
  72 /*
  73  *      0x09->0x0F Reserved
  74  */
  75 #define WIN_RECAL                       0x10
  76 #define WIN_RESTORE                     WIN_RECAL
  77 /*
  78  *      0x10->0x1F Reserved
  79  */
  80 #define WIN_READ                        0x20 /* 28-Bit */
  81 #define WIN_READ_ONCE                   0x21 /* 28-Bit without retries */
  82 #define WIN_READ_LONG                   0x22 /* 28-Bit */
  83 #define WIN_READ_LONG_ONCE              0x23 /* 28-Bit without retries */
  84 #define WIN_READ_EXT                    0x24 /* 48-Bit */
  85 #define WIN_READDMA_EXT                 0x25 /* 48-Bit */
  86 #define WIN_READDMA_QUEUED_EXT          0x26 /* 48-Bit */
  87 #define WIN_READ_NATIVE_MAX_EXT         0x27 /* 48-Bit */
  88 /*
  89  *      0x28
  90  */
  91 #define WIN_MULTREAD_EXT                0x29 /* 48-Bit */
  92 /*
  93  *      0x2A->0x2F Reserved
  94  */
  95 #define WIN_WRITE                       0x30 /* 28-Bit */
  96 #define WIN_WRITE_ONCE                  0x31 /* 28-Bit without retries */
  97 #define WIN_WRITE_LONG                  0x32 /* 28-Bit */
  98 #define WIN_WRITE_LONG_ONCE             0x33 /* 28-Bit without retries */
  99 #define WIN_WRITE_EXT                   0x34 /* 48-Bit */
 100 #define WIN_WRITEDMA_EXT                0x35 /* 48-Bit */
 101 #define WIN_WRITEDMA_QUEUED_EXT         0x36 /* 48-Bit */
 102 #define WIN_SET_MAX_EXT                 0x37 /* 48-Bit */
 103 #define CFA_WRITE_SECT_WO_ERASE         0x38 /* CFA Write Sectors without erase */
 104 #define WIN_MULTWRITE_EXT               0x39 /* 48-Bit */
 105 /*
 106  *      0x3A->0x3B Reserved
 107  */
 108 #define WIN_WRITE_VERIFY                0x3C /* 28-Bit */
 109 /*
 110  *      0x3D->0x3F Reserved
 111  */
 112 #define WIN_VERIFY                      0x40 /* 28-Bit - Read Verify Sectors */
 113 #define WIN_VERIFY_ONCE                 0x41 /* 28-Bit - without retries */
 114 #define WIN_VERIFY_EXT                  0x42 /* 48-Bit */
 115 /*
 116  *      0x43->0x4F Reserved
 117  */
 118 #define WIN_FORMAT                      0x50
 119 /*
 120  *      0x51->0x5F Reserved
 121  */
 122 #define WIN_INIT                        0x60
 123 /*
 124  *      0x61->0x5F Reserved
 125  */
 126 #define WIN_SEEK                        0x70 /* 0x70-0x7F Reserved */
 127 #define CFA_TRANSLATE_SECTOR            0x87 /* CFA Translate Sector */
 128 #define WIN_DIAGNOSE                    0x90
 129 #define WIN_SPECIFY                     0x91 /* set drive geometry translation */
 130 #define WIN_DOWNLOAD_MICROCODE          0x92
 131 #define WIN_STANDBYNOW2                 0x94
 132 #define WIN_STANDBY2                    0x96
 133 #define WIN_SETIDLE2                    0x97
 134 #define WIN_CHECKPOWERMODE2             0x98
 135 #define WIN_SLEEPNOW2                   0x99
 136 /*
 137  *      0x9A VENDOR
 138  */
 139 #define WIN_PACKETCMD                   0xA0 /* Send a packet command. */
 140 #define WIN_PIDENTIFY                   0xA1 /* identify ATAPI device   */
 141 #define WIN_QUEUED_SERVICE              0xA2
 142 #define WIN_SMART                       0xB0 /* self-monitoring and reporting */
 143 #define CFA_ERASE_SECTORS               0xC0
 144 #define WIN_MULTREAD                    0xC4 /* read sectors using multiple mode*/
 145 #define WIN_MULTWRITE                   0xC5 /* write sectors using multiple mode */
 146 #define WIN_SETMULT                     0xC6 /* enable/disable multiple mode */
 147 #define WIN_READDMA_QUEUED              0xC7 /* read sectors using Queued DMA transfers */
 148 #define WIN_READDMA                     0xC8 /* read sectors using DMA transfers */
 149 #define WIN_READDMA_ONCE                0xC9 /* 28-Bit - without retries */
 150 #define WIN_WRITEDMA                    0xCA /* write sectors using DMA transfers */
 151 #define WIN_WRITEDMA_ONCE               0xCB /* 28-Bit - without retries */
 152 #define WIN_WRITEDMA_QUEUED             0xCC /* write sectors using Queued DMA transfers */
 153 #define CFA_WRITE_MULTI_WO_ERASE        0xCD /* CFA Write multiple without erase */
 154 #define WIN_GETMEDIASTATUS              0xDA
 155 #define WIN_ACKMEDIACHANGE              0xDB /* ATA-1, ATA-2 vendor */
 156 #define WIN_POSTBOOT                    0xDC
 157 #define WIN_PREBOOT                     0xDD
 158 #define WIN_DOORLOCK                    0xDE /* lock door on removable drives */
 159 #define WIN_DOORUNLOCK                  0xDF /* unlock door on removable drives */
 160 #define WIN_STANDBYNOW1                 0xE0
 161 #define WIN_IDLEIMMEDIATE               0xE1 /* force drive to become "ready" */
 162 #define WIN_STANDBY                     0xE2 /* Set device in Standby Mode */
 163 #define WIN_SETIDLE1                    0xE3
 164 #define WIN_READ_BUFFER                 0xE4 /* force read only 1 sector */
 165 #define WIN_CHECKPOWERMODE1             0xE5
 166 #define WIN_SLEEPNOW1                   0xE6
 167 #define WIN_FLUSH_CACHE                 0xE7
 168 #define WIN_WRITE_BUFFER                0xE8 /* force write only 1 sector */
 169 #define WIN_WRITE_SAME                  0xE9 /* read ata-2 to use */
 170         /* SET_FEATURES 0x22 or 0xDD */
 171 #define WIN_FLUSH_CACHE_EXT             0xEA /* 48-Bit */
 172 #define WIN_IDENTIFY                    0xEC /* ask drive to identify itself    */
 173 #define WIN_MEDIAEJECT                  0xED
 174 #define WIN_IDENTIFY_DMA                0xEE /* same as WIN_IDENTIFY, but DMA */
 175 #define WIN_SETFEATURES                 0xEF /* set special drive features */
 176 #define EXABYTE_ENABLE_NEST             0xF0
 177 #define WIN_SECURITY_SET_PASS           0xF1
 178 #define WIN_SECURITY_UNLOCK             0xF2
 179 #define WIN_SECURITY_ERASE_PREPARE      0xF3
 180 #define WIN_SECURITY_ERASE_UNIT         0xF4
 181 #define WIN_SECURITY_FREEZE_LOCK        0xF5
 182 #define WIN_SECURITY_DISABLE            0xF6
 183 #define WIN_READ_NATIVE_MAX             0xF8 /* return the native maximum address */
 184 #define WIN_SET_MAX                     0xF9
 185 #define DISABLE_SEAGATE                 0xFB
 186
 187 /* set to 1 set disable mult support */
 188 #define MAX_MULT_SECTORS 8
 189
 190 /* ATAPI defines */
 191
 192 #define ATAPI_PACKET_SIZE 12
 193
 194 /* The generic packet command opcodes for CD/DVD Logical Units,
 195  * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
 196 #define GPCMD_BLANK                         0xa1
 197 #define GPCMD_CLOSE_TRACK                   0x5b
 198 #define GPCMD_FLUSH_CACHE                   0x35
 199 #define GPCMD_FORMAT_UNIT                   0x04
 200 #define GPCMD_GET_CONFIGURATION             0x46
 201 #define GPCMD_GET_EVENT_STATUS_NOTIFICATION 0x4a
 202 #define GPCMD_GET_PERFORMANCE               0xac
 203 #define GPCMD_INQUIRY                       0x12
 204 #define GPCMD_LOAD_UNLOAD                   0xa6
 205 #define GPCMD_MECHANISM_STATUS              0xbd
 206 #define GPCMD_MODE_SELECT_10                0x55
 207 #define GPCMD_MODE_SENSE_10                 0x5a
 208 #define GPCMD_PAUSE_RESUME                  0x4b
 209 #define GPCMD_PLAY_AUDIO_10                 0x45
 210 #define GPCMD_PLAY_AUDIO_MSF                0x47
 211 #define GPCMD_PLAY_AUDIO_TI                 0x48
 212 #define GPCMD_PLAY_CD                       0xbc
 213 #define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL  0x1e
 214 #define GPCMD_READ_10                       0x28
 215 #define GPCMD_READ_12                       0xa8
 216 #define GPCMD_READ_CDVD_CAPACITY            0x25
 217 #define GPCMD_READ_CD                       0xbe
 218 #define GPCMD_READ_CD_MSF                   0xb9
 219 #define GPCMD_READ_DISC_INFO                0x51
 220 #define GPCMD_READ_DVD_STRUCTURE            0xad
 221 #define GPCMD_READ_FORMAT_CAPACITIES        0x23
 222 #define GPCMD_READ_HEADER                   0x44
 223 #define GPCMD_READ_TRACK_RZONE_INFO         0x52
 224 #define GPCMD_READ_SUBCHANNEL               0x42
 225 #define GPCMD_READ_TOC_PMA_ATIP             0x43
 226 #define GPCMD_REPAIR_RZONE_TRACK            0x58
 227 #define GPCMD_REPORT_KEY                    0xa4
 228 #define GPCMD_REQUEST_SENSE                 0x03
 229 #define GPCMD_RESERVE_RZONE_TRACK           0x53
 230 #define GPCMD_SCAN                          0xba
 231 #define GPCMD_SEEK                          0x2b
 232 #define GPCMD_SEND_DVD_STRUCTURE            0xad
 233 #define GPCMD_SEND_EVENT                    0xa2
 234 #define GPCMD_SEND_KEY                      0xa3
 235 #define GPCMD_SEND_OPC                      0x54
 236 #define GPCMD_SET_READ_AHEAD                0xa7
 237 #define GPCMD_SET_STREAMING                 0xb6
 238 #define GPCMD_START_STOP_UNIT               0x1b
 239 #define GPCMD_STOP_PLAY_SCAN                0x4e
 240 #define GPCMD_TEST_UNIT_READY               0x00
 241 #define GPCMD_VERIFY_10                     0x2f
 242 #define GPCMD_WRITE_10                      0x2a
 243 #define GPCMD_WRITE_AND_VERIFY_10           0x2e
 244 /* This is listed as optional in ATAPI 2.6, but is (curiously)
 245  * missing from Mt. Fuji, Table 57.  It _is_ mentioned in Mt. Fuji
 246  * Table 377 as an MMC command for SCSi devices though...  Most ATAPI
 247  * drives support it. */
 248 #define GPCMD_SET_SPEED                     0xbb
 249 /* This seems to be a SCSI specific CD-ROM opcode
 250  * to play data at track/index */
 251 #define GPCMD_PLAYAUDIO_TI                  0x48
 252 /*
 253  * From MS Media Status Notification Support Specification. For
 254  * older drives only.
 255  */
 256 #define GPCMD_GET_MEDIA_STATUS              0xda
 257
 258 /* Mode page codes for mode sense/set */
 259 #define GPMODE_R_W_ERROR_PAGE           0x01
 260 #define GPMODE_WRITE_PARMS_PAGE         0x05
 261 #define GPMODE_AUDIO_CTL_PAGE           0x0e
 262 #define GPMODE_POWER_PAGE               0x1a
 263 #define GPMODE_FAULT_FAIL_PAGE          0x1c
 264 #define GPMODE_TO_PROTECT_PAGE          0x1d
 265 #define GPMODE_CAPABILITIES_PAGE        0x2a
 266 #define GPMODE_ALL_PAGES                0x3f
 267 /* Not in Mt. Fuji, but in ATAPI 2.6 -- depricated now in favor
 268  * of MODE_SENSE_POWER_PAGE */
 269 #define GPMODE_CDROM_PAGE               0x0d
 270
 271 #define ATAPI_INT_REASON_CD             0x01 /* 0 = data transfer */
 272 #define ATAPI_INT_REASON_IO             0x02 /* 1 = transfer to the host */
 273 #define ATAPI_INT_REASON_REL            0x04
 274 #define ATAPI_INT_REASON_TAG            0xf8
 275
 276 /* same constants as bochs */
 277 #define ASC_ILLEGAL_OPCODE                   0x20
 278 #define ASC_LOGICAL_BLOCK_OOR                0x21
 279 #define ASC_INV_FIELD_IN_CMD_PACKET          0x24
 280 #define ASC_MEDIUM_NOT_PRESENT               0x3a
 281 #define ASC_SAVING_PARAMETERS_NOT_SUPPORTED  0x39
 282
 283 #define SENSE_NONE            0
 284 #define SENSE_NOT_READY       2
 285 #define SENSE_ILLEGAL_REQUEST 5
 286 #define SENSE_UNIT_ATTENTION  6
 287
 288 struct IDEState;
 289
 290 typedef void EndTransferFunc(struct IDEState *);
 291
 292 /* NOTE: IDEState represents in fact one drive */
 293 typedef struct IDEState {
 294     /* ide config */
 295     int is_cdrom;
 296     int cylinders, heads, sectors;
 297     int64_t nb_sectors;
 298     int mult_sectors;
 299     int irq;
 300     /* ide regs */
 301     uint8_t feature;
 302     uint8_t error;
 303     uint16_t nsector; /* 0 is 256 to ease computations */
 304     uint8_t sector;
 305     uint8_t lcyl;
 306     uint8_t hcyl;
 307     uint8_t select;
 308     uint8_t status;
 309     /* 0x3f6 command, only meaningful for drive 0 */
 310     uint8_t cmd;
 311     /* depends on bit 4 in select, only meaningful for drive 0 */
 312     struct IDEState *cur_drive;
 313     BlockDriverState *bs;
 314     /* ATAPI specific */
 315     uint8_t sense_key;
 316     uint8_t asc;
 317     int packet_transfer_size;
 318     int elementary_transfer_size;
 319     int io_buffer_index;
 320     int lba;
 321     /* transfer handling */
 322     int req_nb_sectors; /* number of sectors per interrupt */
 323     EndTransferFunc *end_transfer_func;
 324     uint8_t *data_ptr;
 325     uint8_t *data_end;
 326     uint8_t io_buffer[MAX_MULT_SECTORS*512 + 4];
 327 } IDEState;
 328
 329 static void padstr(char *str, const char *src, int len)
 330 {
 331     int i, v;
 332     for(i = 0; i < len; i++) {
 333         if (*src)
 334             v = *src++;
 335         else
 336             v = ' ';
 337         *(char *)((long)str ^ 1) = v;
 338         str++;
 339     }
 340 }
 341
 342 static void padstr8(uint8_t *buf, int buf_size, const char *src)
 343 {
 344     int i;
 345     for(i = 0; i < buf_size; i++) {
 346         if (*src)
 347             buf[i] = *src++;
 348         else
 349             buf[i] = ' ';
 350     }
 351 }
 352
 353 static void put_le16(uint16_t *p, unsigned int v)
 354 {
 355 #ifdef WORDS_BIGENDIAN
 356     *p = bswap16(v);
 357 #else
 358     *p = v;
 359 #endif
 360 }
 361
 362 static void ide_identify(IDEState *s)
 363 {
 364     uint16_t *p;
 365     unsigned int oldsize;
 366
 367     memset(s->io_buffer, 0, 512);
 368     p = (uint16_t *)s->io_buffer;
 369     put_le16(p + 0, 0x0040);
 370     put_le16(p + 1, s->cylinders);
 371     put_le16(p + 3, s->heads);
 372     put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
 373     put_le16(p + 5, 512); /* XXX: retired, remove ? */
 374     put_le16(p + 6, s->sectors);
 375     padstr((uint8_t *)(p + 10), "QM00001", 20); /* serial number */
 376     put_le16(p + 20, 3); /* XXX: retired, remove ? */
 377     put_le16(p + 21, 512); /* cache size in sectors */
 378     put_le16(p + 22, 4); /* ecc bytes */
 379     padstr((uint8_t *)(p + 23), QEMU_VERSION, 8); /* firmware version */
 380     padstr((uint8_t *)(p + 27), "QEMU HARDDISK", 40); /* model */
 381 #if MAX_MULT_SECTORS > 1
 382     put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
 383 #endif
 384     put_le16(p + 48, 1); /* dword I/O */
 385     put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
 386     put_le16(p + 51, 0x200); /* PIO transfer cycle */
 387     put_le16(p + 52, 0x200); /* DMA transfer cycle */
 388     put_le16(p + 53, 1); /* words 54-58 are valid */
 389     put_le16(p + 54, s->cylinders);
 390     put_le16(p + 55, s->heads);
 391     put_le16(p + 56, s->sectors);
 392     oldsize = s->cylinders * s->heads * s->sectors;
 393     put_le16(p + 57, oldsize);
 394     put_le16(p + 58, oldsize >> 16);
 395     if (s->mult_sectors)
 396         put_le16(p + 59, 0x100 | s->mult_sectors);
 397     put_le16(p + 60, s->nb_sectors);
 398     put_le16(p + 61, s->nb_sectors >> 16);
 399     put_le16(p + 80, (1 << 1) | (1 << 2));
 400     put_le16(p + 82, (1 << 14));
 401     put_le16(p + 83, (1 << 14));
 402     put_le16(p + 84, (1 << 14));
 403     put_le16(p + 85, (1 << 14));
 404     put_le16(p + 86, 0);
 405     put_le16(p + 87, (1 << 14));
 406 }
 407
 408 static void ide_atapi_identify(IDEState *s)
 409 {
 410     uint16_t *p;
 411
 412     memset(s->io_buffer, 0, 512);
 413     p = (uint16_t *)s->io_buffer;
 414     /* Removable CDROM, 50us response, 12 byte packets */
 415     put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
 416     put_le16(p + 1, s->cylinders);
 417     put_le16(p + 3, s->heads);
 418     put_le16(p + 4, 512 * s->sectors); /* sectors */
 419     put_le16(p + 5, 512); /* sector size */
 420     put_le16(p + 6, s->sectors);
 421     padstr((uint8_t *)(p + 10), "QM00001", 20); /* serial number */
 422     put_le16(p + 20, 3); /* buffer type */
 423     put_le16(p + 21, 512); /* cache size in sectors */
 424     put_le16(p + 22, 4); /* ecc bytes */
 425     padstr((uint8_t *)(p + 23), QEMU_VERSION, 8); /* firmware version */
 426     padstr((uint8_t *)(p + 27), "QEMU CD-ROM", 40); /* model */
 427     put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
 428     put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
 429     put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
 430     put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
 431     put_le16(p + 64, 1); /* PIO modes */
 432     put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
 433     put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
 434     put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
 435     put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
 436
 437     put_le16(p + 71, 30); /* in ns */
 438     put_le16(p + 72, 30); /* in ns */
 439
 440     put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
 441 }
 442
 443 static void ide_set_signature(IDEState *s)
 444 {
 445     s->select &= 0xf0; /* clear head */
 446     /* put signature */
 447     s->nsector = 1;
 448     s->sector = 1;
 449     if (s->is_cdrom) {
 450         s->lcyl = 0x14;
 451         s->hcyl = 0xeb;
 452     } else if (s->bs) {
 453         s->lcyl = 0;
 454         s->hcyl = 0;
 455     } else {
 456         s->lcyl = 0xff;
 457         s->hcyl = 0xff;
 458     }
 459 }
 460
 461 static inline void ide_abort_command(IDEState *s)
 462 {
 463     s->status = READY_STAT | ERR_STAT;
 464     s->error = ABRT_ERR;
 465 }
 466
 467 static inline void ide_set_irq(IDEState *s)
 468 {
 469     if (!(s->cmd & IDE_CMD_DISABLE_IRQ)) {
 470         pic_set_irq(s->irq, 1);
 471     }
 472 }
 473
 474 /* prepare data transfer and tell what to do after */
 475 static void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
 476                                EndTransferFunc *end_transfer_func)
 477 {
 478     s->end_transfer_func = end_transfer_func;
 479     s->data_ptr = buf;
 480     s->data_end = buf + size;
 481     s->status |= DRQ_STAT;
 482 }
 483
 484 static void ide_transfer_stop(IDEState *s)
 485 {
 486     s->end_transfer_func = ide_transfer_stop;
 487     s->data_ptr = s->io_buffer;
 488     s->data_end = s->io_buffer;
 489     s->status &= ~DRQ_STAT;
 490 }
 491
 492 static int64_t ide_get_sector(IDEState *s)
 493 {
 494     int64_t sector_num;
 495     if (s->select & 0x40) {
 496         /* lba */
 497         sector_num = ((s->select & 0x0f) << 24) | (s->hcyl << 16) |
 498             (s->lcyl << 8) | s->sector;
 499     } else {
 500         sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
 501             (s->select & 0x0f) * s->sectors +
 502             (s->sector - 1);
 503     }
 504     return sector_num;
 505 }
 506
 507 static void ide_set_sector(IDEState *s, int64_t sector_num)
 508 {
 509     unsigned int cyl, r;
 510     if (s->select & 0x40) {
 511         s->select = (s->select & 0xf0) | (sector_num >> 24);
 512         s->hcyl = (sector_num >> 16);
 513         s->lcyl = (sector_num >> 8);
 514         s->sector = (sector_num);
 515     } else {
 516         cyl = sector_num / (s->heads * s->sectors);
 517         r = sector_num % (s->heads * s->sectors);
 518         s->hcyl = cyl >> 8;
 519         s->lcyl = cyl;
 520         s->select = (s->select & 0xf0) | (r / s->sectors);
 521         s->sector = (r % s->sectors) + 1;
 522     }
 523 }
 524
 525 static void ide_sector_read(IDEState *s)
 526 {
 527     int64_t sector_num;
 528     int ret, n;
 529
 530     s->status = READY_STAT | SEEK_STAT;
 531     s->error = 0; /* not needed by IDE spec, but needed by Windows */
 532     sector_num = ide_get_sector(s);
 533     n = s->nsector;
 534     if (n == 0) {
 535         /* no more sector to read from disk */
 536         ide_transfer_stop(s);
 537     } else {
 538 #if defined(DEBUG_IDE)
 539         printf("read sector=%Ld\n", sector_num);
 540 #endif
 541         if (n > s->req_nb_sectors)
 542             n = s->req_nb_sectors;
 543         ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
 544         ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_read);
 545         ide_set_irq(s);
 546         ide_set_sector(s, sector_num + n);
 547         s->nsector -= n;
 548     }
 549 }
 550
 551 static void ide_sector_write(IDEState *s)
 552 {
 553     int64_t sector_num;
 554     int ret, n, n1;
 555
 556     s->status = READY_STAT | SEEK_STAT;
 557     sector_num = ide_get_sector(s);
 558 #if defined(DEBUG_IDE)
 559     printf("write sector=%Ld\n", sector_num);
 560 #endif
 561     n = s->nsector;
 562     if (n > s->req_nb_sectors)
 563         n = s->req_nb_sectors;
 564     ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
 565     s->nsector -= n;
 566     if (s->nsector == 0) {
 567         /* no more sector to write */
 568         ide_transfer_stop(s);
 569     } else {
 570         n1 = s->nsector;
 571         if (n1 > s->req_nb_sectors)
 572             n1 = s->req_nb_sectors;
 573         ide_transfer_start(s, s->io_buffer, 512 * n1, ide_sector_write);
 574     }
 575     ide_set_sector(s, sector_num + n);
 576     ide_set_irq(s);
 577 }
 578
 579 static void ide_atapi_cmd_ok(IDEState *s)
 580 {
 581     s->error = 0;
 582     s->status = READY_STAT;
 583     s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 584     ide_set_irq(s);
 585 }
 586
 587 static void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc)
 588 {
 589 #ifdef DEBUG_IDE_ATAPI
 590     printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key, asc);
 591 #endif
 592     s->error = sense_key << 4;
 593     s->status = READY_STAT | ERR_STAT;
 594     s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 595     s->sense_key = sense_key;
 596     s->asc = asc;
 597     ide_set_irq(s);
 598 }
 599
 600 static inline void cpu_to_ube16(uint8_t *buf, int val)
 601 {
 602     buf[0] = val >> 8;
 603     buf[1] = val;
 604 }
 605
 606 static inline void cpu_to_ube32(uint8_t *buf, unsigned int val)
 607 {
 608     buf[0] = val >> 24;
 609     buf[1] = val >> 16;
 610     buf[2] = val >> 8;
 611     buf[3] = val;
 612 }
 613
 614 static inline int ube16_to_cpu(const uint8_t *buf)
 615 {
 616     return (buf[0] << 8) | buf[1];
 617 }
 618
 619 static inline int ube32_to_cpu(const uint8_t *buf)
 620 {
 621     return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
 622 }
 623
 624 /* The whole ATAPI transfer logic is handled in this function */
 625 static void ide_atapi_cmd_reply_end(IDEState *s)
 626 {
 627     int byte_count_limit, size;
 628 #ifdef DEBUG_IDE_ATAPI
 629     printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
 630            s->packet_transfer_size,
 631            s->elementary_transfer_size,
 632            s->io_buffer_index);
 633 #endif
 634     if (s->packet_transfer_size <= 0) {
 635         /* end of transfer */
 636         ide_transfer_stop(s);
 637         s->status = READY_STAT;
 638         s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
 639         ide_set_irq(s);
 640 #ifdef DEBUG_IDE_ATAPI
 641         printf("status=0x%x\n", s->status);
 642 #endif
 643     } else {
 644         /* see if a new sector must be read */
 645         if (s->lba != -1 && s->io_buffer_index >= 2048) {
 646             bdrv_read(s->bs, (int64_t)s->lba << 2, s->io_buffer, 4);
 647             s->lba++;
 648             s->io_buffer_index = 0;
 649         }
 650         if (s->elementary_transfer_size > 0) {
 651             /* there are some data left to transmit in this elementary
 652                transfer */
 653             size = 2048 - s->io_buffer_index;
 654             if (size > s->elementary_transfer_size)
 655                 size = s->elementary_transfer_size;
 656             ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
 657                                size, ide_atapi_cmd_reply_end);
 658             s->packet_transfer_size -= size;
 659             s->elementary_transfer_size -= size;
 660             s->io_buffer_index += size;
 661         } else {
 662             /* a new transfer is needed */
 663             s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
 664             byte_count_limit = s->lcyl | (s->hcyl << 8);
 665 #ifdef DEBUG_IDE_ATAPI
 666             printf("byte_count_limit=%d\n", byte_count_limit);
 667 #endif
 668             if (byte_count_limit == 0xffff)
 669                 byte_count_limit--;
 670             size = s->packet_transfer_size;
 671             if (size > byte_count_limit) {
 672                 /* byte count limit must be even if this case */
 673                 if (byte_count_limit & 1)
 674                     byte_count_limit--;
 675                 size = byte_count_limit;
 676             }
 677             s->lcyl = size;
 678             s->hcyl = size >> 8;
 679             s->elementary_transfer_size = size;
 680             /* we cannot transmit more than one sector at a time */
 681             if (s->lba != -1) {
 682                 if (size > (2048 - s->io_buffer_index))
 683                     size = (2048 - s->io_buffer_index);
 684             }
 685             ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
 686                                size, ide_atapi_cmd_reply_end);
 687             s->packet_transfer_size -= size;
 688             s->elementary_transfer_size -= size;
 689             s->io_buffer_index += size;
 690             ide_set_irq(s);
 691 #ifdef DEBUG_IDE_ATAPI
 692             printf("status=0x%x\n", s->status);
 693 #endif
 694         }
 695     }
 696 }
 697
 698 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
 699 static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
 700 {
 701     if (size > max_size)
 702         size = max_size;
 703     s->lba = -1; /* no sector read */
 704     s->packet_transfer_size = size;
 705     s->elementary_transfer_size = 0;
 706     s->io_buffer_index = 0;
 707
 708     s->status = READY_STAT;
 709     ide_atapi_cmd_reply_end(s);
 710 }
 711
 712 /* start a CD-CDROM read command */
 713 static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors)
 714 {
 715 #ifdef DEBUG_IDE_ATAPI
 716     printf("read: LBA=%d nb_sectors=%d\n", lba, nb_sectors);
 717 #endif
 718     s->lba = lba;
 719     s->packet_transfer_size = nb_sectors * 2048;
 720     s->elementary_transfer_size = 0;
 721     s->io_buffer_index = 2048;
 722
 723     s->status = READY_STAT;
 724     ide_atapi_cmd_reply_end(s);
 725 }
 726
 727 /* same toc as bochs. Return -1 if error or the toc length */
 728 static int cdrom_read_toc(IDEState *s, uint8_t *buf, int msf, int start_track)
 729 {
 730     uint8_t *q;
 731     int nb_sectors, len;
 732
 733     if (start_track > 1 && start_track != 0xaa)
 734         return -1;
 735     q = buf + 2;
 736     *q++ = 1;
 737     *q++ = 1;
 738     if (start_track <= 1) {
 739         *q++ = 0; /* reserved */
 740         *q++ = 0x14; /* ADR, control */
 741         *q++ = 1;    /* track number */
 742         *q++ = 0; /* reserved */
 743         if (msf) {
 744             *q++ = 0; /* reserved */
 745             *q++ = 0; /* minute */
 746             *q++ = 2; /* second */
 747             *q++ = 0; /* frame */
 748         } else {
 749             /* sector 0 */
 750             cpu_to_ube32(q, 0);
 751             q += 4;
 752         }
 753     }
 754     /* lead out track */
 755     *q++ = 0; /* reserved */
 756     *q++ = 0x16; /* ADR, control */
 757     *q++ = 0xaa; /* track number */
 758     *q++ = 0; /* reserved */
 759     nb_sectors = s->nb_sectors >> 2;
 760     if (msf) {
 761         *q++ = 0; /* reserved */
 762         *q++ = ((nb_sectors + 150) / 75) / 60;
 763         *q++ = ((nb_sectors + 150) / 75) % 60;
 764         *q++ = (nb_sectors + 150) % 75;
 765     } else {
 766         cpu_to_ube32(q, nb_sectors);
 767         q += 4;
 768     }
 769     len = q - buf;
 770     cpu_to_ube16(buf, len - 2);
 771     return len;
 772 }
 773
 774 static void ide_atapi_cmd(IDEState *s)
 775 {
 776     const uint8_t *packet;
 777     uint8_t *buf;
 778     int max_len;
 779
 780     packet = s->io_buffer;
 781     buf = s->io_buffer;
 782 #ifdef DEBUG_IDE_ATAPI
 783     {
 784         int i;
 785         printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8));
 786         for(i = 0; i < ATAPI_PACKET_SIZE; i++) {
 787             printf(" %02x", packet[i]);
 788         }
 789         printf("\n");
 790     }
 791 #endif
 792     switch(s->io_buffer[0]) {
 793     case GPCMD_TEST_UNIT_READY:
 794         if (bdrv_is_inserted(s->bs)) {
 795             ide_atapi_cmd_ok(s);
 796         } else {
 797             ide_atapi_cmd_error(s, SENSE_NOT_READY,
 798                                 ASC_MEDIUM_NOT_PRESENT);
 799         }
 800         break;
 801     case GPCMD_MODE_SENSE_10:
 802         {
 803             int action, code;
 804             max_len = ube16_to_cpu(packet + 7);
 805             action = packet[2] >> 6;
 806             code = packet[2] & 0x3f;
 807             switch(action) {
 808             case 0: /* current values */
 809                 switch(code) {
 810                 case 0x01: /* error recovery */
 811                     cpu_to_ube16(&buf[0], 16 + 6);
 812                     buf[2] = 0x70;
 813                     buf[3] = 0;
 814                     buf[4] = 0;
 815                     buf[5] = 0;
 816                     buf[6] = 0;
 817                     buf[7] = 0;
 818
 819                     buf[8] = 0x01;
 820                     buf[9] = 0x06;
 821                     buf[10] = 0x00;
 822                     buf[11] = 0x05;
 823                     buf[12] = 0x00;
 824                     buf[13] = 0x00;
 825                     buf[14] = 0x00;
 826                     buf[15] = 0x00;
 827                     ide_atapi_cmd_reply(s, 16, max_len);
 828                     break;
 829                 case 0x2a:
 830                     cpu_to_ube16(&buf[0], 28 + 6);
 831                     buf[2] = 0x70;
 832                     buf[3] = 0;
 833                     buf[4] = 0;
 834                     buf[5] = 0;
 835                     buf[6] = 0;
 836                     buf[7] = 0;
 837
 838                     buf[8] = 0x2a;
 839                     buf[9] = 0x12;
 840                     buf[10] = 0x00;
 841                     buf[11] = 0x00;
 842
 843                     buf[12] = 0x70;
 844                     buf[13] = 3 << 5;
 845                     buf[14] = (1 << 0) | (1 << 3) | (1 << 5);
 846                     if (bdrv_is_locked(s->bs))
 847                         buf[6] |= 1 << 1;
 848                     buf[15] = 0x00;
 849                     cpu_to_ube16(&buf[16], 706);
 850                     buf[18] = 0;
 851                     buf[19] = 2;
 852                     cpu_to_ube16(&buf[20], 512);
 853                     cpu_to_ube16(&buf[22], 706);
 854                     buf[24] = 0;
 855                     buf[25] = 0;
 856                     buf[26] = 0;
 857                     buf[27] = 0;
 858                     ide_atapi_cmd_reply(s, 28, max_len);
 859                     break;
 860                 default:
 861                     goto error_cmd;
 862                 }
 863                 break;
 864             case 1: /* changeable values */
 865                 goto error_cmd;
 866             case 2: /* default values */
 867                 goto error_cmd;
 868             default:
 869             case 3: /* saved values */
 870                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
 871                                     ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
 872                 break;
 873             }
 874         }
 875         break;
 876     case GPCMD_REQUEST_SENSE:
 877         max_len = packet[4];
 878         memset(buf, 0, 18);
 879         buf[0] = 0x70 | (1 << 7);
 880         buf[2] = s->sense_key;
 881         buf[7] = 10;
 882         buf[12] = s->asc;
 883         ide_atapi_cmd_reply(s, 18, max_len);
 884         break;
 885     case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
 886         if (bdrv_is_inserted(s->bs)) {
 887             bdrv_set_locked(s->bs, packet[4] & 1);
 888             ide_atapi_cmd_ok(s);
 889         } else {
 890             ide_atapi_cmd_error(s, SENSE_NOT_READY,
 891                                 ASC_MEDIUM_NOT_PRESENT);
 892         }
 893         break;
 894     case GPCMD_READ_10:
 895     case GPCMD_READ_12:
 896         {
 897             int nb_sectors, lba;
 898
 899             if (!bdrv_is_inserted(s->bs)) {
 900                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
 901                                     ASC_MEDIUM_NOT_PRESENT);
 902                 break;
 903             }
 904             if (packet[0] == GPCMD_READ_10)
 905                 nb_sectors = ube16_to_cpu(packet + 7);
 906             else
 907                 nb_sectors = ube32_to_cpu(packet + 6);
 908             lba = ube32_to_cpu(packet + 2);
 909             if (nb_sectors == 0) {
 910                 ide_atapi_cmd_ok(s);
 911                 break;
 912             }
 913             if (((int64_t)(lba + nb_sectors) << 2) > s->nb_sectors) {
 914                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
 915                                     ASC_LOGICAL_BLOCK_OOR);
 916                 break;
 917             }
 918             ide_atapi_cmd_read(s, lba, nb_sectors);
 919         }
 920         break;
 921     case GPCMD_SEEK:
 922         {
 923             int lba;
 924             if (!bdrv_is_inserted(s->bs)) {
 925                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
 926                                     ASC_MEDIUM_NOT_PRESENT);
 927                 break;
 928             }
 929             lba = ube32_to_cpu(packet + 2);
 930             if (((int64_t)lba << 2) > s->nb_sectors) {
 931                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
 932                                     ASC_LOGICAL_BLOCK_OOR);
 933                 break;
 934             }
 935             ide_atapi_cmd_ok(s);
 936         }
 937         break;
 938     case GPCMD_START_STOP_UNIT:
 939         {
 940             int start, eject;
 941             start = packet[4] & 1;
 942             eject = (packet[4] >> 1) & 1;
 943
 944             if (eject && !start) {
 945                 /* eject the disk */
 946                 bdrv_close(s->bs);
 947             }
 948             ide_atapi_cmd_ok(s);
 949         }
 950         break;
 951     case GPCMD_MECHANISM_STATUS:
 952         {
 953             max_len = ube16_to_cpu(packet + 8);
 954             cpu_to_ube16(buf, 0);
 955             /* no current LBA */
 956             buf[2] = 0;
 957             buf[3] = 0;
 958             buf[4] = 0;
 959             buf[5] = 1;
 960             cpu_to_ube16(buf + 6, 0);
 961             ide_atapi_cmd_reply(s, 8, max_len);
 962         }
 963         break;
 964     case GPCMD_READ_TOC_PMA_ATIP:
 965         {
 966             int format, msf, start_track, len;
 967
 968             if (!bdrv_is_inserted(s->bs)) {
 969                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
 970                                     ASC_MEDIUM_NOT_PRESENT);
 971                 break;
 972             }
 973             max_len = ube16_to_cpu(packet + 7);
 974             format = packet[9] >> 6;
 975             msf = (packet[1] >> 1) & 1;
 976             start_track = packet[6];
 977             switch(format) {
 978             case 0:
 979                 len = cdrom_read_toc(s, buf, msf, start_track);
 980                 if (len < 0)
 981                     goto error_cmd;
 982                 ide_atapi_cmd_reply(s, len, max_len);
 983                 break;
 984             case 1:
 985                 /* multi session : only a single session defined */
 986                 memset(buf, 0, 12);
 987                 buf[1] = 0x0a;
 988                 buf[2] = 0x01;
 989                 buf[3] = 0x01;
 990                 ide_atapi_cmd_reply(s, 12, max_len);
 991                 break;
 992             default:
 993             error_cmd:
 994                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
 995                                     ASC_INV_FIELD_IN_CMD_PACKET);
 996                 break;
 997             }
 998         }
 999         break;
1000     case GPCMD_READ_CDVD_CAPACITY:
1001         if (!bdrv_is_inserted(s->bs)) {
1002             ide_atapi_cmd_error(s, SENSE_NOT_READY,
1003                                 ASC_MEDIUM_NOT_PRESENT);
1004             break;
1005         }
1006         /* NOTE: it is really the number of sectors minus 1 */
1007         cpu_to_ube32(buf, (s->nb_sectors >> 2) - 1);
1008         cpu_to_ube32(buf + 4, 2048);
1009         ide_atapi_cmd_reply(s, 8, 8);
1010         break;
1011     case GPCMD_INQUIRY:
1012         max_len = packet[4];
1013         buf[0] = 0x05; /* CD-ROM */
1014         buf[1] = 0x80; /* removable */
1015         buf[2] = 0x00; /* ISO */
1016         buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1017         buf[4] = 31; /* additionnal length */
1018         buf[5] = 0; /* reserved */
1019         buf[6] = 0; /* reserved */
1020         buf[7] = 0; /* reserved */
1021         padstr8(buf + 8, 8, "QEMU");
1022         padstr8(buf + 16, 16, "QEMU CD-ROM");
1023         padstr8(buf + 32, 4, QEMU_VERSION);
1024         ide_atapi_cmd_reply(s, 36, max_len);
1025         break;
1026     default:
1027         ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1028                             ASC_ILLEGAL_OPCODE);
1029         break;
1030     }
1031 }
1032
1033 /* called when the inserted state of the media has changed */
1034 static void cdrom_change_cb(void *opaque)
1035 {
1036     IDEState *s = opaque;
1037     int64_t nb_sectors;
1038
1039     /* XXX: send interrupt too */
1040     bdrv_get_geometry(s->bs, &nb_sectors);
1041     s->nb_sectors = nb_sectors;
1042 }
1043
1044 static void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
1045 {
1046     IDEState *ide_if = opaque;
1047     IDEState *s;
1048     int unit, n;
1049
1050 #ifdef DEBUG_IDE
1051     printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
1052 #endif
1053     addr &= 7;
1054     switch(addr) {
1055     case 0:
1056         break;
1057     case 1:
1058         /* NOTE: data is written to the two drives */
1059         ide_if[0].feature = val;
1060         ide_if[1].feature = val;
1061         break;
1062     case 2:
1063         if (val == 0)
1064             val = 256;
1065         ide_if[0].nsector = val;
1066         ide_if[1].nsector = val;
1067         break;
1068     case 3:
1069         ide_if[0].sector = val;
1070         ide_if[1].sector = val;
1071         break;
1072     case 4:
1073         ide_if[0].lcyl = val;
1074         ide_if[1].lcyl = val;
1075         break;
1076     case 5:
1077         ide_if[0].hcyl = val;
1078         ide_if[1].hcyl = val;
1079         break;
1080     case 6:
1081         ide_if[0].select = val & 0x4f;
1082         ide_if[1].select = val & 0x4f;
1083         /* select drive */
1084         unit = (val >> 4) & 1;
1085         s = ide_if + unit;
1086         ide_if->cur_drive = s;
1087         break;
1088     default:
1089     case 7:
1090         /* command */
1091 #if defined(DEBUG_IDE)
1092         printf("ide: CMD=%02x\n", val);
1093 #endif
1094         s = ide_if->cur_drive;
1095         switch(val) {
1096         case WIN_IDENTIFY:
1097             if (s->bs && !s->is_cdrom) {
1098                 ide_identify(s);
1099                 s->status = READY_STAT;
1100                 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1101             } else {
1102                 if (s->is_cdrom) {
1103                     ide_set_signature(s);
1104                 }
1105                 ide_abort_command(s);
1106             }
1107             ide_set_irq(s);
1108             break;
1109         case WIN_SPECIFY:
1110         case WIN_RECAL:
1111             s->error = 0;
1112             s->status = READY_STAT;
1113             ide_set_irq(s);
1114             break;
1115         case WIN_SETMULT:
1116             if (s->nsector > MAX_MULT_SECTORS ||
1117                 s->nsector == 0 ||
1118                 (s->nsector & (s->nsector - 1)) != 0) {
1119                 ide_abort_command(s);
1120             } else {
1121                 s->mult_sectors = s->nsector;
1122                 s->status = READY_STAT;
1123             }
1124             ide_set_irq(s);
1125             break;
1126         case WIN_VERIFY:
1127         case WIN_VERIFY_ONCE:
1128             /* do sector number check ? */
1129             s->status = READY_STAT;
1130             ide_set_irq(s);
1131             break;
1132         case WIN_READ:
1133         case WIN_READ_ONCE:
1134             if (!s->bs)
1135                 goto abort_cmd;
1136             s->req_nb_sectors = 1;
1137             ide_sector_read(s);
1138             break;
1139         case WIN_WRITE:
1140         case WIN_WRITE_ONCE:
1141             s->error = 0;
1142             s->status = SEEK_STAT;
1143             s->req_nb_sectors = 1;
1144             ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
1145             break;
1146         case WIN_MULTREAD:
1147             if (!s->mult_sectors)
1148                 goto abort_cmd;
1149             s->req_nb_sectors = s->mult_sectors;
1150             ide_sector_read(s);
1151             break;
1152         case WIN_MULTWRITE:
1153             if (!s->mult_sectors)
1154                 goto abort_cmd;
1155             s->error = 0;
1156             s->status = SEEK_STAT;
1157             s->req_nb_sectors = s->mult_sectors;
1158             n = s->nsector;
1159             if (n > s->req_nb_sectors)
1160                 n = s->req_nb_sectors;
1161             ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
1162             break;
1163         case WIN_READ_NATIVE_MAX:
1164             ide_set_sector(s, s->nb_sectors - 1);
1165             s->status = READY_STAT;
1166             ide_set_irq(s);
1167             break;
1168         case WIN_CHECKPOWERMODE1:
1169             s->nsector = 0xff; /* device active or idle */
1170             s->status = READY_STAT;
1171             ide_set_irq(s);
1172             break;
1173
1174             /* ATAPI commands */
1175         case WIN_PIDENTIFY:
1176             if (s->is_cdrom) {
1177                 ide_atapi_identify(s);
1178                 s->status = READY_STAT;
1179                 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1180             } else {
1181                 ide_abort_command(s);
1182             }
1183             ide_set_irq(s);
1184             break;
1185         case WIN_SRST:
1186             if (!s->is_cdrom)
1187                 goto abort_cmd;
1188             ide_set_signature(s);
1189             s->status = 0x00; /* NOTE: READY is _not_ set */
1190             s->error = 0x01;
1191             break;
1192         case WIN_PACKETCMD:
1193             if (!s->is_cdrom)
1194                 goto abort_cmd;
1195             /* DMA or overlapping commands not supported */
1196             if ((s->feature & 0x03) != 0)
1197                 goto abort_cmd;
1198             s->nsector = 1;
1199             ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
1200                                ide_atapi_cmd);
1201             break;
1202         default:
1203         abort_cmd:
1204             ide_abort_command(s);
1205             ide_set_irq(s);
1206             break;
1207         }
1208     }
1209 }
1210
1211 static uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
1212 {
1213     IDEState *s = ((IDEState *)opaque)->cur_drive;
1214     uint32_t addr;
1215     int ret;
1216
1217     addr = addr1 & 7;
1218     switch(addr) {
1219     case 0:
1220         ret = 0xff;
1221         break;
1222     case 1:
1223         if (!s->bs)
1224             ret = 0;
1225         else
1226             ret = s->error;
1227         break;
1228     case 2:
1229         if (!s->bs)
1230             ret = 0;
1231         else
1232             ret = s->nsector & 0xff;
1233         break;
1234     case 3:
1235         if (!s->bs)
1236             ret = 0;
1237         else
1238             ret = s->sector;
1239         break;
1240     case 4:
1241         if (!s->bs)
1242             ret = 0;
1243         else
1244             ret = s->lcyl;
1245         break;
1246     case 5:
1247         if (!s->bs)
1248             ret = 0;
1249         else
1250             ret = s->hcyl;
1251         break;
1252     case 6:
1253         if (!s->bs)
1254             ret = 0;
1255         else
1256             ret = s->select | 0xa0;
1257         break;
1258     default:
1259     case 7:
1260         if (!s->bs)
1261             ret = 0;
1262         else
1263             ret = s->status;
1264         pic_set_irq(s->irq, 0);
1265         break;
1266     }
1267 #ifdef DEBUG_IDE
1268     printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
1269 #endif
1270     return ret;
1271 }
1272
1273 static uint32_t ide_status_read(void *opaque, uint32_t addr)
1274 {
1275     IDEState *s = ((IDEState *)opaque)->cur_drive;
1276     int ret;
1277     ret = s->status;
1278 #ifdef DEBUG_IDE
1279     printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
1280 #endif
1281     return ret;
1282 }
1283
1284 static void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
1285 {
1286     IDEState *ide_if = opaque;
1287     IDEState *s;
1288     int i;
1289
1290 #ifdef DEBUG_IDE
1291     printf("ide: write control addr=0x%x val=%02x\n", addr, val);
1292 #endif
1293     /* common for both drives */
1294     if (!(ide_if[0].cmd & IDE_CMD_RESET) &&
1295         (val & IDE_CMD_RESET)) {
1296         /* reset low to high */
1297         for(i = 0;i < 2; i++) {
1298             s = &ide_if[i];
1299             s->status = BUSY_STAT | SEEK_STAT;
1300             s->error = 0x01;
1301         }
1302     } else if ((ide_if[0].cmd & IDE_CMD_RESET) &&
1303                !(val & IDE_CMD_RESET)) {
1304         /* high to low */
1305         for(i = 0;i < 2; i++) {
1306             s = &ide_if[i];
1307             if (s->is_cdrom)
1308                 s->status = 0x00; /* NOTE: READY is _not_ set */
1309             else
1310                 s->status = READY_STAT | SEEK_STAT;
1311             ide_set_signature(s);
1312         }
1313     }
1314
1315     ide_if[0].cmd = val;
1316     ide_if[1].cmd = val;
1317 }
1318
1319 static void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
1320 {
1321     IDEState *s = ((IDEState *)opaque)->cur_drive;
1322     uint8_t *p;
1323
1324     p = s->data_ptr;
1325     *(uint16_t *)p = tswap16(val);
1326     p += 2;
1327     s->data_ptr = p;
1328     if (p >= s->data_end)
1329         s->end_transfer_func(s);
1330 }
1331
1332 static uint32_t ide_data_readw(void *opaque, uint32_t addr)
1333 {
1334     IDEState *s = ((IDEState *)opaque)->cur_drive;
1335     uint8_t *p;
1336     int ret;
1337     p = s->data_ptr;
1338     ret = tswap16(*(uint16_t *)p);
1339     p += 2;
1340     s->data_ptr = p;
1341     if (p >= s->data_end)
1342         s->end_transfer_func(s);
1343     return ret;
1344 }
1345
1346 static void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
1347 {
1348     IDEState *s = ((IDEState *)opaque)->cur_drive;
1349     uint8_t *p;
1350
1351     p = s->data_ptr;
1352     *(uint32_t *)p = tswap32(val);
1353     p += 4;
1354     s->data_ptr = p;
1355     if (p >= s->data_end)
1356         s->end_transfer_func(s);
1357 }
1358
1359 static uint32_t ide_data_readl(void *opaque, uint32_t addr)
1360 {
1361     IDEState *s = ((IDEState *)opaque)->cur_drive;
1362     uint8_t *p;
1363     int ret;
1364
1365     p = s->data_ptr;
1366     ret = tswap32(*(uint32_t *)p);
1367     p += 4;
1368     s->data_ptr = p;
1369     if (p >= s->data_end)
1370         s->end_transfer_func(s);
1371     return ret;
1372 }
1373
1374 static void ide_reset(IDEState *s)
1375 {
1376     s->mult_sectors = MAX_MULT_SECTORS;
1377     s->cur_drive = s;
1378     s->select = 0xa0;
1379     s->status = READY_STAT;
1380     ide_set_signature(s);
1381 }
1382
1383 struct partition {
1384         uint8_t boot_ind;               /* 0x80 - active */
1385         uint8_t head;           /* starting head */
1386         uint8_t sector;         /* starting sector */
1387         uint8_t cyl;            /* starting cylinder */
1388         uint8_t sys_ind;                /* What partition type */
1389         uint8_t end_head;               /* end head */
1390         uint8_t end_sector;     /* end sector */
1391         uint8_t end_cyl;                /* end cylinder */
1392         uint32_t start_sect;    /* starting sector counting from 0 */
1393         uint32_t nr_sects;              /* nr of sectors in partition */
1394 } __attribute__((packed));
1395
1396 /* try to guess the IDE geometry from the MSDOS partition table */
1397 static void ide_guess_geometry(IDEState *s)
1398 {
1399     uint8_t buf[512];
1400     int ret, i;
1401     struct partition *p;
1402     uint32_t nr_sects;
1403
1404     if (s->cylinders != 0)
1405         return;
1406     ret = bdrv_read(s->bs, 0, buf, 1);
1407     if (ret < 0)
1408         return;
1409     /* test msdos magic */
1410     if (buf[510] != 0x55 || buf[511] != 0xaa)
1411         return;
1412     for(i = 0; i < 4; i++) {
1413         p = ((struct partition *)(buf + 0x1be)) + i;
1414         nr_sects = tswap32(p->nr_sects);
1415         if (nr_sects && p->end_head) {
1416             /* We make the assumption that the partition terminates on
1417                a cylinder boundary */
1418             s->heads = p->end_head + 1;
1419             s->sectors = p->end_sector & 63;
1420             s->cylinders = s->nb_sectors / (s->heads * s->sectors);
1421 #if 0
1422             printf("guessed partition: CHS=%d %d %d\n",
1423                    s->cylinders, s->heads, s->sectors);
1424 #endif
1425         }
1426     }
1427 }
1428
1429 void ide_init(int iobase, int iobase2, int irq,
1430               BlockDriverState *hd0, BlockDriverState *hd1)
1431 {
1432     IDEState *s, *ide_state;
1433     int i, cylinders, heads, secs;
1434     int64_t nb_sectors;
1435
1436     ide_state = qemu_mallocz(sizeof(IDEState) * 2);
1437     if (!ide_state)
1438         return;
1439
1440     for(i = 0; i < 2; i++) {
1441         s = ide_state + i;
1442         if (i == 0)
1443             s->bs = hd0;
1444         else
1445             s->bs = hd1;
1446         if (s->bs) {
1447             bdrv_get_geometry(s->bs, &nb_sectors);
1448             s->nb_sectors = nb_sectors;
1449             /* if a geometry hint is available, use it */
1450             bdrv_get_geometry_hint(s->bs, &cylinders, &heads, &secs);
1451             if (cylinders != 0) {
1452                 s->cylinders = cylinders;
1453                 s->heads = heads;
1454                 s->sectors = secs;
1455             } else {
1456                 ide_guess_geometry(s);
1457                 if (s->cylinders == 0) {
1458                     /* if no geometry, use a LBA compatible one */
1459                     cylinders = nb_sectors / (16 * 63);
1460                     if (cylinders > 16383)
1461                         cylinders = 16383;
1462                     else if (cylinders < 2)
1463                         cylinders = 2;
1464                     s->cylinders = cylinders;
1465                     s->heads = 16;
1466                     s->sectors = 63;
1467                 }
1468             }
1469             if (bdrv_get_type_hint(s->bs) == BDRV_TYPE_CDROM) {
1470                 s->is_cdrom = 1;
1471                 bdrv_set_change_cb(s->bs, cdrom_change_cb, s);
1472             }
1473         }
1474         s->irq = irq;
1475         ide_reset(s);
1476     }
1477     register_ioport_write(iobase, 8, 1, ide_ioport_write, ide_state);
1478     register_ioport_read(iobase, 8, 1, ide_ioport_read, ide_state);
1479     if (iobase2) {
1480         register_ioport_read(iobase2, 1, 1, ide_status_read, ide_state);
1481         register_ioport_write(iobase2, 1, 1, ide_cmd_write, ide_state);
1482     }
1483
1484     /* data ports */
1485     register_ioport_write(iobase, 2, 2, ide_data_writew, ide_state);
1486     register_ioport_read(iobase, 2, 2, ide_data_readw, ide_state);
1487     register_ioport_write(iobase, 4, 4, ide_data_writel, ide_state);
1488     register_ioport_read(iobase, 4, 4, ide_data_readl, ide_state);
1489 }