git.maemo.org Git - qemu/blob - hw/ide.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.h"
  26 #include "pc.h"
  27 #include "pci.h"
  28 #include "scsi-disk.h"
  29 #include "pcmcia.h"
  30 #include "block.h"
  31 #include "qemu-timer.h"
  32 #include "sysemu.h"
  33 #include "ppc_mac.h"
  34
  35 /* debug IDE devices */
  36 //#define DEBUG_IDE
  37 //#define DEBUG_IDE_ATAPI
  38 //#define DEBUG_AIO
  39 #define USE_DMA_CDROM
  40
  41 /* Bits of HD_STATUS */
  42 #define ERR_STAT                0x01
  43 #define INDEX_STAT              0x02
  44 #define ECC_STAT                0x04    /* Corrected error */
  45 #define DRQ_STAT                0x08
  46 #define SEEK_STAT               0x10
  47 #define SRV_STAT                0x10
  48 #define WRERR_STAT              0x20
  49 #define READY_STAT              0x40
  50 #define BUSY_STAT               0x80
  51
  52 /* Bits for HD_ERROR */
  53 #define MARK_ERR                0x01    /* Bad address mark */
  54 #define TRK0_ERR                0x02    /* couldn't find track 0 */
  55 #define ABRT_ERR                0x04    /* Command aborted */
  56 #define MCR_ERR                 0x08    /* media change request */
  57 #define ID_ERR                  0x10    /* ID field not found */
  58 #define MC_ERR                  0x20    /* media changed */
  59 #define ECC_ERR                 0x40    /* Uncorrectable ECC error */
  60 #define BBD_ERR                 0x80    /* pre-EIDE meaning:  block marked bad */
  61 #define ICRC_ERR                0x80    /* new meaning:  CRC error during transfer */
  62
  63 /* Bits of HD_NSECTOR */
  64 #define CD                      0x01
  65 #define IO                      0x02
  66 #define REL                     0x04
  67 #define TAG_MASK                0xf8
  68
  69 #define IDE_CMD_RESET           0x04
  70 #define IDE_CMD_DISABLE_IRQ     0x02
  71
  72 /* ATA/ATAPI Commands pre T13 Spec */
  73 #define WIN_NOP                         0x00
  74 /*
  75  *      0x01->0x02 Reserved
  76  */
  77 #define CFA_REQ_EXT_ERROR_CODE          0x03 /* CFA Request Extended Error Code */
  78 /*
  79  *      0x04->0x07 Reserved
  80  */
  81 #define WIN_SRST                        0x08 /* ATAPI soft reset command */
  82 #define WIN_DEVICE_RESET                0x08
  83 /*
  84  *      0x09->0x0F Reserved
  85  */
  86 #define WIN_RECAL                       0x10
  87 #define WIN_RESTORE                     WIN_RECAL
  88 /*
  89  *      0x10->0x1F Reserved
  90  */
  91 #define WIN_READ                        0x20 /* 28-Bit */
  92 #define WIN_READ_ONCE                   0x21 /* 28-Bit without retries */
  93 #define WIN_READ_LONG                   0x22 /* 28-Bit */
  94 #define WIN_READ_LONG_ONCE              0x23 /* 28-Bit without retries */
  95 #define WIN_READ_EXT                    0x24 /* 48-Bit */
  96 #define WIN_READDMA_EXT                 0x25 /* 48-Bit */
  97 #define WIN_READDMA_QUEUED_EXT          0x26 /* 48-Bit */
  98 #define WIN_READ_NATIVE_MAX_EXT         0x27 /* 48-Bit */
  99 /*
 100  *      0x28
 101  */
 102 #define WIN_MULTREAD_EXT                0x29 /* 48-Bit */
 103 /*
 104  *      0x2A->0x2F Reserved
 105  */
 106 #define WIN_WRITE                       0x30 /* 28-Bit */
 107 #define WIN_WRITE_ONCE                  0x31 /* 28-Bit without retries */
 108 #define WIN_WRITE_LONG                  0x32 /* 28-Bit */
 109 #define WIN_WRITE_LONG_ONCE             0x33 /* 28-Bit without retries */
 110 #define WIN_WRITE_EXT                   0x34 /* 48-Bit */
 111 #define WIN_WRITEDMA_EXT                0x35 /* 48-Bit */
 112 #define WIN_WRITEDMA_QUEUED_EXT         0x36 /* 48-Bit */
 113 #define WIN_SET_MAX_EXT                 0x37 /* 48-Bit */
 114 #define CFA_WRITE_SECT_WO_ERASE         0x38 /* CFA Write Sectors without erase */
 115 #define WIN_MULTWRITE_EXT               0x39 /* 48-Bit */
 116 /*
 117  *      0x3A->0x3B Reserved
 118  */
 119 #define WIN_WRITE_VERIFY                0x3C /* 28-Bit */
 120 /*
 121  *      0x3D->0x3F Reserved
 122  */
 123 #define WIN_VERIFY                      0x40 /* 28-Bit - Read Verify Sectors */
 124 #define WIN_VERIFY_ONCE                 0x41 /* 28-Bit - without retries */
 125 #define WIN_VERIFY_EXT                  0x42 /* 48-Bit */
 126 /*
 127  *      0x43->0x4F Reserved
 128  */
 129 #define WIN_FORMAT                      0x50
 130 /*
 131  *      0x51->0x5F Reserved
 132  */
 133 #define WIN_INIT                        0x60
 134 /*
 135  *      0x61->0x5F Reserved
 136  */
 137 #define WIN_SEEK                        0x70 /* 0x70-0x7F Reserved */
 138 #define CFA_TRANSLATE_SECTOR            0x87 /* CFA Translate Sector */
 139 #define WIN_DIAGNOSE                    0x90
 140 #define WIN_SPECIFY                     0x91 /* set drive geometry translation */
 141 #define WIN_DOWNLOAD_MICROCODE          0x92
 142 #define WIN_STANDBYNOW2                 0x94
 143 #define CFA_IDLEIMMEDIATE               0x95 /* force drive to become "ready" */
 144 #define WIN_STANDBY2                    0x96
 145 #define WIN_SETIDLE2                    0x97
 146 #define WIN_CHECKPOWERMODE2             0x98
 147 #define WIN_SLEEPNOW2                   0x99
 148 /*
 149  *      0x9A VENDOR
 150  */
 151 #define WIN_PACKETCMD                   0xA0 /* Send a packet command. */
 152 #define WIN_PIDENTIFY                   0xA1 /* identify ATAPI device   */
 153 #define WIN_QUEUED_SERVICE              0xA2
 154 #define WIN_SMART                       0xB0 /* self-monitoring and reporting */
 155 #define CFA_ACCESS_METADATA_STORAGE     0xB8
 156 #define CFA_ERASE_SECTORS               0xC0 /* microdrives implement as NOP */
 157 #define WIN_MULTREAD                    0xC4 /* read sectors using multiple mode*/
 158 #define WIN_MULTWRITE                   0xC5 /* write sectors using multiple mode */
 159 #define WIN_SETMULT                     0xC6 /* enable/disable multiple mode */
 160 #define WIN_READDMA_QUEUED              0xC7 /* read sectors using Queued DMA transfers */
 161 #define WIN_READDMA                     0xC8 /* read sectors using DMA transfers */
 162 #define WIN_READDMA_ONCE                0xC9 /* 28-Bit - without retries */
 163 #define WIN_WRITEDMA                    0xCA /* write sectors using DMA transfers */
 164 #define WIN_WRITEDMA_ONCE               0xCB /* 28-Bit - without retries */
 165 #define WIN_WRITEDMA_QUEUED             0xCC /* write sectors using Queued DMA transfers */
 166 #define CFA_WRITE_MULTI_WO_ERASE        0xCD /* CFA Write multiple without erase */
 167 #define WIN_GETMEDIASTATUS              0xDA
 168 #define WIN_ACKMEDIACHANGE              0xDB /* ATA-1, ATA-2 vendor */
 169 #define WIN_POSTBOOT                    0xDC
 170 #define WIN_PREBOOT                     0xDD
 171 #define WIN_DOORLOCK                    0xDE /* lock door on removable drives */
 172 #define WIN_DOORUNLOCK                  0xDF /* unlock door on removable drives */
 173 #define WIN_STANDBYNOW1                 0xE0
 174 #define WIN_IDLEIMMEDIATE               0xE1 /* force drive to become "ready" */
 175 #define WIN_STANDBY                     0xE2 /* Set device in Standby Mode */
 176 #define WIN_SETIDLE1                    0xE3
 177 #define WIN_READ_BUFFER                 0xE4 /* force read only 1 sector */
 178 #define WIN_CHECKPOWERMODE1             0xE5
 179 #define WIN_SLEEPNOW1                   0xE6
 180 #define WIN_FLUSH_CACHE                 0xE7
 181 #define WIN_WRITE_BUFFER                0xE8 /* force write only 1 sector */
 182 #define WIN_WRITE_SAME                  0xE9 /* read ata-2 to use */
 183         /* SET_FEATURES 0x22 or 0xDD */
 184 #define WIN_FLUSH_CACHE_EXT             0xEA /* 48-Bit */
 185 #define WIN_IDENTIFY                    0xEC /* ask drive to identify itself    */
 186 #define WIN_MEDIAEJECT                  0xED
 187 #define WIN_IDENTIFY_DMA                0xEE /* same as WIN_IDENTIFY, but DMA */
 188 #define WIN_SETFEATURES                 0xEF /* set special drive features */
 189 #define EXABYTE_ENABLE_NEST             0xF0
 190 #define IBM_SENSE_CONDITION             0xF0 /* measure disk temperature */
 191 #define WIN_SECURITY_SET_PASS           0xF1
 192 #define WIN_SECURITY_UNLOCK             0xF2
 193 #define WIN_SECURITY_ERASE_PREPARE      0xF3
 194 #define WIN_SECURITY_ERASE_UNIT         0xF4
 195 #define WIN_SECURITY_FREEZE_LOCK        0xF5
 196 #define CFA_WEAR_LEVEL                  0xF5 /* microdrives implement as NOP */
 197 #define WIN_SECURITY_DISABLE            0xF6
 198 #define WIN_READ_NATIVE_MAX             0xF8 /* return the native maximum address */
 199 #define WIN_SET_MAX                     0xF9
 200 #define DISABLE_SEAGATE                 0xFB
 201
 202 /* set to 1 set disable mult support */
 203 #define MAX_MULT_SECTORS 16
 204
 205 #define IDE_DMA_BUF_SECTORS 256
 206
 207 #if (IDE_DMA_BUF_SECTORS < MAX_MULT_SECTORS)
 208 #error "IDE_DMA_BUF_SECTORS must be bigger or equal to MAX_MULT_SECTORS"
 209 #endif
 210
 211 /* ATAPI defines */
 212
 213 #define ATAPI_PACKET_SIZE 12
 214
 215 /* The generic packet command opcodes for CD/DVD Logical Units,
 216  * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
 217 #define GPCMD_BLANK                         0xa1
 218 #define GPCMD_CLOSE_TRACK                   0x5b
 219 #define GPCMD_FLUSH_CACHE                   0x35
 220 #define GPCMD_FORMAT_UNIT                   0x04
 221 #define GPCMD_GET_CONFIGURATION             0x46
 222 #define GPCMD_GET_EVENT_STATUS_NOTIFICATION 0x4a
 223 #define GPCMD_GET_PERFORMANCE               0xac
 224 #define GPCMD_INQUIRY                       0x12
 225 #define GPCMD_LOAD_UNLOAD                   0xa6
 226 #define GPCMD_MECHANISM_STATUS              0xbd
 227 #define GPCMD_MODE_SELECT_10                0x55
 228 #define GPCMD_MODE_SENSE_10                 0x5a
 229 #define GPCMD_PAUSE_RESUME                  0x4b
 230 #define GPCMD_PLAY_AUDIO_10                 0x45
 231 #define GPCMD_PLAY_AUDIO_MSF                0x47
 232 #define GPCMD_PLAY_AUDIO_TI                 0x48
 233 #define GPCMD_PLAY_CD                       0xbc
 234 #define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL  0x1e
 235 #define GPCMD_READ_10                       0x28
 236 #define GPCMD_READ_12                       0xa8
 237 #define GPCMD_READ_CDVD_CAPACITY            0x25
 238 #define GPCMD_READ_CD                       0xbe
 239 #define GPCMD_READ_CD_MSF                   0xb9
 240 #define GPCMD_READ_DISC_INFO                0x51
 241 #define GPCMD_READ_DVD_STRUCTURE            0xad
 242 #define GPCMD_READ_FORMAT_CAPACITIES        0x23
 243 #define GPCMD_READ_HEADER                   0x44
 244 #define GPCMD_READ_TRACK_RZONE_INFO         0x52
 245 #define GPCMD_READ_SUBCHANNEL               0x42
 246 #define GPCMD_READ_TOC_PMA_ATIP             0x43
 247 #define GPCMD_REPAIR_RZONE_TRACK            0x58
 248 #define GPCMD_REPORT_KEY                    0xa4
 249 #define GPCMD_REQUEST_SENSE                 0x03
 250 #define GPCMD_RESERVE_RZONE_TRACK           0x53
 251 #define GPCMD_SCAN                          0xba
 252 #define GPCMD_SEEK                          0x2b
 253 #define GPCMD_SEND_DVD_STRUCTURE            0xad
 254 #define GPCMD_SEND_EVENT                    0xa2
 255 #define GPCMD_SEND_KEY                      0xa3
 256 #define GPCMD_SEND_OPC                      0x54
 257 #define GPCMD_SET_READ_AHEAD                0xa7
 258 #define GPCMD_SET_STREAMING                 0xb6
 259 #define GPCMD_START_STOP_UNIT               0x1b
 260 #define GPCMD_STOP_PLAY_SCAN                0x4e
 261 #define GPCMD_TEST_UNIT_READY               0x00
 262 #define GPCMD_VERIFY_10                     0x2f
 263 #define GPCMD_WRITE_10                      0x2a
 264 #define GPCMD_WRITE_AND_VERIFY_10           0x2e
 265 /* This is listed as optional in ATAPI 2.6, but is (curiously)
 266  * missing from Mt. Fuji, Table 57.  It _is_ mentioned in Mt. Fuji
 267  * Table 377 as an MMC command for SCSi devices though...  Most ATAPI
 268  * drives support it. */
 269 #define GPCMD_SET_SPEED                     0xbb
 270 /* This seems to be a SCSI specific CD-ROM opcode
 271  * to play data at track/index */
 272 #define GPCMD_PLAYAUDIO_TI                  0x48
 273 /*
 274  * From MS Media Status Notification Support Specification. For
 275  * older drives only.
 276  */
 277 #define GPCMD_GET_MEDIA_STATUS              0xda
 278 #define GPCMD_MODE_SENSE_6                  0x1a
 279
 280 /* Mode page codes for mode sense/set */
 281 #define GPMODE_R_W_ERROR_PAGE           0x01
 282 #define GPMODE_WRITE_PARMS_PAGE         0x05
 283 #define GPMODE_AUDIO_CTL_PAGE           0x0e
 284 #define GPMODE_POWER_PAGE               0x1a
 285 #define GPMODE_FAULT_FAIL_PAGE          0x1c
 286 #define GPMODE_TO_PROTECT_PAGE          0x1d
 287 #define GPMODE_CAPABILITIES_PAGE        0x2a
 288 #define GPMODE_ALL_PAGES                0x3f
 289 /* Not in Mt. Fuji, but in ATAPI 2.6 -- depricated now in favor
 290  * of MODE_SENSE_POWER_PAGE */
 291 #define GPMODE_CDROM_PAGE               0x0d
 292
 293 /*
 294  * Based on values from <linux/cdrom.h> but extending CD_MINS
 295  * to the maximum common size allowed by the Orange's Book ATIP
 296  *
 297  * 90 and 99 min CDs are also available but using them as the
 298  * upper limit reduces the effectiveness of the heuristic to
 299  * detect DVDs burned to less than 25% of their maximum capacity
 300  */
 301
 302 /* Some generally useful CD-ROM information */
 303 #define CD_MINS                       80 /* max. minutes per CD */
 304 #define CD_SECS                       60 /* seconds per minute */
 305 #define CD_FRAMES                     75 /* frames per second */
 306 #define CD_FRAMESIZE                2048 /* bytes per frame, "cooked" mode */
 307 #define CD_MAX_BYTES       (CD_MINS * CD_SECS * CD_FRAMES * CD_FRAMESIZE)
 308 #define CD_MAX_SECTORS     (CD_MAX_BYTES / 512)
 309
 310 /*
 311  * The MMC values are not IDE specific and might need to be moved
 312  * to a common header if they are also needed for the SCSI emulation
 313  */
 314
 315 /* Profile list from MMC-6 revision 1 table 91 */
 316 #define MMC_PROFILE_NONE                0x0000
 317 #define MMC_PROFILE_CD_ROM              0x0008
 318 #define MMC_PROFILE_CD_R                0x0009
 319 #define MMC_PROFILE_CD_RW               0x000A
 320 #define MMC_PROFILE_DVD_ROM             0x0010
 321 #define MMC_PROFILE_DVD_R_SR            0x0011
 322 #define MMC_PROFILE_DVD_RAM             0x0012
 323 #define MMC_PROFILE_DVD_RW_RO           0x0013
 324 #define MMC_PROFILE_DVD_RW_SR           0x0014
 325 #define MMC_PROFILE_DVD_R_DL_SR         0x0015
 326 #define MMC_PROFILE_DVD_R_DL_JR         0x0016
 327 #define MMC_PROFILE_DVD_RW_DL           0x0017
 328 #define MMC_PROFILE_DVD_DDR             0x0018
 329 #define MMC_PROFILE_DVD_PLUS_RW         0x001A
 330 #define MMC_PROFILE_DVD_PLUS_R          0x001B
 331 #define MMC_PROFILE_DVD_PLUS_RW_DL      0x002A
 332 #define MMC_PROFILE_DVD_PLUS_R_DL       0x002B
 333 #define MMC_PROFILE_BD_ROM              0x0040
 334 #define MMC_PROFILE_BD_R_SRM            0x0041
 335 #define MMC_PROFILE_BD_R_RRM            0x0042
 336 #define MMC_PROFILE_BD_RE               0x0043
 337 #define MMC_PROFILE_HDDVD_ROM           0x0050
 338 #define MMC_PROFILE_HDDVD_R             0x0051
 339 #define MMC_PROFILE_HDDVD_RAM           0x0052
 340 #define MMC_PROFILE_HDDVD_RW            0x0053
 341 #define MMC_PROFILE_HDDVD_R_DL          0x0058
 342 #define MMC_PROFILE_HDDVD_RW_DL         0x005A
 343 #define MMC_PROFILE_INVALID             0xFFFF
 344
 345 #define ATAPI_INT_REASON_CD             0x01 /* 0 = data transfer */
 346 #define ATAPI_INT_REASON_IO             0x02 /* 1 = transfer to the host */
 347 #define ATAPI_INT_REASON_REL            0x04
 348 #define ATAPI_INT_REASON_TAG            0xf8
 349
 350 /* same constants as bochs */
 351 #define ASC_ILLEGAL_OPCODE                   0x20
 352 #define ASC_LOGICAL_BLOCK_OOR                0x21
 353 #define ASC_INV_FIELD_IN_CMD_PACKET          0x24
 354 #define ASC_INCOMPATIBLE_FORMAT              0x30
 355 #define ASC_MEDIUM_NOT_PRESENT               0x3a
 356 #define ASC_SAVING_PARAMETERS_NOT_SUPPORTED  0x39
 357
 358 #define CFA_NO_ERROR            0x00
 359 #define CFA_MISC_ERROR          0x09
 360 #define CFA_INVALID_COMMAND     0x20
 361 #define CFA_INVALID_ADDRESS     0x21
 362 #define CFA_ADDRESS_OVERFLOW    0x2f
 363
 364 #define SENSE_NONE            0
 365 #define SENSE_NOT_READY       2
 366 #define SENSE_ILLEGAL_REQUEST 5
 367 #define SENSE_UNIT_ATTENTION  6
 368
 369 struct IDEState;
 370
 371 typedef void EndTransferFunc(struct IDEState *);
 372
 373 /* NOTE: IDEState represents in fact one drive */
 374 typedef struct IDEState {
 375     /* ide config */
 376     int is_cdrom;
 377     int is_cf;
 378     int cylinders, heads, sectors;
 379     int64_t nb_sectors;
 380     int mult_sectors;
 381     int identify_set;
 382     uint16_t identify_data[256];
 383     qemu_irq irq;
 384     PCIDevice *pci_dev;
 385     struct BMDMAState *bmdma;
 386     int drive_serial;
 387     /* ide regs */
 388     uint8_t feature;
 389     uint8_t error;
 390     uint32_t nsector;
 391     uint8_t sector;
 392     uint8_t lcyl;
 393     uint8_t hcyl;
 394     /* other part of tf for lba48 support */
 395     uint8_t hob_feature;
 396     uint8_t hob_nsector;
 397     uint8_t hob_sector;
 398     uint8_t hob_lcyl;
 399     uint8_t hob_hcyl;
 400
 401     uint8_t select;
 402     uint8_t status;
 403
 404     /* 0x3f6 command, only meaningful for drive 0 */
 405     uint8_t cmd;
 406     /* set for lba48 access */
 407     uint8_t lba48;
 408     /* depends on bit 4 in select, only meaningful for drive 0 */
 409     struct IDEState *cur_drive;
 410     BlockDriverState *bs;
 411     /* ATAPI specific */
 412     uint8_t sense_key;
 413     uint8_t asc;
 414     int packet_transfer_size;
 415     int elementary_transfer_size;
 416     int io_buffer_index;
 417     int lba;
 418     int cd_sector_size;
 419     int atapi_dma; /* true if dma is requested for the packet cmd */
 420     /* ATA DMA state */
 421     int io_buffer_size;
 422     /* PIO transfer handling */
 423     int req_nb_sectors; /* number of sectors per interrupt */
 424     EndTransferFunc *end_transfer_func;
 425     uint8_t *data_ptr;
 426     uint8_t *data_end;
 427     uint8_t *io_buffer;
 428     QEMUTimer *sector_write_timer; /* only used for win2k install hack */
 429     uint32_t irq_count; /* counts IRQs when using win2k install hack */
 430     /* CF-ATA extended error */
 431     uint8_t ext_error;
 432     /* CF-ATA metadata storage */
 433     uint32_t mdata_size;
 434     uint8_t *mdata_storage;
 435     int media_changed;
 436 } IDEState;
 437
 438 /* XXX: DVDs that could fit on a CD will be reported as a CD */
 439 static inline int media_present(IDEState *s)
 440 {
 441     return (s->nb_sectors > 0);
 442 }
 443
 444 static inline int media_is_dvd(IDEState *s)
 445 {
 446     return (media_present(s) && s->nb_sectors > CD_MAX_SECTORS);
 447 }
 448
 449 static inline int media_is_cd(IDEState *s)
 450 {
 451     return (media_present(s) && s->nb_sectors <= CD_MAX_SECTORS);
 452 }
 453
 454 #define BM_STATUS_DMAING 0x01
 455 #define BM_STATUS_ERROR  0x02
 456 #define BM_STATUS_INT    0x04
 457
 458 #define BM_CMD_START     0x01
 459 #define BM_CMD_READ      0x08
 460
 461 #define IDE_TYPE_PIIX3   0
 462 #define IDE_TYPE_CMD646  1
 463 #define IDE_TYPE_PIIX4   2
 464
 465 /* CMD646 specific */
 466 #define MRDMODE         0x71
 467 #define   MRDMODE_INTR_CH0      0x04
 468 #define   MRDMODE_INTR_CH1      0x08
 469 #define   MRDMODE_BLK_CH0       0x10
 470 #define   MRDMODE_BLK_CH1       0x20
 471 #define UDIDETCR0       0x73
 472 #define UDIDETCR1       0x7B
 473
 474 typedef struct BMDMAState {
 475     uint8_t cmd;
 476     uint8_t status;
 477     uint32_t addr;
 478
 479     struct PCIIDEState *pci_dev;
 480     /* current transfer state */
 481     uint32_t cur_addr;
 482     uint32_t cur_prd_last;
 483     uint32_t cur_prd_addr;
 484     uint32_t cur_prd_len;
 485     IDEState *ide_if;
 486     BlockDriverCompletionFunc *dma_cb;
 487     BlockDriverAIOCB *aiocb;
 488 } BMDMAState;
 489
 490 typedef struct PCIIDEState {
 491     PCIDevice dev;
 492     IDEState ide_if[4];
 493     BMDMAState bmdma[2];
 494     int type; /* see IDE_TYPE_xxx */
 495 } PCIIDEState;
 496
 497 static void ide_dma_start(IDEState *s, BlockDriverCompletionFunc *dma_cb);
 498 static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);
 499
 500 static void padstr(char *str, const char *src, int len)
 501 {
 502     int i, v;
 503     for(i = 0; i < len; i++) {
 504         if (*src)
 505             v = *src++;
 506         else
 507             v = ' ';
 508         str[i^1] = v;
 509     }
 510 }
 511
 512 static void padstr8(uint8_t *buf, int buf_size, const char *src)
 513 {
 514     int i;
 515     for(i = 0; i < buf_size; i++) {
 516         if (*src)
 517             buf[i] = *src++;
 518         else
 519             buf[i] = ' ';
 520     }
 521 }
 522
 523 static void put_le16(uint16_t *p, unsigned int v)
 524 {
 525     *p = cpu_to_le16(v);
 526 }
 527
 528 static void ide_identify(IDEState *s)
 529 {
 530     uint16_t *p;
 531     unsigned int oldsize;
 532     char buf[20];
 533
 534     if (s->identify_set) {
 535         memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
 536         return;
 537     }
 538
 539     memset(s->io_buffer, 0, 512);
 540     p = (uint16_t *)s->io_buffer;
 541     put_le16(p + 0, 0x0040);
 542     put_le16(p + 1, s->cylinders);
 543     put_le16(p + 3, s->heads);
 544     put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
 545     put_le16(p + 5, 512); /* XXX: retired, remove ? */
 546     put_le16(p + 6, s->sectors);
 547     snprintf(buf, sizeof(buf), "QM%05d", s->drive_serial);
 548     padstr((char *)(p + 10), buf, 20); /* serial number */
 549     put_le16(p + 20, 3); /* XXX: retired, remove ? */
 550     put_le16(p + 21, 512); /* cache size in sectors */
 551     put_le16(p + 22, 4); /* ecc bytes */
 552     padstr((char *)(p + 23), QEMU_VERSION, 8); /* firmware version */
 553     padstr((char *)(p + 27), "QEMU HARDDISK", 40); /* model */
 554 #if MAX_MULT_SECTORS > 1
 555     put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
 556 #endif
 557     put_le16(p + 48, 1); /* dword I/O */
 558     put_le16(p + 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
 559     put_le16(p + 51, 0x200); /* PIO transfer cycle */
 560     put_le16(p + 52, 0x200); /* DMA transfer cycle */
 561     put_le16(p + 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
 562     put_le16(p + 54, s->cylinders);
 563     put_le16(p + 55, s->heads);
 564     put_le16(p + 56, s->sectors);
 565     oldsize = s->cylinders * s->heads * s->sectors;
 566     put_le16(p + 57, oldsize);
 567     put_le16(p + 58, oldsize >> 16);
 568     if (s->mult_sectors)
 569         put_le16(p + 59, 0x100 | s->mult_sectors);
 570     put_le16(p + 60, s->nb_sectors);
 571     put_le16(p + 61, s->nb_sectors >> 16);
 572     put_le16(p + 62, 0x07); /* single word dma0-2 supported */
 573     put_le16(p + 63, 0x07); /* mdma0-2 supported */
 574     put_le16(p + 65, 120);
 575     put_le16(p + 66, 120);
 576     put_le16(p + 67, 120);
 577     put_le16(p + 68, 120);
 578     put_le16(p + 80, 0xf0); /* ata3 -> ata6 supported */
 579     put_le16(p + 81, 0x16); /* conforms to ata5 */
 580     put_le16(p + 82, (1 << 14));
 581     /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
 582     put_le16(p + 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
 583     put_le16(p + 84, (1 << 14));
 584     put_le16(p + 85, (1 << 14));
 585     /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
 586     put_le16(p + 86, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
 587     put_le16(p + 87, (1 << 14));
 588     put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
 589     put_le16(p + 93, 1 | (1 << 14) | 0x2000);
 590     put_le16(p + 100, s->nb_sectors);
 591     put_le16(p + 101, s->nb_sectors >> 16);
 592     put_le16(p + 102, s->nb_sectors >> 32);
 593     put_le16(p + 103, s->nb_sectors >> 48);
 594
 595     memcpy(s->identify_data, p, sizeof(s->identify_data));
 596     s->identify_set = 1;
 597 }
 598
 599 static void ide_atapi_identify(IDEState *s)
 600 {
 601     uint16_t *p;
 602     char buf[20];
 603
 604     if (s->identify_set) {
 605         memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
 606         return;
 607     }
 608
 609     memset(s->io_buffer, 0, 512);
 610     p = (uint16_t *)s->io_buffer;
 611     /* Removable CDROM, 50us response, 12 byte packets */
 612     put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
 613     snprintf(buf, sizeof(buf), "QM%05d", s->drive_serial);
 614     padstr((char *)(p + 10), buf, 20); /* serial number */
 615     put_le16(p + 20, 3); /* buffer type */
 616     put_le16(p + 21, 512); /* cache size in sectors */
 617     put_le16(p + 22, 4); /* ecc bytes */
 618     padstr((char *)(p + 23), QEMU_VERSION, 8); /* firmware version */
 619     padstr((char *)(p + 27), "QEMU DVD-ROM", 40); /* model */
 620     put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
 621 #ifdef USE_DMA_CDROM
 622     put_le16(p + 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
 623     put_le16(p + 53, 7); /* words 64-70, 54-58, 88 valid */
 624     put_le16(p + 62, 7);  /* single word dma0-2 supported */
 625     put_le16(p + 63, 7);  /* mdma0-2 supported */
 626     put_le16(p + 64, 0x3f); /* PIO modes supported */
 627 #else
 628     put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
 629     put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
 630     put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
 631     put_le16(p + 64, 1); /* PIO modes */
 632 #endif
 633     put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
 634     put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
 635     put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
 636     put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
 637
 638     put_le16(p + 71, 30); /* in ns */
 639     put_le16(p + 72, 30); /* in ns */
 640
 641     put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
 642 #ifdef USE_DMA_CDROM
 643     put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
 644 #endif
 645     memcpy(s->identify_data, p, sizeof(s->identify_data));
 646     s->identify_set = 1;
 647 }
 648
 649 static void ide_cfata_identify(IDEState *s)
 650 {
 651     uint16_t *p;
 652     uint32_t cur_sec;
 653     char buf[20];
 654
 655     p = (uint16_t *) s->identify_data;
 656     if (s->identify_set)
 657         goto fill_buffer;
 658
 659     memset(p, 0, sizeof(s->identify_data));
 660
 661     cur_sec = s->cylinders * s->heads * s->sectors;
 662
 663     put_le16(p + 0, 0x848a);                    /* CF Storage Card signature */
 664     put_le16(p + 1, s->cylinders);              /* Default cylinders */
 665     put_le16(p + 3, s->heads);                  /* Default heads */
 666     put_le16(p + 6, s->sectors);                /* Default sectors per track */
 667     put_le16(p + 7, s->nb_sectors >> 16);       /* Sectors per card */
 668     put_le16(p + 8, s->nb_sectors);             /* Sectors per card */
 669     snprintf(buf, sizeof(buf), "QM%05d", s->drive_serial);
 670     padstr((char *)(p + 10), buf, 20);  /* Serial number in ASCII */
 671     put_le16(p + 22, 0x0004);                   /* ECC bytes */
 672     padstr((char *) (p + 23), QEMU_VERSION, 8); /* Firmware Revision */
 673     padstr((char *) (p + 27), "QEMU MICRODRIVE", 40);/* Model number */
 674 #if MAX_MULT_SECTORS > 1
 675     put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
 676 #else
 677     put_le16(p + 47, 0x0000);
 678 #endif
 679     put_le16(p + 49, 0x0f00);                   /* Capabilities */
 680     put_le16(p + 51, 0x0002);                   /* PIO cycle timing mode */
 681     put_le16(p + 52, 0x0001);                   /* DMA cycle timing mode */
 682     put_le16(p + 53, 0x0003);                   /* Translation params valid */
 683     put_le16(p + 54, s->cylinders);             /* Current cylinders */
 684     put_le16(p + 55, s->heads);                 /* Current heads */
 685     put_le16(p + 56, s->sectors);               /* Current sectors */
 686     put_le16(p + 57, cur_sec);                  /* Current capacity */
 687     put_le16(p + 58, cur_sec >> 16);            /* Current capacity */
 688     if (s->mult_sectors)                        /* Multiple sector setting */
 689         put_le16(p + 59, 0x100 | s->mult_sectors);
 690     put_le16(p + 60, s->nb_sectors);            /* Total LBA sectors */
 691     put_le16(p + 61, s->nb_sectors >> 16);      /* Total LBA sectors */
 692     put_le16(p + 63, 0x0203);                   /* Multiword DMA capability */
 693     put_le16(p + 64, 0x0001);                   /* Flow Control PIO support */
 694     put_le16(p + 65, 0x0096);                   /* Min. Multiword DMA cycle */
 695     put_le16(p + 66, 0x0096);                   /* Rec. Multiword DMA cycle */
 696     put_le16(p + 68, 0x00b4);                   /* Min. PIO cycle time */
 697     put_le16(p + 82, 0x400c);                   /* Command Set supported */
 698     put_le16(p + 83, 0x7068);                   /* Command Set supported */
 699     put_le16(p + 84, 0x4000);                   /* Features supported */
 700     put_le16(p + 85, 0x000c);                   /* Command Set enabled */
 701     put_le16(p + 86, 0x7044);                   /* Command Set enabled */
 702     put_le16(p + 87, 0x4000);                   /* Features enabled */
 703     put_le16(p + 91, 0x4060);                   /* Current APM level */
 704     put_le16(p + 129, 0x0002);                  /* Current features option */
 705     put_le16(p + 130, 0x0005);                  /* Reassigned sectors */
 706     put_le16(p + 131, 0x0001);                  /* Initial power mode */
 707     put_le16(p + 132, 0x0000);                  /* User signature */
 708     put_le16(p + 160, 0x8100);                  /* Power requirement */
 709     put_le16(p + 161, 0x8001);                  /* CF command set */
 710
 711     s->identify_set = 1;
 712
 713 fill_buffer:
 714     memcpy(s->io_buffer, p, sizeof(s->identify_data));
 715 }
 716
 717 static void ide_set_signature(IDEState *s)
 718 {
 719     s->select &= 0xf0; /* clear head */
 720     /* put signature */
 721     s->nsector = 1;
 722     s->sector = 1;
 723     if (s->is_cdrom) {
 724         s->lcyl = 0x14;
 725         s->hcyl = 0xeb;
 726     } else if (s->bs) {
 727         s->lcyl = 0;
 728         s->hcyl = 0;
 729     } else {
 730         s->lcyl = 0xff;
 731         s->hcyl = 0xff;
 732     }
 733 }
 734
 735 static inline void ide_abort_command(IDEState *s)
 736 {
 737     s->status = READY_STAT | ERR_STAT;
 738     s->error = ABRT_ERR;
 739 }
 740
 741 static inline void ide_set_irq(IDEState *s)
 742 {
 743     BMDMAState *bm = s->bmdma;
 744     if (!(s->cmd & IDE_CMD_DISABLE_IRQ)) {
 745         if (bm) {
 746             bm->status |= BM_STATUS_INT;
 747         }
 748         qemu_irq_raise(s->irq);
 749     }
 750 }
 751
 752 /* prepare data transfer and tell what to do after */
 753 static void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
 754                                EndTransferFunc *end_transfer_func)
 755 {
 756     s->end_transfer_func = end_transfer_func;
 757     s->data_ptr = buf;
 758     s->data_end = buf + size;
 759     if (!(s->status & ERR_STAT))
 760         s->status |= DRQ_STAT;
 761 }
 762
 763 static void ide_transfer_stop(IDEState *s)
 764 {
 765     s->end_transfer_func = ide_transfer_stop;
 766     s->data_ptr = s->io_buffer;
 767     s->data_end = s->io_buffer;
 768     s->status &= ~DRQ_STAT;
 769 }
 770
 771 static int64_t ide_get_sector(IDEState *s)
 772 {
 773     int64_t sector_num;
 774     if (s->select & 0x40) {
 775         /* lba */
 776         if (!s->lba48) {
 777             sector_num = ((s->select & 0x0f) << 24) | (s->hcyl << 16) |
 778                 (s->lcyl << 8) | s->sector;
 779         } else {
 780             sector_num = ((int64_t)s->hob_hcyl << 40) |
 781                 ((int64_t) s->hob_lcyl << 32) |
 782                 ((int64_t) s->hob_sector << 24) |
 783                 ((int64_t) s->hcyl << 16) |
 784                 ((int64_t) s->lcyl << 8) | s->sector;
 785         }
 786     } else {
 787         sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
 788             (s->select & 0x0f) * s->sectors + (s->sector - 1);
 789     }
 790     return sector_num;
 791 }
 792
 793 static void ide_set_sector(IDEState *s, int64_t sector_num)
 794 {
 795     unsigned int cyl, r;
 796     if (s->select & 0x40) {
 797         if (!s->lba48) {
 798             s->select = (s->select & 0xf0) | (sector_num >> 24);
 799             s->hcyl = (sector_num >> 16);
 800             s->lcyl = (sector_num >> 8);
 801             s->sector = (sector_num);
 802         } else {
 803             s->sector = sector_num;
 804             s->lcyl = sector_num >> 8;
 805             s->hcyl = sector_num >> 16;
 806             s->hob_sector = sector_num >> 24;
 807             s->hob_lcyl = sector_num >> 32;
 808             s->hob_hcyl = sector_num >> 40;
 809         }
 810     } else {
 811         cyl = sector_num / (s->heads * s->sectors);
 812         r = sector_num % (s->heads * s->sectors);
 813         s->hcyl = cyl >> 8;
 814         s->lcyl = cyl;
 815         s->select = (s->select & 0xf0) | ((r / s->sectors) & 0x0f);
 816         s->sector = (r % s->sectors) + 1;
 817     }
 818 }
 819
 820 static void ide_sector_read(IDEState *s)
 821 {
 822     int64_t sector_num;
 823     int ret, n;
 824
 825     s->status = READY_STAT | SEEK_STAT;
 826     s->error = 0; /* not needed by IDE spec, but needed by Windows */
 827     sector_num = ide_get_sector(s);
 828     n = s->nsector;
 829     if (n == 0) {
 830         /* no more sector to read from disk */
 831         ide_transfer_stop(s);
 832     } else {
 833 #if defined(DEBUG_IDE)
 834         printf("read sector=%Ld\n", sector_num);
 835 #endif
 836         if (n > s->req_nb_sectors)
 837             n = s->req_nb_sectors;
 838         ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
 839         ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_read);
 840         ide_set_irq(s);
 841         ide_set_sector(s, sector_num + n);
 842         s->nsector -= n;
 843     }
 844 }
 845
 846 /* return 0 if buffer completed */
 847 static int dma_buf_rw(BMDMAState *bm, int is_write)
 848 {
 849     IDEState *s = bm->ide_if;
 850     struct {
 851         uint32_t addr;
 852         uint32_t size;
 853     } prd;
 854     int l, len;
 855
 856     for(;;) {
 857         l = s->io_buffer_size - s->io_buffer_index;
 858         if (l <= 0)
 859             break;
 860         if (bm->cur_prd_len == 0) {
 861             /* end of table (with a fail safe of one page) */
 862             if (bm->cur_prd_last ||
 863                 (bm->cur_addr - bm->addr) >= 4096)
 864                 return 0;
 865             cpu_physical_memory_read(bm->cur_addr, (uint8_t *)&prd, 8);
 866             bm->cur_addr += 8;
 867             prd.addr = le32_to_cpu(prd.addr);
 868             prd.size = le32_to_cpu(prd.size);
 869             len = prd.size & 0xfffe;
 870             if (len == 0)
 871                 len = 0x10000;
 872             bm->cur_prd_len = len;
 873             bm->cur_prd_addr = prd.addr;
 874             bm->cur_prd_last = (prd.size & 0x80000000);
 875         }
 876         if (l > bm->cur_prd_len)
 877             l = bm->cur_prd_len;
 878         if (l > 0) {
 879             if (is_write) {
 880                 cpu_physical_memory_write(bm->cur_prd_addr,
 881                                           s->io_buffer + s->io_buffer_index, l);
 882             } else {
 883                 cpu_physical_memory_read(bm->cur_prd_addr,
 884                                           s->io_buffer + s->io_buffer_index, l);
 885             }
 886             bm->cur_prd_addr += l;
 887             bm->cur_prd_len -= l;
 888             s->io_buffer_index += l;
 889         }
 890     }
 891     return 1;
 892 }
 893
 894 /* XXX: handle errors */
 895 static void ide_read_dma_cb(void *opaque, int ret)
 896 {
 897     BMDMAState *bm = opaque;
 898     IDEState *s = bm->ide_if;
 899     int n;
 900     int64_t sector_num;
 901
 902     n = s->io_buffer_size >> 9;
 903     sector_num = ide_get_sector(s);
 904     if (n > 0) {
 905         sector_num += n;
 906         ide_set_sector(s, sector_num);
 907         s->nsector -= n;
 908         if (dma_buf_rw(bm, 1) == 0)
 909             goto eot;
 910     }
 911
 912     /* end of transfer ? */
 913     if (s->nsector == 0) {
 914         s->status = READY_STAT | SEEK_STAT;
 915         ide_set_irq(s);
 916     eot:
 917         bm->status &= ~BM_STATUS_DMAING;
 918         bm->status |= BM_STATUS_INT;
 919         bm->dma_cb = NULL;
 920         bm->ide_if = NULL;
 921         bm->aiocb = NULL;
 922         return;
 923     }
 924
 925     /* launch next transfer */
 926     n = s->nsector;
 927     if (n > IDE_DMA_BUF_SECTORS)
 928         n = IDE_DMA_BUF_SECTORS;
 929     s->io_buffer_index = 0;
 930     s->io_buffer_size = n * 512;
 931 #ifdef DEBUG_AIO
 932     printf("aio_read: sector_num=%lld n=%d\n", sector_num, n);
 933 #endif
 934     bm->aiocb = bdrv_aio_read(s->bs, sector_num, s->io_buffer, n,
 935                               ide_read_dma_cb, bm);
 936 }
 937
 938 static void ide_sector_read_dma(IDEState *s)
 939 {
 940     s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
 941     s->io_buffer_index = 0;
 942     s->io_buffer_size = 0;
 943     ide_dma_start(s, ide_read_dma_cb);
 944 }
 945
 946 static void ide_sector_write_timer_cb(void *opaque)
 947 {
 948     IDEState *s = opaque;
 949     ide_set_irq(s);
 950 }
 951
 952 static void ide_sector_write(IDEState *s)
 953 {
 954     int64_t sector_num;
 955     int ret, n, n1;
 956
 957     s->status = READY_STAT | SEEK_STAT;
 958     sector_num = ide_get_sector(s);
 959 #if defined(DEBUG_IDE)
 960     printf("write sector=%Ld\n", sector_num);
 961 #endif
 962     n = s->nsector;
 963     if (n > s->req_nb_sectors)
 964         n = s->req_nb_sectors;
 965     ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
 966     s->nsector -= n;
 967     if (s->nsector == 0) {
 968         /* no more sectors to write */
 969         ide_transfer_stop(s);
 970     } else {
 971         n1 = s->nsector;
 972         if (n1 > s->req_nb_sectors)
 973             n1 = s->req_nb_sectors;
 974         ide_transfer_start(s, s->io_buffer, 512 * n1, ide_sector_write);
 975     }
 976     ide_set_sector(s, sector_num + n);
 977
 978 #ifdef TARGET_I386
 979     if (win2k_install_hack && ((++s->irq_count % 16) == 0)) {
 980         /* It seems there is a bug in the Windows 2000 installer HDD
 981            IDE driver which fills the disk with empty logs when the
 982            IDE write IRQ comes too early. This hack tries to correct
 983            that at the expense of slower write performances. Use this
 984            option _only_ to install Windows 2000. You must disable it
 985            for normal use. */
 986         qemu_mod_timer(s->sector_write_timer,
 987                        qemu_get_clock(vm_clock) + (ticks_per_sec / 1000));
 988     } else
 989 #endif
 990     {
 991         ide_set_irq(s);
 992     }
 993 }
 994
 995 /* XXX: handle errors */
 996 static void ide_write_dma_cb(void *opaque, int ret)
 997 {
 998     BMDMAState *bm = opaque;
 999     IDEState *s = bm->ide_if;
1000     int n;
1001     int64_t sector_num;
1002
1003     n = s->io_buffer_size >> 9;
1004     sector_num = ide_get_sector(s);
1005     if (n > 0) {
1006         sector_num += n;
1007         ide_set_sector(s, sector_num);
1008         s->nsector -= n;
1009     }
1010
1011     /* end of transfer ? */
1012     if (s->nsector == 0) {
1013         s->status = READY_STAT | SEEK_STAT;
1014         ide_set_irq(s);
1015     eot:
1016         bm->status &= ~BM_STATUS_DMAING;
1017         bm->status |= BM_STATUS_INT;
1018         bm->dma_cb = NULL;
1019         bm->ide_if = NULL;
1020         bm->aiocb = NULL;
1021         return;
1022     }
1023
1024     /* launch next transfer */
1025     n = s->nsector;
1026     if (n > IDE_DMA_BUF_SECTORS)
1027         n = IDE_DMA_BUF_SECTORS;
1028     s->io_buffer_index = 0;
1029     s->io_buffer_size = n * 512;
1030
1031     if (dma_buf_rw(bm, 0) == 0)
1032         goto eot;
1033 #ifdef DEBUG_AIO
1034     printf("aio_write: sector_num=%lld n=%d\n", sector_num, n);
1035 #endif
1036     bm->aiocb = bdrv_aio_write(s->bs, sector_num, s->io_buffer, n,
1037                                ide_write_dma_cb, bm);
1038 }
1039
1040 static void ide_sector_write_dma(IDEState *s)
1041 {
1042     s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
1043     s->io_buffer_index = 0;
1044     s->io_buffer_size = 0;
1045     ide_dma_start(s, ide_write_dma_cb);
1046 }
1047
1048 static void ide_atapi_cmd_ok(IDEState *s)
1049 {
1050     s->error = 0;
1051     s->status = READY_STAT | SEEK_STAT;
1052     s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
1053     ide_set_irq(s);
1054 }
1055
1056 static void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc)
1057 {
1058 #ifdef DEBUG_IDE_ATAPI
1059     printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key, asc);
1060 #endif
1061     s->error = sense_key << 4;
1062     s->status = READY_STAT | ERR_STAT;
1063     s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
1064     s->sense_key = sense_key;
1065     s->asc = asc;
1066     ide_set_irq(s);
1067 }
1068
1069 static inline void cpu_to_ube16(uint8_t *buf, int val)
1070 {
1071     buf[0] = val >> 8;
1072     buf[1] = val;
1073 }
1074
1075 static inline void cpu_to_ube32(uint8_t *buf, unsigned int val)
1076 {
1077     buf[0] = val >> 24;
1078     buf[1] = val >> 16;
1079     buf[2] = val >> 8;
1080     buf[3] = val;
1081 }
1082
1083 static inline int ube16_to_cpu(const uint8_t *buf)
1084 {
1085     return (buf[0] << 8) | buf[1];
1086 }
1087
1088 static inline int ube32_to_cpu(const uint8_t *buf)
1089 {
1090     return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
1091 }
1092
1093 static void lba_to_msf(uint8_t *buf, int lba)
1094 {
1095     lba += 150;
1096     buf[0] = (lba / 75) / 60;
1097     buf[1] = (lba / 75) % 60;
1098     buf[2] = lba % 75;
1099 }
1100
1101 static void cd_data_to_raw(uint8_t *buf, int lba)
1102 {
1103     /* sync bytes */
1104     buf[0] = 0x00;
1105     memset(buf + 1, 0xff, 10);
1106     buf[11] = 0x00;
1107     buf += 12;
1108     /* MSF */
1109     lba_to_msf(buf, lba);
1110     buf[3] = 0x01; /* mode 1 data */
1111     buf += 4;
1112     /* data */
1113     buf += 2048;
1114     /* XXX: ECC not computed */
1115     memset(buf, 0, 288);
1116 }
1117
1118 static int cd_read_sector(BlockDriverState *bs, int lba, uint8_t *buf,
1119                            int sector_size)
1120 {
1121     int ret;
1122
1123     switch(sector_size) {
1124     case 2048:
1125         ret = bdrv_read(bs, (int64_t)lba << 2, buf, 4);
1126         break;
1127     case 2352:
1128         ret = bdrv_read(bs, (int64_t)lba << 2, buf + 16, 4);
1129         if (ret < 0)
1130             return ret;
1131         cd_data_to_raw(buf, lba);
1132         break;
1133     default:
1134         ret = -EIO;
1135         break;
1136     }
1137     return ret;
1138 }
1139
1140 static void ide_atapi_io_error(IDEState *s, int ret)
1141 {
1142     /* XXX: handle more errors */
1143     if (ret == -ENOMEDIUM) {
1144         ide_atapi_cmd_error(s, SENSE_NOT_READY,
1145                             ASC_MEDIUM_NOT_PRESENT);
1146     } else {
1147         ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1148                             ASC_LOGICAL_BLOCK_OOR);
1149     }
1150 }
1151
1152 /* The whole ATAPI transfer logic is handled in this function */
1153 static void ide_atapi_cmd_reply_end(IDEState *s)
1154 {
1155     int byte_count_limit, size, ret;
1156 #ifdef DEBUG_IDE_ATAPI
1157     printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
1158            s->packet_transfer_size,
1159            s->elementary_transfer_size,
1160            s->io_buffer_index);
1161 #endif
1162     if (s->packet_transfer_size <= 0) {
1163         /* end of transfer */
1164         ide_transfer_stop(s);
1165         s->status = READY_STAT | SEEK_STAT;
1166         s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
1167         ide_set_irq(s);
1168 #ifdef DEBUG_IDE_ATAPI
1169         printf("status=0x%x\n", s->status);
1170 #endif
1171     } else {
1172         /* see if a new sector must be read */
1173         if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
1174             ret = cd_read_sector(s->bs, s->lba, s->io_buffer, s->cd_sector_size);
1175             if (ret < 0) {
1176                 ide_transfer_stop(s);
1177                 ide_atapi_io_error(s, ret);
1178                 return;
1179             }
1180             s->lba++;
1181             s->io_buffer_index = 0;
1182         }
1183         if (s->elementary_transfer_size > 0) {
1184             /* there are some data left to transmit in this elementary
1185                transfer */
1186             size = s->cd_sector_size - s->io_buffer_index;
1187             if (size > s->elementary_transfer_size)
1188                 size = s->elementary_transfer_size;
1189             ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
1190                                size, ide_atapi_cmd_reply_end);
1191             s->packet_transfer_size -= size;
1192             s->elementary_transfer_size -= size;
1193             s->io_buffer_index += size;
1194         } else {
1195             /* a new transfer is needed */
1196             s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
1197             byte_count_limit = s->lcyl | (s->hcyl << 8);
1198 #ifdef DEBUG_IDE_ATAPI
1199             printf("byte_count_limit=%d\n", byte_count_limit);
1200 #endif
1201             if (byte_count_limit == 0xffff)
1202                 byte_count_limit--;
1203             size = s->packet_transfer_size;
1204             if (size > byte_count_limit) {
1205                 /* byte count limit must be even if this case */
1206                 if (byte_count_limit & 1)
1207                     byte_count_limit--;
1208                 size = byte_count_limit;
1209             }
1210             s->lcyl = size;
1211             s->hcyl = size >> 8;
1212             s->elementary_transfer_size = size;
1213             /* we cannot transmit more than one sector at a time */
1214             if (s->lba != -1) {
1215                 if (size > (s->cd_sector_size - s->io_buffer_index))
1216                     size = (s->cd_sector_size - s->io_buffer_index);
1217             }
1218             ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
1219                                size, ide_atapi_cmd_reply_end);
1220             s->packet_transfer_size -= size;
1221             s->elementary_transfer_size -= size;
1222             s->io_buffer_index += size;
1223             ide_set_irq(s);
1224 #ifdef DEBUG_IDE_ATAPI
1225             printf("status=0x%x\n", s->status);
1226 #endif
1227         }
1228     }
1229 }
1230
1231 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
1232 static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
1233 {
1234     if (size > max_size)
1235         size = max_size;
1236     s->lba = -1; /* no sector read */
1237     s->packet_transfer_size = size;
1238     s->io_buffer_size = size;    /* dma: send the reply data as one chunk */
1239     s->elementary_transfer_size = 0;
1240     s->io_buffer_index = 0;
1241
1242     if (s->atapi_dma) {
1243         s->status = READY_STAT | SEEK_STAT | DRQ_STAT;
1244         ide_dma_start(s, ide_atapi_cmd_read_dma_cb);
1245     } else {
1246         s->status = READY_STAT | SEEK_STAT;
1247         ide_atapi_cmd_reply_end(s);
1248     }
1249 }
1250
1251 /* start a CD-CDROM read command */
1252 static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
1253                                    int sector_size)
1254 {
1255     s->lba = lba;
1256     s->packet_transfer_size = nb_sectors * sector_size;
1257     s->elementary_transfer_size = 0;
1258     s->io_buffer_index = sector_size;
1259     s->cd_sector_size = sector_size;
1260
1261     s->status = READY_STAT | SEEK_STAT;
1262     ide_atapi_cmd_reply_end(s);
1263 }
1264
1265 /* ATAPI DMA support */
1266
1267 /* XXX: handle read errors */
1268 static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
1269 {
1270     BMDMAState *bm = opaque;
1271     IDEState *s = bm->ide_if;
1272     int data_offset, n;
1273
1274     if (ret < 0) {
1275         ide_atapi_io_error(s, ret);
1276         goto eot;
1277     }
1278
1279     if (s->io_buffer_size > 0) {
1280         /*
1281          * For a cdrom read sector command (s->lba != -1),
1282          * adjust the lba for the next s->io_buffer_size chunk
1283          * and dma the current chunk.
1284          * For a command != read (s->lba == -1), just transfer
1285          * the reply data.
1286          */
1287         if (s->lba != -1) {
1288             if (s->cd_sector_size == 2352) {
1289                 n = 1;
1290                 cd_data_to_raw(s->io_buffer, s->lba);
1291             } else {
1292                 n = s->io_buffer_size >> 11;
1293             }
1294             s->lba += n;
1295         }
1296         s->packet_transfer_size -= s->io_buffer_size;
1297         if (dma_buf_rw(bm, 1) == 0)
1298             goto eot;
1299     }
1300
1301     if (s->packet_transfer_size <= 0) {
1302         s->status = READY_STAT | SEEK_STAT;
1303         s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
1304         ide_set_irq(s);
1305     eot:
1306         bm->status &= ~BM_STATUS_DMAING;
1307         bm->status |= BM_STATUS_INT;
1308         bm->dma_cb = NULL;
1309         bm->ide_if = NULL;
1310         bm->aiocb = NULL;
1311         return;
1312     }
1313
1314     s->io_buffer_index = 0;
1315     if (s->cd_sector_size == 2352) {
1316         n = 1;
1317         s->io_buffer_size = s->cd_sector_size;
1318         data_offset = 16;
1319     } else {
1320         n = s->packet_transfer_size >> 11;
1321         if (n > (IDE_DMA_BUF_SECTORS / 4))
1322             n = (IDE_DMA_BUF_SECTORS / 4);
1323         s->io_buffer_size = n * 2048;
1324         data_offset = 0;
1325     }
1326 #ifdef DEBUG_AIO
1327     printf("aio_read_cd: lba=%u n=%d\n", s->lba, n);
1328 #endif
1329     bm->aiocb = bdrv_aio_read(s->bs, (int64_t)s->lba << 2,
1330                               s->io_buffer + data_offset, n * 4,
1331                               ide_atapi_cmd_read_dma_cb, bm);
1332     if (!bm->aiocb) {
1333         /* Note: media not present is the most likely case */
1334         ide_atapi_cmd_error(s, SENSE_NOT_READY,
1335                             ASC_MEDIUM_NOT_PRESENT);
1336         goto eot;
1337     }
1338 }
1339
1340 /* start a CD-CDROM read command with DMA */
1341 /* XXX: test if DMA is available */
1342 static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors,
1343                                    int sector_size)
1344 {
1345     s->lba = lba;
1346     s->packet_transfer_size = nb_sectors * sector_size;
1347     s->io_buffer_index = 0;
1348     s->io_buffer_size = 0;
1349     s->cd_sector_size = sector_size;
1350
1351     /* XXX: check if BUSY_STAT should be set */
1352     s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
1353     ide_dma_start(s, ide_atapi_cmd_read_dma_cb);
1354 }
1355
1356 static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors,
1357                                int sector_size)
1358 {
1359 #ifdef DEBUG_IDE_ATAPI
1360     printf("read %s: LBA=%d nb_sectors=%d\n", s->atapi_dma ? "dma" : "pio",
1361         lba, nb_sectors);
1362 #endif
1363     if (s->atapi_dma) {
1364         ide_atapi_cmd_read_dma(s, lba, nb_sectors, sector_size);
1365     } else {
1366         ide_atapi_cmd_read_pio(s, lba, nb_sectors, sector_size);
1367     }
1368 }
1369
1370 static inline uint8_t ide_atapi_set_profile(uint8_t *buf, uint8_t *index,
1371                                             uint16_t profile)
1372 {
1373     uint8_t *buf_profile = buf + 12; /* start of profiles */
1374
1375     buf_profile += ((*index) * 4); /* start of indexed profile */
1376     cpu_to_ube16 (buf_profile, profile);
1377     buf_profile[2] = ((buf_profile[0] == buf[6]) && (buf_profile[1] == buf[7]));
1378
1379     /* each profile adds 4 bytes to the response */
1380     (*index)++;
1381     buf[11] += 4; /* Additional Length */
1382
1383     return 4;
1384 }
1385
1386 static int ide_dvd_read_structure(IDEState *s, int format,
1387                                   const uint8_t *packet, uint8_t *buf)
1388 {
1389     switch (format) {
1390         case 0x0: /* Physical format information */
1391             {
1392                 int layer = packet[6];
1393                 uint64_t total_sectors;
1394
1395                 if (layer != 0)
1396                     return -ASC_INV_FIELD_IN_CMD_PACKET;
1397
1398                 bdrv_get_geometry(s->bs, &total_sectors);
1399                 total_sectors >>= 2;
1400                 if (total_sectors == 0)
1401                     return -ASC_MEDIUM_NOT_PRESENT;
1402
1403                 buf[4] = 1;   /* DVD-ROM, part version 1 */
1404                 buf[5] = 0xf; /* 120mm disc, minimum rate unspecified */
1405                 buf[6] = 1;   /* one layer, read-only (per MMC-2 spec) */
1406                 buf[7] = 0;   /* default densities */
1407
1408                 /* FIXME: 0x30000 per spec? */
1409                 cpu_to_ube32(buf + 8, 0); /* start sector */
1410                 cpu_to_ube32(buf + 12, total_sectors - 1); /* end sector */
1411                 cpu_to_ube32(buf + 16, total_sectors - 1); /* l0 end sector */
1412
1413                 /* Size of buffer, not including 2 byte size field */
1414                 cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
1415
1416                 /* 2k data + 4 byte header */
1417                 return (2048 + 4);
1418             }
1419
1420         case 0x01: /* DVD copyright information */
1421             buf[4] = 0; /* no copyright data */
1422             buf[5] = 0; /* no region restrictions */
1423
1424             /* Size of buffer, not including 2 byte size field */
1425             cpu_to_be16wu((uint16_t *)buf, 4 + 2);
1426
1427             /* 4 byte header + 4 byte data */
1428             return (4 + 4);
1429
1430         case 0x03: /* BCA information - invalid field for no BCA info */
1431             return -ASC_INV_FIELD_IN_CMD_PACKET;
1432
1433         case 0x04: /* DVD disc manufacturing information */
1434             /* Size of buffer, not including 2 byte size field */
1435             cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
1436
1437             /* 2k data + 4 byte header */
1438             return (2048 + 4);
1439
1440         case 0xff:
1441             /*
1442              * This lists all the command capabilities above.  Add new ones
1443              * in order and update the length and buffer return values.
1444              */
1445
1446             buf[4] = 0x00; /* Physical format */
1447             buf[5] = 0x40; /* Not writable, is readable */
1448             cpu_to_be16wu((uint16_t *)(buf + 6), 2048 + 4);
1449
1450             buf[8] = 0x01; /* Copyright info */
1451             buf[9] = 0x40; /* Not writable, is readable */
1452             cpu_to_be16wu((uint16_t *)(buf + 10), 4 + 4);
1453
1454             buf[12] = 0x03; /* BCA info */
1455             buf[13] = 0x40; /* Not writable, is readable */
1456             cpu_to_be16wu((uint16_t *)(buf + 14), 188 + 4);
1457
1458             buf[16] = 0x04; /* Manufacturing info */
1459             buf[17] = 0x40; /* Not writable, is readable */
1460             cpu_to_be16wu((uint16_t *)(buf + 18), 2048 + 4);
1461
1462             /* Size of buffer, not including 2 byte size field */
1463             cpu_to_be16wu((uint16_t *)buf, 16 + 2);
1464
1465             /* data written + 4 byte header */
1466             return (16 + 4);
1467
1468         default: /* TODO: formats beyond DVD-ROM requires */
1469             return -ASC_INV_FIELD_IN_CMD_PACKET;
1470     }
1471 }
1472
1473 static void ide_atapi_cmd(IDEState *s)
1474 {
1475     const uint8_t *packet;
1476     uint8_t *buf;
1477     int max_len;
1478
1479     packet = s->io_buffer;
1480     buf = s->io_buffer;
1481 #ifdef DEBUG_IDE_ATAPI
1482     {
1483         int i;
1484         printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8));
1485         for(i = 0; i < ATAPI_PACKET_SIZE; i++) {
1486             printf(" %02x", packet[i]);
1487         }
1488         printf("\n");
1489     }
1490 #endif
1491     switch(s->io_buffer[0]) {
1492     case GPCMD_TEST_UNIT_READY:
1493         if (bdrv_is_inserted(s->bs)) {
1494             ide_atapi_cmd_ok(s);
1495         } else {
1496             ide_atapi_cmd_error(s, SENSE_NOT_READY,
1497                                 ASC_MEDIUM_NOT_PRESENT);
1498         }
1499         break;
1500     case GPCMD_MODE_SENSE_6:
1501     case GPCMD_MODE_SENSE_10:
1502         {
1503             int action, code;
1504             if (packet[0] == GPCMD_MODE_SENSE_10)
1505                 max_len = ube16_to_cpu(packet + 7);
1506             else
1507                 max_len = packet[4];
1508             action = packet[2] >> 6;
1509             code = packet[2] & 0x3f;
1510             switch(action) {
1511             case 0: /* current values */
1512                 switch(code) {
1513                 case 0x01: /* error recovery */
1514                     cpu_to_ube16(&buf[0], 16 + 6);
1515                     buf[2] = 0x70;
1516                     buf[3] = 0;
1517                     buf[4] = 0;
1518                     buf[5] = 0;
1519                     buf[6] = 0;
1520                     buf[7] = 0;
1521
1522                     buf[8] = 0x01;
1523                     buf[9] = 0x06;
1524                     buf[10] = 0x00;
1525                     buf[11] = 0x05;
1526                     buf[12] = 0x00;
1527                     buf[13] = 0x00;
1528                     buf[14] = 0x00;
1529                     buf[15] = 0x00;
1530                     ide_atapi_cmd_reply(s, 16, max_len);
1531                     break;
1532                 case 0x2a:
1533                     cpu_to_ube16(&buf[0], 28 + 6);
1534                     buf[2] = 0x70;
1535                     buf[3] = 0;
1536                     buf[4] = 0;
1537                     buf[5] = 0;
1538                     buf[6] = 0;
1539                     buf[7] = 0;
1540
1541                     buf[8] = 0x2a;
1542                     buf[9] = 0x12;
1543                     buf[10] = 0x00;
1544                     buf[11] = 0x00;
1545
1546                     buf[12] = 0x70;
1547                     buf[13] = 3 << 5;
1548                     buf[14] = (1 << 0) | (1 << 3) | (1 << 5);
1549                     if (bdrv_is_locked(s->bs))
1550                         buf[6] |= 1 << 1;
1551                     buf[15] = 0x00;
1552                     cpu_to_ube16(&buf[16], 706);
1553                     buf[18] = 0;
1554                     buf[19] = 2;
1555                     cpu_to_ube16(&buf[20], 512);
1556                     cpu_to_ube16(&buf[22], 706);
1557                     buf[24] = 0;
1558                     buf[25] = 0;
1559                     buf[26] = 0;
1560                     buf[27] = 0;
1561                     ide_atapi_cmd_reply(s, 28, max_len);
1562                     break;
1563                 default:
1564                     goto error_cmd;
1565                 }
1566                 break;
1567             case 1: /* changeable values */
1568                 goto error_cmd;
1569             case 2: /* default values */
1570                 goto error_cmd;
1571             default:
1572             case 3: /* saved values */
1573                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1574                                     ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
1575                 break;
1576             }
1577         }
1578         break;
1579     case GPCMD_REQUEST_SENSE:
1580         max_len = packet[4];
1581         memset(buf, 0, 18);
1582         buf[0] = 0x70 | (1 << 7);
1583         buf[2] = s->sense_key;
1584         buf[7] = 10;
1585         buf[12] = s->asc;
1586         ide_atapi_cmd_reply(s, 18, max_len);
1587         break;
1588     case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
1589         if (bdrv_is_inserted(s->bs)) {
1590             bdrv_set_locked(s->bs, packet[4] & 1);
1591             ide_atapi_cmd_ok(s);
1592         } else {
1593             ide_atapi_cmd_error(s, SENSE_NOT_READY,
1594                                 ASC_MEDIUM_NOT_PRESENT);
1595         }
1596         break;
1597     case GPCMD_READ_10:
1598     case GPCMD_READ_12:
1599         {
1600             int nb_sectors, lba;
1601
1602             if (packet[0] == GPCMD_READ_10)
1603                 nb_sectors = ube16_to_cpu(packet + 7);
1604             else
1605                 nb_sectors = ube32_to_cpu(packet + 6);
1606             lba = ube32_to_cpu(packet + 2);
1607             if (nb_sectors == 0) {
1608                 ide_atapi_cmd_ok(s);
1609                 break;
1610             }
1611             ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
1612         }
1613         break;
1614     case GPCMD_READ_CD:
1615         {
1616             int nb_sectors, lba, transfer_request;
1617
1618             nb_sectors = (packet[6] << 16) | (packet[7] << 8) | packet[8];
1619             lba = ube32_to_cpu(packet + 2);
1620             if (nb_sectors == 0) {
1621                 ide_atapi_cmd_ok(s);
1622                 break;
1623             }
1624             transfer_request = packet[9];
1625             switch(transfer_request & 0xf8) {
1626             case 0x00:
1627                 /* nothing */
1628                 ide_atapi_cmd_ok(s);
1629                 break;
1630             case 0x10:
1631                 /* normal read */
1632                 ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
1633                 break;
1634             case 0xf8:
1635                 /* read all data */
1636                 ide_atapi_cmd_read(s, lba, nb_sectors, 2352);
1637                 break;
1638             default:
1639                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1640                                     ASC_INV_FIELD_IN_CMD_PACKET);
1641                 break;
1642             }
1643         }
1644         break;
1645     case GPCMD_SEEK:
1646         {
1647             unsigned int lba;
1648             uint64_t total_sectors;
1649
1650             bdrv_get_geometry(s->bs, &total_sectors);
1651             total_sectors >>= 2;
1652             if (total_sectors == 0) {
1653                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1654                                     ASC_MEDIUM_NOT_PRESENT);
1655                 break;
1656             }
1657             lba = ube32_to_cpu(packet + 2);
1658             if (lba >= total_sectors) {
1659                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1660                                     ASC_LOGICAL_BLOCK_OOR);
1661                 break;
1662             }
1663             ide_atapi_cmd_ok(s);
1664         }
1665         break;
1666     case GPCMD_START_STOP_UNIT:
1667         {
1668             int start, eject;
1669             start = packet[4] & 1;
1670             eject = (packet[4] >> 1) & 1;
1671
1672             if (eject && !start) {
1673                 /* eject the disk */
1674                 bdrv_eject(s->bs, 1);
1675             } else if (eject && start) {
1676                 /* close the tray */
1677                 bdrv_eject(s->bs, 0);
1678             }
1679             ide_atapi_cmd_ok(s);
1680         }
1681         break;
1682     case GPCMD_MECHANISM_STATUS:
1683         {
1684             max_len = ube16_to_cpu(packet + 8);
1685             cpu_to_ube16(buf, 0);
1686             /* no current LBA */
1687             buf[2] = 0;
1688             buf[3] = 0;
1689             buf[4] = 0;
1690             buf[5] = 1;
1691             cpu_to_ube16(buf + 6, 0);
1692             ide_atapi_cmd_reply(s, 8, max_len);
1693         }
1694         break;
1695     case GPCMD_READ_TOC_PMA_ATIP:
1696         {
1697             int format, msf, start_track, len;
1698             uint64_t total_sectors;
1699
1700             bdrv_get_geometry(s->bs, &total_sectors);
1701             total_sectors >>= 2;
1702             if (total_sectors == 0) {
1703                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1704                                     ASC_MEDIUM_NOT_PRESENT);
1705                 break;
1706             }
1707             max_len = ube16_to_cpu(packet + 7);
1708             format = packet[9] >> 6;
1709             msf = (packet[1] >> 1) & 1;
1710             start_track = packet[6];
1711             switch(format) {
1712             case 0:
1713                 len = cdrom_read_toc(total_sectors, buf, msf, start_track);
1714                 if (len < 0)
1715                     goto error_cmd;
1716                 ide_atapi_cmd_reply(s, len, max_len);
1717                 break;
1718             case 1:
1719                 /* multi session : only a single session defined */
1720                 memset(buf, 0, 12);
1721                 buf[1] = 0x0a;
1722                 buf[2] = 0x01;
1723                 buf[3] = 0x01;
1724                 ide_atapi_cmd_reply(s, 12, max_len);
1725                 break;
1726             case 2:
1727                 len = cdrom_read_toc_raw(total_sectors, buf, msf, start_track);
1728                 if (len < 0)
1729                     goto error_cmd;
1730                 ide_atapi_cmd_reply(s, len, max_len);
1731                 break;
1732             default:
1733             error_cmd:
1734                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1735                                     ASC_INV_FIELD_IN_CMD_PACKET);
1736                 break;
1737             }
1738         }
1739         break;
1740     case GPCMD_READ_CDVD_CAPACITY:
1741         {
1742             uint64_t total_sectors;
1743
1744             bdrv_get_geometry(s->bs, &total_sectors);
1745             total_sectors >>= 2;
1746             if (total_sectors == 0) {
1747                 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1748                                     ASC_MEDIUM_NOT_PRESENT);
1749                 break;
1750             }
1751             /* NOTE: it is really the number of sectors minus 1 */
1752             cpu_to_ube32(buf, total_sectors - 1);
1753             cpu_to_ube32(buf + 4, 2048);
1754             ide_atapi_cmd_reply(s, 8, 8);
1755         }
1756         break;
1757     case GPCMD_READ_DVD_STRUCTURE:
1758         {
1759             int media = packet[1];
1760             int format = packet[7];
1761             int ret;
1762
1763             max_len = ube16_to_cpu(packet + 8);
1764
1765             if (format < 0xff) {
1766                 if (media_is_cd(s)) {
1767                     ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1768                                         ASC_INCOMPATIBLE_FORMAT);
1769                     break;
1770                 } else if (!media_present(s)) {
1771                     ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1772                                         ASC_INV_FIELD_IN_CMD_PACKET);
1773                     break;
1774                 }
1775             }
1776
1777             memset(buf, 0, max_len > IDE_DMA_BUF_SECTORS * 512 + 4 ?
1778                    IDE_DMA_BUF_SECTORS * 512 + 4 : max_len);
1779
1780             switch (format) {
1781                 case 0x00 ... 0x7f:
1782                 case 0xff:
1783                     if (media == 0) {
1784                         ret = ide_dvd_read_structure(s, format, packet, buf);
1785
1786                         if (ret < 0)
1787                             ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST, -ret);
1788                         else
1789                             ide_atapi_cmd_reply(s, ret, max_len);
1790
1791                         break;
1792                     }
1793                     /* TODO: BD support, fall through for now */
1794
1795                 /* Generic disk structures */
1796                 case 0x80: /* TODO: AACS volume identifier */
1797                 case 0x81: /* TODO: AACS media serial number */
1798                 case 0x82: /* TODO: AACS media identifier */
1799                 case 0x83: /* TODO: AACS media key block */
1800                 case 0x90: /* TODO: List of recognized format layers */
1801                 case 0xc0: /* TODO: Write protection status */
1802                 default:
1803                     ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1804                                         ASC_INV_FIELD_IN_CMD_PACKET);
1805                     break;
1806             }
1807         }
1808         break;
1809     case GPCMD_SET_SPEED:
1810         ide_atapi_cmd_ok(s);
1811         break;
1812     case GPCMD_INQUIRY:
1813         max_len = packet[4];
1814         buf[0] = 0x05; /* CD-ROM */
1815         buf[1] = 0x80; /* removable */
1816         buf[2] = 0x00; /* ISO */
1817         buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1818         buf[4] = 31; /* additional length */
1819         buf[5] = 0; /* reserved */
1820         buf[6] = 0; /* reserved */
1821         buf[7] = 0; /* reserved */
1822         padstr8(buf + 8, 8, "QEMU");
1823         padstr8(buf + 16, 16, "QEMU DVD-ROM");
1824         padstr8(buf + 32, 4, QEMU_VERSION);
1825         ide_atapi_cmd_reply(s, 36, max_len);
1826         break;
1827     case GPCMD_GET_CONFIGURATION:
1828         {
1829             uint32_t len;
1830             uint8_t index = 0;
1831
1832             /* only feature 0 is supported */
1833             if (packet[2] != 0 || packet[3] != 0) {
1834                 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1835                                     ASC_INV_FIELD_IN_CMD_PACKET);
1836                 break;
1837             }
1838
1839             /* XXX: could result in alignment problems in some architectures */
1840             max_len = ube16_to_cpu(packet + 7);
1841
1842             /*
1843              * XXX: avoid overflow for io_buffer if max_len is bigger than
1844              *      the size of that buffer (dimensioned to max number of
1845              *      sectors to transfer at once)
1846              *
1847              *      Only a problem if the feature/profiles grow.
1848              */
1849             if (max_len > 512) /* XXX: assume 1 sector */
1850                 max_len = 512;
1851
1852             memset(buf, 0, max_len);
1853             /*
1854              * the number of sectors from the media tells us which profile
1855              * to use as current.  0 means there is no media
1856              */
1857             if (media_is_dvd(s))
1858                 cpu_to_ube16(buf + 6, MMC_PROFILE_DVD_ROM);
1859             else if (media_is_cd(s))
1860                 cpu_to_ube16(buf + 6, MMC_PROFILE_CD_ROM);
1861
1862             buf[10] = 0x02 | 0x01; /* persistent and current */
1863             len = 12; /* headers: 8 + 4 */
1864             len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_DVD_ROM);
1865             len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_CD_ROM);
1866             cpu_to_ube32(buf, len - 4); /* data length */
1867
1868             ide_atapi_cmd_reply(s, len, max_len);
1869             break;
1870         }
1871     default:
1872         ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1873                             ASC_ILLEGAL_OPCODE);
1874         break;
1875     }
1876 }
1877
1878 static void ide_cfata_metadata_inquiry(IDEState *s)
1879 {
1880     uint16_t *p;
1881     uint32_t spd;
1882
1883     p = (uint16_t *) s->io_buffer;
1884     memset(p, 0, 0x200);
1885     spd = ((s->mdata_size - 1) >> 9) + 1;
1886
1887     put_le16(p + 0, 0x0001);                    /* Data format revision */
1888     put_le16(p + 1, 0x0000);                    /* Media property: silicon */
1889     put_le16(p + 2, s->media_changed);          /* Media status */
1890     put_le16(p + 3, s->mdata_size & 0xffff);    /* Capacity in bytes (low) */
1891     put_le16(p + 4, s->mdata_size >> 16);       /* Capacity in bytes (high) */
1892     put_le16(p + 5, spd & 0xffff);              /* Sectors per device (low) */
1893     put_le16(p + 6, spd >> 16);                 /* Sectors per device (high) */
1894 }
1895
1896 static void ide_cfata_metadata_read(IDEState *s)
1897 {
1898     uint16_t *p;
1899
1900     if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
1901         s->status = ERR_STAT;
1902         s->error = ABRT_ERR;
1903         return;
1904     }
1905
1906     p = (uint16_t *) s->io_buffer;
1907     memset(p, 0, 0x200);
1908
1909     put_le16(p + 0, s->media_changed);          /* Media status */
1910     memcpy(p + 1, s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
1911                     MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
1912                                     s->nsector << 9), 0x200 - 2));
1913 }
1914
1915 static void ide_cfata_metadata_write(IDEState *s)
1916 {
1917     if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
1918         s->status = ERR_STAT;
1919         s->error = ABRT_ERR;
1920         return;
1921     }
1922
1923     s->media_changed = 0;
1924
1925     memcpy(s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
1926                     s->io_buffer + 2,
1927                     MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
1928                                     s->nsector << 9), 0x200 - 2));
1929 }
1930
1931 /* called when the inserted state of the media has changed */
1932 static void cdrom_change_cb(void *opaque)
1933 {
1934     IDEState *s = opaque;
1935     uint64_t nb_sectors;
1936
1937     /* XXX: send interrupt too */
1938     bdrv_get_geometry(s->bs, &nb_sectors);
1939     s->nb_sectors = nb_sectors;
1940 }
1941
1942 static void ide_cmd_lba48_transform(IDEState *s, int lba48)
1943 {
1944     s->lba48 = lba48;
1945
1946     /* handle the 'magic' 0 nsector count conversion here. to avoid
1947      * fiddling with the rest of the read logic, we just store the
1948      * full sector count in ->nsector and ignore ->hob_nsector from now
1949      */
1950     if (!s->lba48) {
1951         if (!s->nsector)
1952             s->nsector = 256;
1953     } else {
1954         if (!s->nsector && !s->hob_nsector)
1955             s->nsector = 65536;
1956         else {
1957             int lo = s->nsector;
1958             int hi = s->hob_nsector;
1959
1960             s->nsector = (hi << 8) | lo;
1961         }
1962     }
1963 }
1964
1965 static void ide_clear_hob(IDEState *ide_if)
1966 {
1967     /* any write clears HOB high bit of device control register */
1968     ide_if[0].select &= ~(1 << 7);
1969     ide_if[1].select &= ~(1 << 7);
1970 }
1971
1972 static void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
1973 {
1974     IDEState *ide_if = opaque;
1975     IDEState *s;
1976     int unit, n;
1977     int lba48 = 0;
1978
1979 #ifdef DEBUG_IDE
1980     printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
1981 #endif
1982
1983     addr &= 7;
1984     switch(addr) {
1985     case 0:
1986         break;
1987     case 1:
1988         ide_clear_hob(ide_if);
1989         /* NOTE: data is written to the two drives */
1990         ide_if[0].hob_feature = ide_if[0].feature;
1991         ide_if[1].hob_feature = ide_if[1].feature;
1992         ide_if[0].feature = val;
1993         ide_if[1].feature = val;
1994         break;
1995     case 2:
1996         ide_clear_hob(ide_if);
1997         ide_if[0].hob_nsector = ide_if[0].nsector;
1998         ide_if[1].hob_nsector = ide_if[1].nsector;
1999         ide_if[0].nsector = val;
2000         ide_if[1].nsector = val;
2001         break;
2002     case 3:
2003         ide_clear_hob(ide_if);
2004         ide_if[0].hob_sector = ide_if[0].sector;
2005         ide_if[1].hob_sector = ide_if[1].sector;
2006         ide_if[0].sector = val;
2007         ide_if[1].sector = val;
2008         break;
2009     case 4:
2010         ide_clear_hob(ide_if);
2011         ide_if[0].hob_lcyl = ide_if[0].lcyl;
2012         ide_if[1].hob_lcyl = ide_if[1].lcyl;
2013         ide_if[0].lcyl = val;
2014         ide_if[1].lcyl = val;
2015         break;
2016     case 5:
2017         ide_clear_hob(ide_if);
2018         ide_if[0].hob_hcyl = ide_if[0].hcyl;
2019         ide_if[1].hob_hcyl = ide_if[1].hcyl;
2020         ide_if[0].hcyl = val;
2021         ide_if[1].hcyl = val;
2022         break;
2023     case 6:
2024         /* FIXME: HOB readback uses bit 7 */
2025         ide_if[0].select = (val & ~0x10) | 0xa0;
2026         ide_if[1].select = (val | 0x10) | 0xa0;
2027         /* select drive */
2028         unit = (val >> 4) & 1;
2029         s = ide_if + unit;
2030         ide_if->cur_drive = s;
2031         break;
2032     default:
2033     case 7:
2034         /* command */
2035 #if defined(DEBUG_IDE)
2036         printf("ide: CMD=%02x\n", val);
2037 #endif
2038         s = ide_if->cur_drive;
2039         /* ignore commands to non existant slave */
2040         if (s != ide_if && !s->bs)
2041             break;
2042
2043         switch(val) {
2044         case WIN_IDENTIFY:
2045             if (s->bs && !s->is_cdrom) {
2046                 if (!s->is_cf)
2047                     ide_identify(s);
2048                 else
2049                     ide_cfata_identify(s);
2050                 s->status = READY_STAT | SEEK_STAT;
2051                 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
2052             } else {
2053                 if (s->is_cdrom) {
2054                     ide_set_signature(s);
2055                 }
2056                 ide_abort_command(s);
2057             }
2058             ide_set_irq(s);
2059             break;
2060         case WIN_SPECIFY:
2061         case WIN_RECAL:
2062             s->error = 0;
2063             s->status = READY_STAT | SEEK_STAT;
2064             ide_set_irq(s);
2065             break;
2066         case WIN_SETMULT:
2067             if (s->is_cf && s->nsector == 0) {
2068                 /* Disable Read and Write Multiple */
2069                 s->mult_sectors = 0;
2070                 s->status = READY_STAT | SEEK_STAT;
2071             } else if ((s->nsector & 0xff) != 0 &&
2072                 ((s->nsector & 0xff) > MAX_MULT_SECTORS ||
2073                  (s->nsector & (s->nsector - 1)) != 0)) {
2074                 ide_abort_command(s);
2075             } else {
2076                 s->mult_sectors = s->nsector & 0xff;
2077                 s->status = READY_STAT | SEEK_STAT;
2078             }
2079             ide_set_irq(s);
2080             break;
2081         case WIN_VERIFY_EXT:
2082             lba48 = 1;
2083         case WIN_VERIFY:
2084         case WIN_VERIFY_ONCE:
2085             /* do sector number check ? */
2086             ide_cmd_lba48_transform(s, lba48);
2087             s->status = READY_STAT | SEEK_STAT;
2088             ide_set_irq(s);
2089             break;
2090         case WIN_READ_EXT:
2091             lba48 = 1;
2092         case WIN_READ:
2093         case WIN_READ_ONCE:
2094             if (!s->bs)
2095                 goto abort_cmd;
2096             ide_cmd_lba48_transform(s, lba48);
2097             s->req_nb_sectors = 1;
2098             ide_sector_read(s);
2099             break;
2100         case WIN_WRITE_EXT:
2101             lba48 = 1;
2102         case WIN_WRITE:
2103         case WIN_WRITE_ONCE:
2104         case CFA_WRITE_SECT_WO_ERASE:
2105         case WIN_WRITE_VERIFY:
2106             ide_cmd_lba48_transform(s, lba48);
2107             s->error = 0;
2108             s->status = SEEK_STAT | READY_STAT;
2109             s->req_nb_sectors = 1;
2110             ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
2111             s->media_changed = 1;
2112             break;
2113         case WIN_MULTREAD_EXT:
2114             lba48 = 1;
2115         case WIN_MULTREAD:
2116             if (!s->mult_sectors)
2117                 goto abort_cmd;
2118             ide_cmd_lba48_transform(s, lba48);
2119             s->req_nb_sectors = s->mult_sectors;
2120             ide_sector_read(s);
2121             break;
2122         case WIN_MULTWRITE_EXT:
2123             lba48 = 1;
2124         case WIN_MULTWRITE:
2125         case CFA_WRITE_MULTI_WO_ERASE:
2126             if (!s->mult_sectors)
2127                 goto abort_cmd;
2128             ide_cmd_lba48_transform(s, lba48);
2129             s->error = 0;
2130             s->status = SEEK_STAT | READY_STAT;
2131             s->req_nb_sectors = s->mult_sectors;
2132             n = s->nsector;
2133             if (n > s->req_nb_sectors)
2134                 n = s->req_nb_sectors;
2135             ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
2136             s->media_changed = 1;
2137             break;
2138         case WIN_READDMA_EXT:
2139             lba48 = 1;
2140         case WIN_READDMA:
2141         case WIN_READDMA_ONCE:
2142             if (!s->bs)
2143                 goto abort_cmd;
2144             ide_cmd_lba48_transform(s, lba48);
2145             ide_sector_read_dma(s);
2146             break;
2147         case WIN_WRITEDMA_EXT:
2148             lba48 = 1;
2149         case WIN_WRITEDMA:
2150         case WIN_WRITEDMA_ONCE:
2151             if (!s->bs)
2152                 goto abort_cmd;
2153             ide_cmd_lba48_transform(s, lba48);
2154             ide_sector_write_dma(s);
2155             s->media_changed = 1;
2156             break;
2157         case WIN_READ_NATIVE_MAX_EXT:
2158             lba48 = 1;
2159         case WIN_READ_NATIVE_MAX:
2160             ide_cmd_lba48_transform(s, lba48);
2161             ide_set_sector(s, s->nb_sectors - 1);
2162             s->status = READY_STAT | SEEK_STAT;
2163             ide_set_irq(s);
2164             break;
2165         case WIN_CHECKPOWERMODE1:
2166         case WIN_CHECKPOWERMODE2:
2167             s->nsector = 0xff; /* device active or idle */
2168             s->status = READY_STAT | SEEK_STAT;
2169             ide_set_irq(s);
2170             break;
2171         case WIN_SETFEATURES:
2172             if (!s->bs)
2173                 goto abort_cmd;
2174             /* XXX: valid for CDROM ? */
2175             switch(s->feature) {
2176             case 0xcc: /* reverting to power-on defaults enable */
2177             case 0x66: /* reverting to power-on defaults disable */
2178             case 0x02: /* write cache enable */
2179             case 0x82: /* write cache disable */
2180             case 0xaa: /* read look-ahead enable */
2181             case 0x55: /* read look-ahead disable */
2182             case 0x05: /* set advanced power management mode */
2183             case 0x85: /* disable advanced power management mode */
2184             case 0x69: /* NOP */
2185             case 0x67: /* NOP */
2186             case 0x96: /* NOP */
2187             case 0x9a: /* NOP */
2188             case 0x42: /* enable Automatic Acoustic Mode */
2189             case 0xc2: /* disable Automatic Acoustic Mode */
2190                 s->status = READY_STAT | SEEK_STAT;
2191                 ide_set_irq(s);
2192                 break;
2193             case 0x03: { /* set transfer mode */
2194                 uint8_t val = s->nsector & 0x07;
2195
2196                 switch (s->nsector >> 3) {
2197                     case 0x00: /* pio default */
2198                     case 0x01: /* pio mode */
2199                         put_le16(s->identify_data + 62,0x07);
2200                         put_le16(s->identify_data + 63,0x07);
2201                         put_le16(s->identify_data + 88,0x3f);
2202                         break;
2203                     case 0x02: /* sigle word dma mode*/
2204                         put_le16(s->identify_data + 62,0x07 | (1 << (val + 8)));
2205                         put_le16(s->identify_data + 63,0x07);
2206                         put_le16(s->identify_data + 88,0x3f);
2207                         break;
2208                     case 0x04: /* mdma mode */
2209                         put_le16(s->identify_data + 62,0x07);
2210                         put_le16(s->identify_data + 63,0x07 | (1 << (val + 8)));
2211                         put_le16(s->identify_data + 88,0x3f);
2212                         break;
2213                     case 0x08: /* udma mode */
2214                         put_le16(s->identify_data + 62,0x07);
2215                         put_le16(s->identify_data + 63,0x07);
2216                         put_le16(s->identify_data + 88,0x3f | (1 << (val + 8)));
2217                         break;
2218                     default:
2219                         goto abort_cmd;
2220                 }
2221                 s->status = READY_STAT | SEEK_STAT;
2222                 ide_set_irq(s);
2223                 break;
2224             }
2225             default:
2226                 goto abort_cmd;
2227             }
2228             break;
2229         case WIN_FLUSH_CACHE:
2230         case WIN_FLUSH_CACHE_EXT:
2231             if (s->bs)
2232                 bdrv_flush(s->bs);
2233             s->status = READY_STAT | SEEK_STAT;
2234             ide_set_irq(s);
2235             break;
2236         case WIN_STANDBY:
2237         case WIN_STANDBY2:
2238         case WIN_STANDBYNOW1:
2239         case WIN_STANDBYNOW2:
2240         case WIN_IDLEIMMEDIATE:
2241         case CFA_IDLEIMMEDIATE:
2242         case WIN_SETIDLE1:
2243         case WIN_SETIDLE2:
2244         case WIN_SLEEPNOW1:
2245         case WIN_SLEEPNOW2:
2246             s->status = READY_STAT;
2247             ide_set_irq(s);
2248             break;
2249             /* ATAPI commands */
2250         case WIN_PIDENTIFY:
2251             if (s->is_cdrom) {
2252                 ide_atapi_identify(s);
2253                 s->status = READY_STAT | SEEK_STAT;
2254                 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
2255             } else {
2256                 ide_abort_command(s);
2257             }
2258             ide_set_irq(s);
2259             break;
2260         case WIN_DIAGNOSE:
2261             ide_set_signature(s);
2262             s->status = READY_STAT | SEEK_STAT;
2263             s->error = 0x01;
2264             ide_set_irq(s);
2265             break;
2266         case WIN_SRST:
2267             if (!s->is_cdrom)
2268                 goto abort_cmd;
2269             ide_set_signature(s);
2270             s->status = 0x00; /* NOTE: READY is _not_ set */
2271             s->error = 0x01;
2272             break;
2273         case WIN_PACKETCMD:
2274             if (!s->is_cdrom)
2275                 goto abort_cmd;
2276             /* overlapping commands not supported */
2277             if (s->feature & 0x02)
2278                 goto abort_cmd;
2279             s->status = READY_STAT | SEEK_STAT;
2280             s->atapi_dma = s->feature & 1;
2281             s->nsector = 1;
2282             ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
2283                                ide_atapi_cmd);
2284             break;
2285         /* CF-ATA commands */
2286         case CFA_REQ_EXT_ERROR_CODE:
2287             if (!s->is_cf)
2288                 goto abort_cmd;
2289             s->error = 0x09;    /* miscellaneous error */
2290             s->status = READY_STAT | SEEK_STAT;
2291             ide_set_irq(s);
2292             break;
2293         case CFA_ERASE_SECTORS:
2294         case CFA_WEAR_LEVEL:
2295             if (!s->is_cf)
2296                 goto abort_cmd;
2297             if (val == CFA_WEAR_LEVEL)
2298                 s->nsector = 0;
2299             if (val == CFA_ERASE_SECTORS)
2300                 s->media_changed = 1;
2301             s->error = 0x00;
2302             s->status = READY_STAT | SEEK_STAT;
2303             ide_set_irq(s);
2304             break;
2305         case CFA_TRANSLATE_SECTOR:
2306             if (!s->is_cf)
2307                 goto abort_cmd;
2308             s->error = 0x00;
2309             s->status = READY_STAT | SEEK_STAT;
2310             memset(s->io_buffer, 0, 0x200);
2311             s->io_buffer[0x00] = s->hcyl;                       /* Cyl MSB */
2312             s->io_buffer[0x01] = s->lcyl;                       /* Cyl LSB */
2313             s->io_buffer[0x02] = s->select;                     /* Head */
2314             s->io_buffer[0x03] = s->sector;                     /* Sector */
2315             s->io_buffer[0x04] = ide_get_sector(s) >> 16;       /* LBA MSB */
2316             s->io_buffer[0x05] = ide_get_sector(s) >> 8;        /* LBA */
2317             s->io_buffer[0x06] = ide_get_sector(s) >> 0;        /* LBA LSB */
2318             s->io_buffer[0x13] = 0x00;                          /* Erase flag */
2319             s->io_buffer[0x18] = 0x00;                          /* Hot count */
2320             s->io_buffer[0x19] = 0x00;                          /* Hot count */
2321             s->io_buffer[0x1a] = 0x01;                          /* Hot count */
2322             ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2323             ide_set_irq(s);
2324             break;
2325         case CFA_ACCESS_METADATA_STORAGE:
2326             if (!s->is_cf)
2327                 goto abort_cmd;
2328             switch (s->feature) {
2329             case 0x02:  /* Inquiry Metadata Storage */
2330                 ide_cfata_metadata_inquiry(s);
2331                 break;
2332             case 0x03:  /* Read Metadata Storage */
2333                 ide_cfata_metadata_read(s);
2334                 break;
2335             case 0x04:  /* Write Metadata Storage */
2336                 ide_cfata_metadata_write(s);
2337                 break;
2338             default:
2339                 goto abort_cmd;
2340             }
2341             ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2342             s->status = 0x00; /* NOTE: READY is _not_ set */
2343             ide_set_irq(s);
2344             break;
2345         case IBM_SENSE_CONDITION:
2346             if (!s->is_cf)
2347                 goto abort_cmd;
2348             switch (s->feature) {
2349             case 0x01:  /* sense temperature in device */
2350                 s->nsector = 0x50;      /* +20 C */
2351                 break;
2352             default:
2353                 goto abort_cmd;
2354             }
2355             s->status = READY_STAT | SEEK_STAT;
2356             ide_set_irq(s);
2357             break;
2358         default:
2359         abort_cmd:
2360             ide_abort_command(s);
2361             ide_set_irq(s);
2362             break;
2363         }
2364     }
2365 }
2366
2367 static uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
2368 {
2369     IDEState *ide_if = opaque;
2370     IDEState *s = ide_if->cur_drive;
2371     uint32_t addr;
2372     int ret, hob;
2373
2374     addr = addr1 & 7;
2375     /* FIXME: HOB readback uses bit 7, but it's always set right now */
2376     //hob = s->select & (1 << 7);
2377     hob = 0;
2378     switch(addr) {
2379     case 0:
2380         ret = 0xff;
2381         break;
2382     case 1:
2383         if (!ide_if[0].bs && !ide_if[1].bs)
2384             ret = 0;
2385         else if (!hob)
2386             ret = s->error;
2387         else
2388             ret = s->hob_feature;
2389         break;
2390     case 2:
2391         if (!ide_if[0].bs && !ide_if[1].bs)
2392             ret = 0;
2393         else if (!hob)
2394             ret = s->nsector & 0xff;
2395         else
2396             ret = s->hob_nsector;
2397         break;
2398     case 3:
2399         if (!ide_if[0].bs && !ide_if[1].bs)
2400             ret = 0;
2401         else if (!hob)
2402             ret = s->sector;
2403         else
2404             ret = s->hob_sector;
2405         break;
2406     case 4:
2407         if (!ide_if[0].bs && !ide_if[1].bs)
2408             ret = 0;
2409         else if (!hob)
2410             ret = s->lcyl;
2411         else
2412             ret = s->hob_lcyl;
2413         break;
2414     case 5:
2415         if (!ide_if[0].bs && !ide_if[1].bs)
2416             ret = 0;
2417         else if (!hob)
2418             ret = s->hcyl;
2419         else
2420             ret = s->hob_hcyl;
2421         break;
2422     case 6:
2423         if (!ide_if[0].bs && !ide_if[1].bs)
2424             ret = 0;
2425         else
2426             ret = s->select;
2427         break;
2428     default:
2429     case 7:
2430         if ((!ide_if[0].bs && !ide_if[1].bs) ||
2431             (s != ide_if && !s->bs))
2432             ret = 0;
2433         else
2434             ret = s->status;
2435         qemu_irq_lower(s->irq);
2436         break;
2437     }
2438 #ifdef DEBUG_IDE
2439     printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
2440 #endif
2441     return ret;
2442 }
2443
2444 static uint32_t ide_status_read(void *opaque, uint32_t addr)
2445 {
2446     IDEState *ide_if = opaque;
2447     IDEState *s = ide_if->cur_drive;
2448     int ret;
2449
2450     if ((!ide_if[0].bs && !ide_if[1].bs) ||
2451         (s != ide_if && !s->bs))
2452         ret = 0;
2453     else
2454         ret = s->status;
2455 #ifdef DEBUG_IDE
2456     printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
2457 #endif
2458     return ret;
2459 }
2460
2461 static void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
2462 {
2463     IDEState *ide_if = opaque;
2464     IDEState *s;
2465     int i;
2466
2467 #ifdef DEBUG_IDE
2468     printf("ide: write control addr=0x%x val=%02x\n", addr, val);
2469 #endif
2470     /* common for both drives */
2471     if (!(ide_if[0].cmd & IDE_CMD_RESET) &&
2472         (val & IDE_CMD_RESET)) {
2473         /* reset low to high */
2474         for(i = 0;i < 2; i++) {
2475             s = &ide_if[i];
2476             s->status = BUSY_STAT | SEEK_STAT;
2477             s->error = 0x01;
2478         }
2479     } else if ((ide_if[0].cmd & IDE_CMD_RESET) &&
2480                !(val & IDE_CMD_RESET)) {
2481         /* high to low */
2482         for(i = 0;i < 2; i++) {
2483             s = &ide_if[i];
2484             if (s->is_cdrom)
2485                 s->status = 0x00; /* NOTE: READY is _not_ set */
2486             else
2487                 s->status = READY_STAT | SEEK_STAT;
2488             ide_set_signature(s);
2489         }
2490     }
2491
2492     ide_if[0].cmd = val;
2493     ide_if[1].cmd = val;
2494 }
2495
2496 static void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
2497 {
2498     IDEState *s = ((IDEState *)opaque)->cur_drive;
2499     uint8_t *p;
2500
2501     p = s->data_ptr;
2502     *(uint16_t *)p = le16_to_cpu(val);
2503     p += 2;
2504     s->data_ptr = p;
2505     if (p >= s->data_end)
2506         s->end_transfer_func(s);
2507 }
2508
2509 static uint32_t ide_data_readw(void *opaque, uint32_t addr)
2510 {
2511     IDEState *s = ((IDEState *)opaque)->cur_drive;
2512     uint8_t *p;
2513     int ret;
2514     p = s->data_ptr;
2515     ret = cpu_to_le16(*(uint16_t *)p);
2516     p += 2;
2517     s->data_ptr = p;
2518     if (p >= s->data_end)
2519         s->end_transfer_func(s);
2520     return ret;
2521 }
2522
2523 static void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
2524 {
2525     IDEState *s = ((IDEState *)opaque)->cur_drive;
2526     uint8_t *p;
2527
2528     p = s->data_ptr;
2529     *(uint32_t *)p = le32_to_cpu(val);
2530     p += 4;
2531     s->data_ptr = p;
2532     if (p >= s->data_end)
2533         s->end_transfer_func(s);
2534 }
2535
2536 static uint32_t ide_data_readl(void *opaque, uint32_t addr)
2537 {
2538     IDEState *s = ((IDEState *)opaque)->cur_drive;
2539     uint8_t *p;
2540     int ret;
2541
2542     p = s->data_ptr;
2543     ret = cpu_to_le32(*(uint32_t *)p);
2544     p += 4;
2545     s->data_ptr = p;
2546     if (p >= s->data_end)
2547         s->end_transfer_func(s);
2548     return ret;
2549 }
2550
2551 static void ide_dummy_transfer_stop(IDEState *s)
2552 {
2553     s->data_ptr = s->io_buffer;
2554     s->data_end = s->io_buffer;
2555     s->io_buffer[0] = 0xff;
2556     s->io_buffer[1] = 0xff;
2557     s->io_buffer[2] = 0xff;
2558     s->io_buffer[3] = 0xff;
2559 }
2560
2561 static void ide_reset(IDEState *s)
2562 {
2563     if (s->is_cf)
2564         s->mult_sectors = 0;
2565     else
2566         s->mult_sectors = MAX_MULT_SECTORS;
2567     s->cur_drive = s;
2568     s->select = 0xa0;
2569     s->status = READY_STAT | SEEK_STAT;
2570     ide_set_signature(s);
2571     /* init the transfer handler so that 0xffff is returned on data
2572        accesses */
2573     s->end_transfer_func = ide_dummy_transfer_stop;
2574     ide_dummy_transfer_stop(s);
2575     s->media_changed = 0;
2576 }
2577
2578 struct partition {
2579         uint8_t boot_ind;               /* 0x80 - active */
2580         uint8_t head;           /* starting head */
2581         uint8_t sector;         /* starting sector */
2582         uint8_t cyl;            /* starting cylinder */
2583         uint8_t sys_ind;                /* What partition type */
2584         uint8_t end_head;               /* end head */
2585         uint8_t end_sector;     /* end sector */
2586         uint8_t end_cyl;                /* end cylinder */
2587         uint32_t start_sect;    /* starting sector counting from 0 */
2588         uint32_t nr_sects;              /* nr of sectors in partition */
2589 } __attribute__((packed));
2590
2591 /* try to guess the disk logical geometry from the MSDOS partition table. Return 0 if OK, -1 if could not guess */
2592 static int guess_disk_lchs(IDEState *s,
2593                            int *pcylinders, int *pheads, int *psectors)
2594 {
2595     uint8_t *buf = s->io_buffer;
2596     int ret, i, heads, sectors, cylinders;
2597     struct partition *p;
2598     uint32_t nr_sects;
2599
2600     ret = bdrv_read(s->bs, 0, buf, 1);
2601     if (ret < 0) {
2602         return -1;
2603     }
2604     /* test msdos magic */
2605     if (buf[510] != 0x55 || buf[511] != 0xaa) {
2606         return -1;
2607     }
2608     for(i = 0; i < 4; i++) {
2609         p = ((struct partition *)(buf + 0x1be)) + i;
2610         nr_sects = le32_to_cpu(p->nr_sects);
2611         if (nr_sects && p->end_head) {
2612             /* We make the assumption that the partition terminates on
2613                a cylinder boundary */
2614             heads = p->end_head + 1;
2615             sectors = p->end_sector & 63;
2616             if (sectors == 0)
2617                 continue;
2618             cylinders = s->nb_sectors / (heads * sectors);
2619             if (cylinders < 1 || cylinders > 16383)
2620                 continue;
2621             *pheads = heads;
2622             *psectors = sectors;
2623             *pcylinders = cylinders;
2624 #if 0
2625             printf("guessed geometry: LCHS=%d %d %d\n",
2626                    cylinders, heads, sectors);
2627 #endif
2628             return 0;
2629         }
2630     }
2631     return -1;
2632 }
2633
2634 static void ide_init2(IDEState *ide_state,
2635                       BlockDriverState *hd0, BlockDriverState *hd1,
2636                       qemu_irq irq)
2637 {
2638     IDEState *s;
2639     static int drive_serial = 1;
2640     int i, cylinders, heads, secs, translation, lba_detected = 0;
2641     uint64_t nb_sectors;
2642
2643     for(i = 0; i < 2; i++) {
2644         s = ide_state + i;
2645         s->io_buffer = qemu_memalign(512, IDE_DMA_BUF_SECTORS*512 + 4);
2646         if (i == 0)
2647             s->bs = hd0;
2648         else
2649             s->bs = hd1;
2650         if (s->bs) {
2651             bdrv_get_geometry(s->bs, &nb_sectors);
2652             s->nb_sectors = nb_sectors;
2653             /* if a geometry hint is available, use it */
2654             bdrv_get_geometry_hint(s->bs, &cylinders, &heads, &secs);
2655             translation = bdrv_get_translation_hint(s->bs);
2656             if (cylinders != 0) {
2657                 s->cylinders = cylinders;
2658                 s->heads = heads;
2659                 s->sectors = secs;
2660             } else {
2661                 if (guess_disk_lchs(s, &cylinders, &heads, &secs) == 0) {
2662                     if (heads > 16) {
2663                         /* if heads > 16, it means that a BIOS LBA
2664                            translation was active, so the default
2665                            hardware geometry is OK */
2666                         lba_detected = 1;
2667                         goto default_geometry;
2668                     } else {
2669                         s->cylinders = cylinders;
2670                         s->heads = heads;
2671                         s->sectors = secs;
2672                         /* disable any translation to be in sync with
2673                            the logical geometry */
2674                         if (translation == BIOS_ATA_TRANSLATION_AUTO) {
2675                             bdrv_set_translation_hint(s->bs,
2676                                                       BIOS_ATA_TRANSLATION_NONE);
2677                         }
2678                     }
2679                 } else {
2680                 default_geometry:
2681                     /* if no geometry, use a standard physical disk geometry */
2682                     cylinders = nb_sectors / (16 * 63);
2683                     if (cylinders > 16383)
2684                         cylinders = 16383;
2685                     else if (cylinders < 2)
2686                         cylinders = 2;
2687                     s->cylinders = cylinders;
2688                     s->heads = 16;
2689                     s->sectors = 63;
2690                     if ((lba_detected == 1) && (translation == BIOS_ATA_TRANSLATION_AUTO)) {
2691                       if ((s->cylinders * s->heads) <= 131072) {
2692                         bdrv_set_translation_hint(s->bs,
2693                                                   BIOS_ATA_TRANSLATION_LARGE);
2694                       } else {
2695                         bdrv_set_translation_hint(s->bs,
2696                                                   BIOS_ATA_TRANSLATION_LBA);
2697                       }
2698                     }
2699                 }
2700                 bdrv_set_geometry_hint(s->bs, s->cylinders, s->heads, s->sectors);
2701             }
2702             if (bdrv_get_type_hint(s->bs) == BDRV_TYPE_CDROM) {
2703                 s->is_cdrom = 1;
2704                 bdrv_set_change_cb(s->bs, cdrom_change_cb, s);
2705             }
2706         }
2707         s->drive_serial = drive_serial++;
2708         s->irq = irq;
2709         s->sector_write_timer = qemu_new_timer(vm_clock,
2710                                                ide_sector_write_timer_cb, s);
2711         ide_reset(s);
2712     }
2713 }
2714
2715 static void ide_init_ioport(IDEState *ide_state, int iobase, int iobase2)
2716 {
2717     register_ioport_write(iobase, 8, 1, ide_ioport_write, ide_state);
2718     register_ioport_read(iobase, 8, 1, ide_ioport_read, ide_state);
2719     if (iobase2) {
2720         register_ioport_read(iobase2, 1, 1, ide_status_read, ide_state);
2721         register_ioport_write(iobase2, 1, 1, ide_cmd_write, ide_state);
2722     }
2723
2724     /* data ports */
2725     register_ioport_write(iobase, 2, 2, ide_data_writew, ide_state);
2726     register_ioport_read(iobase, 2, 2, ide_data_readw, ide_state);
2727     register_ioport_write(iobase, 4, 4, ide_data_writel, ide_state);
2728     register_ioport_read(iobase, 4, 4, ide_data_readl, ide_state);
2729 }
2730
2731 /* save per IDE drive data */
2732 static void ide_save(QEMUFile* f, IDEState *s)
2733 {
2734     qemu_put_be32(f, s->mult_sectors);
2735     qemu_put_be32(f, s->identify_set);
2736     if (s->identify_set) {
2737         qemu_put_buffer(f, (const uint8_t *)s->identify_data, 512);
2738     }
2739     qemu_put_8s(f, &s->feature);
2740     qemu_put_8s(f, &s->error);
2741     qemu_put_be32s(f, &s->nsector);
2742     qemu_put_8s(f, &s->sector);
2743     qemu_put_8s(f, &s->lcyl);
2744     qemu_put_8s(f, &s->hcyl);
2745     qemu_put_8s(f, &s->hob_feature);
2746     qemu_put_8s(f, &s->hob_nsector);
2747     qemu_put_8s(f, &s->hob_sector);
2748     qemu_put_8s(f, &s->hob_lcyl);
2749     qemu_put_8s(f, &s->hob_hcyl);
2750     qemu_put_8s(f, &s->select);
2751     qemu_put_8s(f, &s->status);
2752     qemu_put_8s(f, &s->lba48);
2753
2754     qemu_put_8s(f, &s->sense_key);
2755     qemu_put_8s(f, &s->asc);
2756     /* XXX: if a transfer is pending, we do not save it yet */
2757 }
2758
2759 /* load per IDE drive data */
2760 static void ide_load(QEMUFile* f, IDEState *s)
2761 {
2762     s->mult_sectors=qemu_get_be32(f);
2763     s->identify_set=qemu_get_be32(f);
2764     if (s->identify_set) {
2765         qemu_get_buffer(f, (uint8_t *)s->identify_data, 512);
2766     }
2767     qemu_get_8s(f, &s->feature);
2768     qemu_get_8s(f, &s->error);
2769     qemu_get_be32s(f, &s->nsector);
2770     qemu_get_8s(f, &s->sector);
2771     qemu_get_8s(f, &s->lcyl);
2772     qemu_get_8s(f, &s->hcyl);
2773     qemu_get_8s(f, &s->hob_feature);
2774     qemu_get_8s(f, &s->hob_nsector);
2775     qemu_get_8s(f, &s->hob_sector);
2776     qemu_get_8s(f, &s->hob_lcyl);
2777     qemu_get_8s(f, &s->hob_hcyl);
2778     qemu_get_8s(f, &s->select);
2779     qemu_get_8s(f, &s->status);
2780     qemu_get_8s(f, &s->lba48);
2781
2782     qemu_get_8s(f, &s->sense_key);
2783     qemu_get_8s(f, &s->asc);
2784     /* XXX: if a transfer is pending, we do not save it yet */
2785 }
2786
2787 /***********************************************************/
2788 /* ISA IDE definitions */
2789
2790 void isa_ide_init(int iobase, int iobase2, qemu_irq irq,
2791                   BlockDriverState *hd0, BlockDriverState *hd1)
2792 {
2793     IDEState *ide_state;
2794
2795     ide_state = qemu_mallocz(sizeof(IDEState) * 2);
2796     if (!ide_state)
2797         return;
2798
2799     ide_init2(ide_state, hd0, hd1, irq);
2800     ide_init_ioport(ide_state, iobase, iobase2);
2801 }
2802
2803 /***********************************************************/
2804 /* PCI IDE definitions */
2805
2806 static void cmd646_update_irq(PCIIDEState *d);
2807
2808 static void ide_map(PCIDevice *pci_dev, int region_num,
2809                     uint32_t addr, uint32_t size, int type)
2810 {
2811     PCIIDEState *d = (PCIIDEState *)pci_dev;
2812     IDEState *ide_state;
2813
2814     if (region_num <= 3) {
2815         ide_state = &d->ide_if[(region_num >> 1) * 2];
2816         if (region_num & 1) {
2817             register_ioport_read(addr + 2, 1, 1, ide_status_read, ide_state);
2818             register_ioport_write(addr + 2, 1, 1, ide_cmd_write, ide_state);
2819         } else {
2820             register_ioport_write(addr, 8, 1, ide_ioport_write, ide_state);
2821             register_ioport_read(addr, 8, 1, ide_ioport_read, ide_state);
2822
2823             /* data ports */
2824             register_ioport_write(addr, 2, 2, ide_data_writew, ide_state);
2825             register_ioport_read(addr, 2, 2, ide_data_readw, ide_state);
2826             register_ioport_write(addr, 4, 4, ide_data_writel, ide_state);
2827             register_ioport_read(addr, 4, 4, ide_data_readl, ide_state);
2828         }
2829     }
2830 }
2831
2832 static void ide_dma_start(IDEState *s, BlockDriverCompletionFunc *dma_cb)
2833 {
2834     BMDMAState *bm = s->bmdma;
2835     if(!bm)
2836         return;
2837     bm->ide_if = s;
2838     bm->dma_cb = dma_cb;
2839     bm->cur_prd_last = 0;
2840     bm->cur_prd_addr = 0;
2841     bm->cur_prd_len = 0;
2842     if (bm->status & BM_STATUS_DMAING) {
2843         bm->dma_cb(bm, 0);
2844     }
2845 }
2846
2847 static void bmdma_cmd_writeb(void *opaque, uint32_t addr, uint32_t val)
2848 {
2849     BMDMAState *bm = opaque;
2850 #ifdef DEBUG_IDE
2851     printf("%s: 0x%08x\n", __func__, val);
2852 #endif
2853     if (!(val & BM_CMD_START)) {
2854         /* XXX: do it better */
2855         if (bm->status & BM_STATUS_DMAING) {
2856             bm->status &= ~BM_STATUS_DMAING;
2857             /* cancel DMA request */
2858             bm->ide_if = NULL;
2859             bm->dma_cb = NULL;
2860             if (bm->aiocb) {
2861 #ifdef DEBUG_AIO
2862                 printf("aio_cancel\n");
2863 #endif
2864                 bdrv_aio_cancel(bm->aiocb);
2865                 bm->aiocb = NULL;
2866             }
2867         }
2868         bm->cmd = val & 0x09;
2869     } else {
2870         if (!(bm->status & BM_STATUS_DMAING)) {
2871             bm->status |= BM_STATUS_DMAING;
2872             /* start dma transfer if possible */
2873             if (bm->dma_cb)
2874                 bm->dma_cb(bm, 0);
2875         }
2876         bm->cmd = val & 0x09;
2877     }
2878 }
2879
2880 static uint32_t bmdma_readb(void *opaque, uint32_t addr)
2881 {
2882     BMDMAState *bm = opaque;
2883     PCIIDEState *pci_dev;
2884     uint32_t val;
2885
2886     switch(addr & 3) {
2887     case 0:
2888         val = bm->cmd;
2889         break;
2890     case 1:
2891         pci_dev = bm->pci_dev;
2892         if (pci_dev->type == IDE_TYPE_CMD646) {
2893             val = pci_dev->dev.config[MRDMODE];
2894         } else {
2895             val = 0xff;
2896         }
2897         break;
2898     case 2:
2899         val = bm->status;
2900         break;
2901     case 3:
2902         pci_dev = bm->pci_dev;
2903         if (pci_dev->type == IDE_TYPE_CMD646) {
2904             if (bm == &pci_dev->bmdma[0])
2905                 val = pci_dev->dev.config[UDIDETCR0];
2906             else
2907                 val = pci_dev->dev.config[UDIDETCR1];
2908         } else {
2909             val = 0xff;
2910         }
2911         break;
2912     default:
2913         val = 0xff;
2914         break;
2915     }
2916 #ifdef DEBUG_IDE
2917     printf("bmdma: readb 0x%02x : 0x%02x\n", addr, val);
2918 #endif
2919     return val;
2920 }
2921
2922 static void bmdma_writeb(void *opaque, uint32_t addr, uint32_t val)
2923 {
2924     BMDMAState *bm = opaque;
2925     PCIIDEState *pci_dev;
2926 #ifdef DEBUG_IDE
2927     printf("bmdma: writeb 0x%02x : 0x%02x\n", addr, val);
2928 #endif
2929     switch(addr & 3) {
2930     case 1:
2931         pci_dev = bm->pci_dev;
2932         if (pci_dev->type == IDE_TYPE_CMD646) {
2933             pci_dev->dev.config[MRDMODE] =
2934                 (pci_dev->dev.config[MRDMODE] & ~0x30) | (val & 0x30);
2935             cmd646_update_irq(pci_dev);
2936         }
2937         break;
2938     case 2:
2939         bm->status = (val & 0x60) | (bm->status & 1) | (bm->status & ~val & 0x06);
2940         break;
2941     case 3:
2942         pci_dev = bm->pci_dev;
2943         if (pci_dev->type == IDE_TYPE_CMD646) {
2944             if (bm == &pci_dev->bmdma[0])
2945                 pci_dev->dev.config[UDIDETCR0] = val;
2946             else
2947                 pci_dev->dev.config[UDIDETCR1] = val;
2948         }
2949         break;
2950     }
2951 }
2952
2953 static uint32_t bmdma_addr_readb(void *opaque, uint32_t addr)
2954 {
2955     BMDMAState *bm = opaque;
2956     uint32_t val;
2957     val = (bm->addr >> ((addr & 3) * 8)) & 0xff;
2958 #ifdef DEBUG_IDE
2959     printf("%s: 0x%08x\n", __func__, val);
2960 #endif
2961     return val;
2962 }
2963
2964 static void bmdma_addr_writeb(void *opaque, uint32_t addr, uint32_t val)
2965 {
2966     BMDMAState *bm = opaque;
2967     int shift = (addr & 3) * 8;
2968 #ifdef DEBUG_IDE
2969     printf("%s: 0x%08x\n", __func__, val);
2970 #endif
2971     bm->addr &= ~(0xFF << shift);
2972     bm->addr |= ((val & 0xFF) << shift) & ~3;
2973     bm->cur_addr = bm->addr;
2974 }
2975
2976 static uint32_t bmdma_addr_readw(void *opaque, uint32_t addr)
2977 {
2978     BMDMAState *bm = opaque;
2979     uint32_t val;
2980     val = (bm->addr >> ((addr & 3) * 8)) & 0xffff;
2981 #ifdef DEBUG_IDE
2982     printf("%s: 0x%08x\n", __func__, val);
2983 #endif
2984     return val;
2985 }
2986
2987 static void bmdma_addr_writew(void *opaque, uint32_t addr, uint32_t val)
2988 {
2989     BMDMAState *bm = opaque;
2990     int shift = (addr & 3) * 8;
2991 #ifdef DEBUG_IDE
2992     printf("%s: 0x%08x\n", __func__, val);
2993 #endif
2994     bm->addr &= ~(0xFFFF << shift);
2995     bm->addr |= ((val & 0xFFFF) << shift) & ~3;
2996     bm->cur_addr = bm->addr;
2997 }
2998
2999 static uint32_t bmdma_addr_readl(void *opaque, uint32_t addr)
3000 {
3001     BMDMAState *bm = opaque;
3002     uint32_t val;
3003     val = bm->addr;
3004 #ifdef DEBUG_IDE
3005     printf("%s: 0x%08x\n", __func__, val);
3006 #endif
3007     return val;
3008 }
3009
3010 static void bmdma_addr_writel(void *opaque, uint32_t addr, uint32_t val)
3011 {
3012     BMDMAState *bm = opaque;
3013 #ifdef DEBUG_IDE
3014     printf("%s: 0x%08x\n", __func__, val);
3015 #endif
3016     bm->addr = val & ~3;
3017     bm->cur_addr = bm->addr;
3018 }
3019
3020 static void bmdma_map(PCIDevice *pci_dev, int region_num,
3021                     uint32_t addr, uint32_t size, int type)
3022 {
3023     PCIIDEState *d = (PCIIDEState *)pci_dev;
3024     int i;
3025
3026     for(i = 0;i < 2; i++) {
3027         BMDMAState *bm = &d->bmdma[i];
3028         d->ide_if[2 * i].bmdma = bm;
3029         d->ide_if[2 * i + 1].bmdma = bm;
3030         bm->pci_dev = (PCIIDEState *)pci_dev;
3031
3032         register_ioport_write(addr, 1, 1, bmdma_cmd_writeb, bm);
3033
3034         register_ioport_write(addr + 1, 3, 1, bmdma_writeb, bm);
3035         register_ioport_read(addr, 4, 1, bmdma_readb, bm);
3036
3037         register_ioport_write(addr + 4, 4, 1, bmdma_addr_writeb, bm);
3038         register_ioport_read(addr + 4, 4, 1, bmdma_addr_readb, bm);
3039         register_ioport_write(addr + 4, 4, 2, bmdma_addr_writew, bm);
3040         register_ioport_read(addr + 4, 4, 2, bmdma_addr_readw, bm);
3041         register_ioport_write(addr + 4, 4, 4, bmdma_addr_writel, bm);
3042         register_ioport_read(addr + 4, 4, 4, bmdma_addr_readl, bm);
3043         addr += 8;
3044     }
3045 }
3046
3047 /* XXX: call it also when the MRDMODE is changed from the PCI config
3048    registers */
3049 static void cmd646_update_irq(PCIIDEState *d)
3050 {
3051     int pci_level;
3052     pci_level = ((d->dev.config[MRDMODE] & MRDMODE_INTR_CH0) &&
3053                  !(d->dev.config[MRDMODE] & MRDMODE_BLK_CH0)) ||
3054         ((d->dev.config[MRDMODE] & MRDMODE_INTR_CH1) &&
3055          !(d->dev.config[MRDMODE] & MRDMODE_BLK_CH1));
3056     qemu_set_irq(d->dev.irq[0], pci_level);
3057 }
3058
3059 /* the PCI irq level is the logical OR of the two channels */
3060 static void cmd646_set_irq(void *opaque, int channel, int level)
3061 {
3062     PCIIDEState *d = opaque;
3063     int irq_mask;
3064
3065     irq_mask = MRDMODE_INTR_CH0 << channel;
3066     if (level)
3067         d->dev.config[MRDMODE] |= irq_mask;
3068     else
3069         d->dev.config[MRDMODE] &= ~irq_mask;
3070     cmd646_update_irq(d);
3071 }
3072
3073 /* CMD646 PCI IDE controller */
3074 void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table,
3075                          int secondary_ide_enabled)
3076 {
3077     PCIIDEState *d;
3078     uint8_t *pci_conf;
3079     int i;
3080     qemu_irq *irq;
3081
3082     d = (PCIIDEState *)pci_register_device(bus, "CMD646 IDE",
3083                                            sizeof(PCIIDEState),
3084                                            -1,
3085                                            NULL, NULL);
3086     d->type = IDE_TYPE_CMD646;
3087     pci_conf = d->dev.config;
3088     pci_conf[0x00] = 0x95; // CMD646
3089     pci_conf[0x01] = 0x10;
3090     pci_conf[0x02] = 0x46;
3091     pci_conf[0x03] = 0x06;
3092
3093     pci_conf[0x08] = 0x07; // IDE controller revision
3094     pci_conf[0x09] = 0x8f;
3095
3096     pci_conf[0x0a] = 0x01; // class_sub = PCI_IDE
3097     pci_conf[0x0b] = 0x01; // class_base = PCI_mass_storage
3098     pci_conf[0x0e] = 0x00; // header_type
3099
3100     if (secondary_ide_enabled) {
3101         /* XXX: if not enabled, really disable the seconday IDE controller */
3102         pci_conf[0x51] = 0x80; /* enable IDE1 */
3103     }
3104
3105     pci_register_io_region((PCIDevice *)d, 0, 0x8,
3106                            PCI_ADDRESS_SPACE_IO, ide_map);
3107     pci_register_io_region((PCIDevice *)d, 1, 0x4,
3108                            PCI_ADDRESS_SPACE_IO, ide_map);
3109     pci_register_io_region((PCIDevice *)d, 2, 0x8,
3110                            PCI_ADDRESS_SPACE_IO, ide_map);
3111     pci_register_io_region((PCIDevice *)d, 3, 0x4,
3112                            PCI_ADDRESS_SPACE_IO, ide_map);
3113     pci_register_io_region((PCIDevice *)d, 4, 0x10,
3114                            PCI_ADDRESS_SPACE_IO, bmdma_map);
3115
3116     pci_conf[0x3d] = 0x01; // interrupt on pin 1
3117
3118     for(i = 0; i < 4; i++)
3119         d->ide_if[i].pci_dev = (PCIDevice *)d;
3120
3121     irq = qemu_allocate_irqs(cmd646_set_irq, d, 2);
3122     ide_init2(&d->ide_if[0], hd_table[0], hd_table[1], irq[0]);
3123     ide_init2(&d->ide_if[2], hd_table[2], hd_table[3], irq[1]);
3124 }
3125
3126 static void pci_ide_save(QEMUFile* f, void *opaque)
3127 {
3128     PCIIDEState *d = opaque;
3129     int i;
3130
3131     pci_device_save(&d->dev, f);
3132
3133     for(i = 0; i < 2; i++) {
3134         BMDMAState *bm = &d->bmdma[i];
3135         qemu_put_8s(f, &bm->cmd);
3136         qemu_put_8s(f, &bm->status);
3137         qemu_put_be32s(f, &bm->addr);
3138         /* XXX: if a transfer is pending, we do not save it yet */
3139     }
3140
3141     /* per IDE interface data */
3142     for(i = 0; i < 2; i++) {
3143         IDEState *s = &d->ide_if[i * 2];
3144         uint8_t drive1_selected;
3145         qemu_put_8s(f, &s->cmd);
3146         drive1_selected = (s->cur_drive != s);
3147         qemu_put_8s(f, &drive1_selected);
3148     }
3149
3150     /* per IDE drive data */
3151     for(i = 0; i < 4; i++) {
3152         ide_save(f, &d->ide_if[i]);
3153     }
3154 }
3155
3156 static int pci_ide_load(QEMUFile* f, void *opaque, int version_id)
3157 {
3158     PCIIDEState *d = opaque;
3159     int ret, i;
3160
3161     if (version_id != 1)
3162         return -EINVAL;
3163     ret = pci_device_load(&d->dev, f);
3164     if (ret < 0)
3165         return ret;
3166
3167     for(i = 0; i < 2; i++) {
3168         BMDMAState *bm = &d->bmdma[i];
3169         qemu_get_8s(f, &bm->cmd);
3170         qemu_get_8s(f, &bm->status);
3171         qemu_get_be32s(f, &bm->addr);
3172         /* XXX: if a transfer is pending, we do not save it yet */
3173     }
3174
3175     /* per IDE interface data */
3176     for(i = 0; i < 2; i++) {
3177         IDEState *s = &d->ide_if[i * 2];
3178         uint8_t drive1_selected;
3179         qemu_get_8s(f, &s->cmd);
3180         qemu_get_8s(f, &drive1_selected);
3181         s->cur_drive = &d->ide_if[i * 2 + (drive1_selected != 0)];
3182     }
3183
3184     /* per IDE drive data */
3185     for(i = 0; i < 4; i++) {
3186         ide_load(f, &d->ide_if[i]);
3187     }
3188     return 0;
3189 }
3190
3191 static void piix3_reset(PCIIDEState *d)
3192 {
3193     uint8_t *pci_conf = d->dev.config;
3194
3195     pci_conf[0x04] = 0x00;
3196     pci_conf[0x05] = 0x00;
3197     pci_conf[0x06] = 0x80; /* FBC */
3198     pci_conf[0x07] = 0x02; // PCI_status_devsel_medium
3199     pci_conf[0x20] = 0x01; /* BMIBA: 20-23h */
3200 }
3201
3202 /* hd_table must contain 4 block drivers */
3203 /* NOTE: for the PIIX3, the IRQs and IOports are hardcoded */
3204 void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn,
3205                         qemu_irq *pic)
3206 {
3207     PCIIDEState *d;
3208     uint8_t *pci_conf;
3209
3210     /* register a function 1 of PIIX3 */
3211     d = (PCIIDEState *)pci_register_device(bus, "PIIX3 IDE",
3212                                            sizeof(PCIIDEState),
3213                                            devfn,
3214                                            NULL, NULL);
3215     d->type = IDE_TYPE_PIIX3;
3216
3217     pci_conf = d->dev.config;
3218     pci_conf[0x00] = 0x86; // Intel
3219     pci_conf[0x01] = 0x80;
3220     pci_conf[0x02] = 0x10;
3221     pci_conf[0x03] = 0x70;
3222     pci_conf[0x09] = 0x80; // legacy ATA mode
3223     pci_conf[0x0a] = 0x01; // class_sub = PCI_IDE
3224     pci_conf[0x0b] = 0x01; // class_base = PCI_mass_storage
3225     pci_conf[0x0e] = 0x00; // header_type
3226
3227     piix3_reset(d);
3228
3229     pci_register_io_region((PCIDevice *)d, 4, 0x10,
3230                            PCI_ADDRESS_SPACE_IO, bmdma_map);
3231
3232     ide_init2(&d->ide_if[0], hd_table[0], hd_table[1], pic[14]);
3233     ide_init2(&d->ide_if[2], hd_table[2], hd_table[3], pic[15]);
3234     ide_init_ioport(&d->ide_if[0], 0x1f0, 0x3f6);
3235     ide_init_ioport(&d->ide_if[2], 0x170, 0x376);
3236
3237     register_savevm("ide", 0, 1, pci_ide_save, pci_ide_load, d);
3238 }
3239
3240 /* hd_table must contain 4 block drivers */
3241 /* NOTE: for the PIIX4, the IRQs and IOports are hardcoded */
3242 void pci_piix4_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn,
3243                         qemu_irq *pic)
3244 {
3245     PCIIDEState *d;
3246     uint8_t *pci_conf;
3247
3248     /* register a function 1 of PIIX4 */
3249     d = (PCIIDEState *)pci_register_device(bus, "PIIX4 IDE",
3250                                            sizeof(PCIIDEState),
3251                                            devfn,
3252                                            NULL, NULL);
3253     d->type = IDE_TYPE_PIIX4;
3254
3255     pci_conf = d->dev.config;
3256     pci_conf[0x00] = 0x86; // Intel
3257     pci_conf[0x01] = 0x80;
3258     pci_conf[0x02] = 0x11;
3259     pci_conf[0x03] = 0x71;
3260     pci_conf[0x09] = 0x80; // legacy ATA mode
3261     pci_conf[0x0a] = 0x01; // class_sub = PCI_IDE
3262     pci_conf[0x0b] = 0x01; // class_base = PCI_mass_storage
3263     pci_conf[0x0e] = 0x00; // header_type
3264
3265     piix3_reset(d);
3266
3267     pci_register_io_region((PCIDevice *)d, 4, 0x10,
3268                            PCI_ADDRESS_SPACE_IO, bmdma_map);
3269
3270     ide_init2(&d->ide_if[0], hd_table[0], hd_table[1], pic[14]);
3271     ide_init2(&d->ide_if[2], hd_table[2], hd_table[3], pic[15]);
3272     ide_init_ioport(&d->ide_if[0], 0x1f0, 0x3f6);
3273     ide_init_ioport(&d->ide_if[2], 0x170, 0x376);
3274
3275     register_savevm("ide", 0, 1, pci_ide_save, pci_ide_load, d);
3276 }
3277
3278 /***********************************************************/
3279 /* MacIO based PowerPC IDE */
3280
3281 /* PowerMac IDE memory IO */
3282 static void pmac_ide_writeb (void *opaque,
3283                              target_phys_addr_t addr, uint32_t val)
3284 {
3285     addr = (addr & 0xFFF) >> 4;
3286     switch (addr) {
3287     case 1 ... 7:
3288         ide_ioport_write(opaque, addr, val);
3289         break;
3290     case 8:
3291     case 22:
3292         ide_cmd_write(opaque, 0, val);
3293         break;
3294     default:
3295         break;
3296     }
3297 }
3298
3299 static uint32_t pmac_ide_readb (void *opaque,target_phys_addr_t addr)
3300 {
3301     uint8_t retval;
3302
3303     addr = (addr & 0xFFF) >> 4;
3304     switch (addr) {
3305     case 1 ... 7:
3306         retval = ide_ioport_read(opaque, addr);
3307         break;
3308     case 8:
3309     case 22:
3310         retval = ide_status_read(opaque, 0);
3311         break;
3312     default:
3313         retval = 0xFF;
3314         break;
3315     }
3316     return retval;
3317 }
3318
3319 static void pmac_ide_writew (void *opaque,
3320                              target_phys_addr_t addr, uint32_t val)
3321 {
3322     addr = (addr & 0xFFF) >> 4;
3323 #ifdef TARGET_WORDS_BIGENDIAN
3324     val = bswap16(val);
3325 #endif
3326     if (addr == 0) {
3327         ide_data_writew(opaque, 0, val);
3328     }
3329 }
3330
3331 static uint32_t pmac_ide_readw (void *opaque,target_phys_addr_t addr)
3332 {
3333     uint16_t retval;
3334
3335     addr = (addr & 0xFFF) >> 4;
3336     if (addr == 0) {
3337         retval = ide_data_readw(opaque, 0);
3338     } else {
3339         retval = 0xFFFF;
3340     }
3341 #ifdef TARGET_WORDS_BIGENDIAN
3342     retval = bswap16(retval);
3343 #endif
3344     return retval;
3345 }
3346
3347 static void pmac_ide_writel (void *opaque,
3348                              target_phys_addr_t addr, uint32_t val)
3349 {
3350     addr = (addr & 0xFFF) >> 4;
3351 #ifdef TARGET_WORDS_BIGENDIAN
3352     val = bswap32(val);
3353 #endif
3354     if (addr == 0) {
3355         ide_data_writel(opaque, 0, val);
3356     }
3357 }
3358
3359 static uint32_t pmac_ide_readl (void *opaque,target_phys_addr_t addr)
3360 {
3361     uint32_t retval;
3362
3363     addr = (addr & 0xFFF) >> 4;
3364     if (addr == 0) {
3365         retval = ide_data_readl(opaque, 0);
3366     } else {
3367         retval = 0xFFFFFFFF;
3368     }
3369 #ifdef TARGET_WORDS_BIGENDIAN
3370     retval = bswap32(retval);
3371 #endif
3372     return retval;
3373 }
3374
3375 static CPUWriteMemoryFunc *pmac_ide_write[] = {
3376     pmac_ide_writeb,
3377     pmac_ide_writew,
3378     pmac_ide_writel,
3379 };
3380
3381 static CPUReadMemoryFunc *pmac_ide_read[] = {
3382     pmac_ide_readb,
3383     pmac_ide_readw,
3384     pmac_ide_readl,
3385 };
3386
3387 /* hd_table must contain 4 block drivers */
3388 /* PowerMac uses memory mapped registers, not I/O. Return the memory
3389    I/O index to access the ide. */
3390 int pmac_ide_init (BlockDriverState **hd_table, qemu_irq irq)
3391 {
3392     IDEState *ide_if;
3393     int pmac_ide_memory;
3394
3395     ide_if = qemu_mallocz(sizeof(IDEState) * 2);
3396     ide_init2(&ide_if[0], hd_table[0], hd_table[1], irq);
3397
3398     pmac_ide_memory = cpu_register_io_memory(0, pmac_ide_read,
3399                                              pmac_ide_write, &ide_if[0]);
3400     return pmac_ide_memory;
3401 }
3402
3403 /***********************************************************/
3404 /* CF-ATA Microdrive */
3405
3406 #define METADATA_SIZE   0x20
3407
3408 /* DSCM-1XXXX Microdrive hard disk with CF+ II / PCMCIA interface.  */
3409 struct md_s {
3410     IDEState ide[2];
3411     struct pcmcia_card_s card;
3412     uint32_t attr_base;
3413     uint32_t io_base;
3414
3415     /* Card state */
3416     uint8_t opt;
3417     uint8_t stat;
3418     uint8_t pins;
3419
3420     uint8_t ctrl;
3421     uint16_t io;
3422     int cycle;
3423 };
3424
3425 /* Register bitfields */
3426 enum md_opt {
3427     OPT_MODE_MMAP       = 0,
3428     OPT_MODE_IOMAP16    = 1,
3429     OPT_MODE_IOMAP1     = 2,
3430     OPT_MODE_IOMAP2     = 3,
3431     OPT_MODE            = 0x3f,
3432     OPT_LEVIREQ         = 0x40,
3433     OPT_SRESET          = 0x80,
3434 };
3435 enum md_cstat {
3436     STAT_INT            = 0x02,
3437     STAT_PWRDWN         = 0x04,
3438     STAT_XE             = 0x10,
3439     STAT_IOIS8          = 0x20,
3440     STAT_SIGCHG         = 0x40,
3441     STAT_CHANGED        = 0x80,
3442 };
3443 enum md_pins {
3444     PINS_MRDY           = 0x02,
3445     PINS_CRDY           = 0x20,
3446 };
3447 enum md_ctrl {
3448     CTRL_IEN            = 0x02,
3449     CTRL_SRST           = 0x04,
3450 };
3451
3452 static inline void md_interrupt_update(struct md_s *s)
3453 {
3454     if (!s->card.slot)
3455         return;
3456
3457     qemu_set_irq(s->card.slot->irq,
3458                     !(s->stat & STAT_INT) &&    /* Inverted */
3459                     !(s->ctrl & (CTRL_IEN | CTRL_SRST)) &&
3460                     !(s->opt & OPT_SRESET));
3461 }
3462
3463 static void md_set_irq(void *opaque, int irq, int level)
3464 {
3465     struct md_s *s = (struct md_s *) opaque;
3466     if (level)
3467         s->stat |= STAT_INT;
3468     else
3469         s->stat &= ~STAT_INT;
3470
3471     md_interrupt_update(s);
3472 }
3473
3474 static void md_reset(struct md_s *s)
3475 {
3476     s->opt = OPT_MODE_MMAP;
3477     s->stat = 0;
3478     s->pins = 0;
3479     s->cycle = 0;
3480     s->ctrl = 0;
3481     ide_reset(s->ide);
3482 }
3483
3484 static uint8_t md_attr_read(void *opaque, uint32_t at)
3485 {
3486     struct md_s *s = (struct md_s *) opaque;
3487     if (at < s->attr_base) {
3488         if (at < s->card.cis_len)
3489             return s->card.cis[at];
3490         else
3491             return 0x00;
3492     }
3493
3494     at -= s->attr_base;
3495
3496     switch (at) {
3497     case 0x00:  /* Configuration Option Register */
3498         return s->opt;
3499     case 0x02:  /* Card Configuration Status Register */
3500         if (s->ctrl & CTRL_IEN)
3501             return s->stat & ~STAT_INT;
3502         else
3503             return s->stat;
3504     case 0x04:  /* Pin Replacement Register */
3505         return (s->pins & PINS_CRDY) | 0x0c;
3506     case 0x06:  /* Socket and Copy Register */
3507         return 0x00;
3508 #ifdef VERBOSE
3509     default:
3510         printf("%s: Bad attribute space register %02x\n", __FUNCTION__, at);
3511 #endif
3512     }
3513
3514     return 0;
3515 }
3516
3517 static void md_attr_write(void *opaque, uint32_t at, uint8_t value)
3518 {
3519     struct md_s *s = (struct md_s *) opaque;
3520     at -= s->attr_base;
3521
3522     switch (at) {
3523     case 0x00:  /* Configuration Option Register */
3524         s->opt = value & 0xcf;
3525         if (value & OPT_SRESET)
3526             md_reset(s);
3527         md_interrupt_update(s);
3528         break;
3529     case 0x02:  /* Card Configuration Status Register */
3530         if ((s->stat ^ value) & STAT_PWRDWN)
3531             s->pins |= PINS_CRDY;
3532         s->stat &= 0x82;
3533         s->stat |= value & 0x74;
3534         md_interrupt_update(s);
3535         /* Word 170 in Identify Device must be equal to STAT_XE */
3536         break;
3537     case 0x04:  /* Pin Replacement Register */
3538         s->pins &= PINS_CRDY;
3539         s->pins |= value & PINS_MRDY;
3540         break;
3541     case 0x06:  /* Socket and Copy Register */
3542         break;
3543     default:
3544         printf("%s: Bad attribute space register %02x\n", __FUNCTION__, at);
3545     }
3546 }
3547
3548 static uint16_t md_common_read(void *opaque, uint32_t at)
3549 {
3550     struct md_s *s = (struct md_s *) opaque;
3551     uint16_t ret;
3552     at -= s->io_base;
3553
3554     switch (s->opt & OPT_MODE) {
3555     case OPT_MODE_MMAP:
3556         if ((at & ~0x3ff) == 0x400)
3557             at = 0;
3558         break;
3559     case OPT_MODE_IOMAP16:
3560         at &= 0xf;
3561         break;
3562     case OPT_MODE_IOMAP1:
3563         if ((at & ~0xf) == 0x3f0)
3564             at -= 0x3e8;
3565         else if ((at & ~0xf) == 0x1f0)
3566             at -= 0x1f0;
3567         break;
3568     case OPT_MODE_IOMAP2:
3569         if ((at & ~0xf) == 0x370)
3570             at -= 0x368;
3571         else if ((at & ~0xf) == 0x170)
3572             at -= 0x170;
3573     }
3574
3575     switch (at) {
3576     case 0x0:   /* Even RD Data */
3577     case 0x8:
3578         return ide_data_readw(s->ide, 0);
3579
3580         /* TODO: 8-bit accesses */
3581         if (s->cycle)
3582             ret = s->io >> 8;
3583         else {
3584             s->io = ide_data_readw(s->ide, 0);
3585             ret = s->io & 0xff;
3586         }
3587         s->cycle = !s->cycle;
3588         return ret;
3589     case 0x9:   /* Odd RD Data */
3590         return s->io >> 8;
3591     case 0xd:   /* Error */
3592         return ide_ioport_read(s->ide, 0x1);
3593     case 0xe:   /* Alternate Status */
3594         if (s->ide->cur_drive->bs)
3595             return s->ide->cur_drive->status;
3596         else
3597             return 0;
3598     case 0xf:   /* Device Address */
3599         return 0xc2 | ((~s->ide->select << 2) & 0x3c);
3600     default:
3601         return ide_ioport_read(s->ide, at);
3602     }
3603
3604     return 0;
3605 }
3606
3607 static void md_common_write(void *opaque, uint32_t at, uint16_t value)
3608 {
3609     struct md_s *s = (struct md_s *) opaque;
3610     at -= s->io_base;
3611
3612     switch (s->opt & OPT_MODE) {
3613     case OPT_MODE_MMAP:
3614         if ((at & ~0x3ff) == 0x400)
3615             at = 0;
3616         break;
3617     case OPT_MODE_IOMAP16:
3618         at &= 0xf;
3619         break;
3620     case OPT_MODE_IOMAP1:
3621         if ((at & ~0xf) == 0x3f0)
3622             at -= 0x3e8;
3623         else if ((at & ~0xf) == 0x1f0)
3624             at -= 0x1f0;
3625         break;
3626     case OPT_MODE_IOMAP2:
3627         if ((at & ~0xf) == 0x370)
3628             at -= 0x368;
3629         else if ((at & ~0xf) == 0x170)
3630             at -= 0x170;
3631     }
3632
3633     switch (at) {
3634     case 0x0:   /* Even WR Data */
3635     case 0x8:
3636         ide_data_writew(s->ide, 0, value);
3637         break;
3638
3639         /* TODO: 8-bit accesses */
3640         if (s->cycle)
3641             ide_data_writew(s->ide, 0, s->io | (value << 8));
3642         else
3643             s->io = value & 0xff;
3644         s->cycle = !s->cycle;
3645         break;
3646     case 0x9:
3647         s->io = value & 0xff;
3648         s->cycle = !s->cycle;
3649         break;
3650     case 0xd:   /* Features */
3651         ide_ioport_write(s->ide, 0x1, value);
3652         break;
3653     case 0xe:   /* Device Control */
3654         s->ctrl = value;
3655         if (value & CTRL_SRST)
3656             md_reset(s);
3657         md_interrupt_update(s);
3658         break;
3659     default:
3660         if (s->stat & STAT_PWRDWN) {
3661             s->pins |= PINS_CRDY;
3662             s->stat &= ~STAT_PWRDWN;
3663         }
3664         ide_ioport_write(s->ide, at, value);
3665     }
3666 }
3667
3668 static void md_save(QEMUFile *f, void *opaque)
3669 {
3670     struct md_s *s = (struct md_s *) opaque;
3671     int i;
3672     uint8_t drive1_selected;
3673
3674     qemu_put_8s(f, &s->opt);
3675     qemu_put_8s(f, &s->stat);
3676     qemu_put_8s(f, &s->pins);
3677
3678     qemu_put_8s(f, &s->ctrl);
3679     qemu_put_be16s(f, &s->io);
3680     qemu_put_byte(f, s->cycle);
3681
3682     drive1_selected = (s->ide->cur_drive != s->ide);
3683     qemu_put_8s(f, &s->ide->cmd);
3684     qemu_put_8s(f, &drive1_selected);
3685
3686     for (i = 0; i < 2; i ++)
3687         ide_save(f, &s->ide[i]);
3688 }
3689
3690 static int md_load(QEMUFile *f, void *opaque, int version_id)
3691 {
3692     struct md_s *s = (struct md_s *) opaque;
3693     int i;
3694     uint8_t drive1_selected;
3695
3696     qemu_get_8s(f, &s->opt);
3697     qemu_get_8s(f, &s->stat);
3698     qemu_get_8s(f, &s->pins);
3699
3700     qemu_get_8s(f, &s->ctrl);
3701     qemu_get_be16s(f, &s->io);
3702     s->cycle = qemu_get_byte(f);
3703
3704     qemu_get_8s(f, &s->ide->cmd);
3705     qemu_get_8s(f, &drive1_selected);
3706     s->ide->cur_drive = &s->ide[(drive1_selected != 0)];
3707
3708     for (i = 0; i < 2; i ++)
3709         ide_load(f, &s->ide[i]);
3710
3711     return 0;
3712 }
3713
3714 static const uint8_t dscm1xxxx_cis[0x14a] = {
3715     [0x000] = CISTPL_DEVICE,    /* 5V Device Information */
3716     [0x002] = 0x03,             /* Tuple length = 4 bytes */
3717     [0x004] = 0xdb,             /* ID: DTYPE_FUNCSPEC, non WP, DSPEED_150NS */
3718     [0x006] = 0x01,             /* Size = 2K bytes */
3719     [0x008] = CISTPL_ENDMARK,
3720
3721     [0x00a] = CISTPL_DEVICE_OC, /* Additional Device Information */
3722     [0x00c] = 0x04,             /* Tuple length = 4 byest */
3723     [0x00e] = 0x03,             /* Conditions: Ext = 0, Vcc 3.3V, MWAIT = 1 */
3724     [0x010] = 0xdb,             /* ID: DTYPE_FUNCSPEC, non WP, DSPEED_150NS */
3725     [0x012] = 0x01,             /* Size = 2K bytes */
3726     [0x014] = CISTPL_ENDMARK,
3727
3728     [0x016] = CISTPL_JEDEC_C,   /* JEDEC ID */
3729     [0x018] = 0x02,             /* Tuple length = 2 bytes */
3730     [0x01a] = 0xdf,             /* PC Card ATA with no Vpp required */
3731     [0x01c] = 0x01,
3732
3733     [0x01e] = CISTPL_MANFID,    /* Manufacture ID */
3734     [0x020] = 0x04,             /* Tuple length = 4 bytes */
3735     [0x022] = 0xa4,             /* TPLMID_MANF = 00a4 (IBM) */
3736     [0x024] = 0x00,
3737     [0x026] = 0x00,             /* PLMID_CARD = 0000 */
3738     [0x028] = 0x00,
3739
3740     [0x02a] = CISTPL_VERS_1,    /* Level 1 Version */
3741     [0x02c] = 0x12,             /* Tuple length = 23 bytes */
3742     [0x02e] = 0x04,             /* Major Version = JEIDA 4.2 / PCMCIA 2.1 */
3743     [0x030] = 0x01,             /* Minor Version = 1 */
3744     [0x032] = 'I',
3745     [0x034] = 'B',
3746     [0x036] = 'M',
3747     [0x038] = 0x00,
3748     [0x03a] = 'm',
3749     [0x03c] = 'i',
3750     [0x03e] = 'c',
3751     [0x040] = 'r',
3752     [0x042] = 'o',
3753     [0x044] = 'd',
3754     [0x046] = 'r',
3755     [0x048] = 'i',
3756     [0x04a] = 'v',
3757     [0x04c] = 'e',
3758     [0x04e] = 0x00,
3759     [0x050] = CISTPL_ENDMARK,
3760
3761     [0x052] = CISTPL_FUNCID,    /* Function ID */
3762     [0x054] = 0x02,             /* Tuple length = 2 bytes */
3763     [0x056] = 0x04,             /* TPLFID_FUNCTION = Fixed Disk */
3764     [0x058] = 0x01,             /* TPLFID_SYSINIT: POST = 1, ROM = 0 */
3765
3766     [0x05a] = CISTPL_FUNCE,     /* Function Extension */
3767     [0x05c] = 0x02,             /* Tuple length = 2 bytes */
3768     [0x05e] = 0x01,             /* TPLFE_TYPE = Disk Device Interface */
3769     [0x060] = 0x01,             /* TPLFE_DATA = PC Card ATA Interface */
3770
3771     [0x062] = CISTPL_FUNCE,     /* Function Extension */
3772     [0x064] = 0x03,             /* Tuple length = 3 bytes */
3773     [0x066] = 0x02,             /* TPLFE_TYPE = Basic PC Card ATA Interface */
3774     [0x068] = 0x08,             /* TPLFE_DATA: Rotating, Unique, Single */
3775     [0x06a] = 0x0f,             /* TPLFE_DATA: Sleep, Standby, Idle, Auto */
3776
3777     [0x06c] = CISTPL_CONFIG,    /* Configuration */
3778     [0x06e] = 0x05,             /* Tuple length = 5 bytes */
3779     [0x070] = 0x01,             /* TPCC_RASZ = 2 bytes, TPCC_RMSZ = 1 byte */
3780     [0x072] = 0x07,             /* TPCC_LAST = 7 */
3781     [0x074] = 0x00,             /* TPCC_RADR = 0200 */
3782     [0x076] = 0x02,
3783     [0x078] = 0x0f,             /* TPCC_RMSK = 200, 202, 204, 206 */
3784
3785     [0x07a] = CISTPL_CFTABLE_ENTRY,     /* 16-bit PC Card Configuration */
3786     [0x07c] = 0x0b,             /* Tuple length = 11 bytes */
3787     [0x07e] = 0xc0,             /* TPCE_INDX = Memory Mode, Default, Iface */
3788     [0x080] = 0xc0,             /* TPCE_IF = Memory, no BVDs, no WP, READY */
3789     [0x082] = 0xa1,             /* TPCE_FS = Vcc only, no I/O, Memory, Misc */
3790     [0x084] = 0x27,             /* NomV = 1, MinV = 1, MaxV = 1, Peakl = 1 */
3791     [0x086] = 0x55,             /* NomV: 5.0 V */
3792     [0x088] = 0x4d,             /* MinV: 4.5 V */
3793     [0x08a] = 0x5d,             /* MaxV: 5.5 V */
3794     [0x08c] = 0x4e,             /* Peakl: 450 mA */
3795     [0x08e] = 0x08,             /* TPCE_MS = 1 window, 1 byte, Host address */
3796     [0x090] = 0x00,             /* Window descriptor: Window length = 0 */
3797     [0x092] = 0x20,             /* TPCE_MI: support power down mode, RW */
3798
3799     [0x094] = CISTPL_CFTABLE_ENTRY,     /* 16-bit PC Card Configuration */
3800     [0x096] = 0x06,             /* Tuple length = 6 bytes */
3801     [0x098] = 0x00,             /* TPCE_INDX = Memory Mode, no Default */
3802     [0x09a] = 0x01,             /* TPCE_FS = Vcc only, no I/O, no Memory */
3803     [0x09c] = 0x21,             /* NomV = 1, MinV = 0, MaxV = 0, Peakl = 1 */
3804     [0x09e] = 0xb5,             /* NomV: 3.3 V */
3805     [0x0a0] = 0x1e,
3806     [0x0a2] = 0x3e,             /* Peakl: 350 mA */
3807
3808     [0x0a4] = CISTPL_CFTABLE_ENTRY,     /* 16-bit PC Card Configuration */
3809     [0x0a6] = 0x0d,             /* Tuple length = 13 bytes */
3810     [0x0a8] = 0xc1,             /* TPCE_INDX = I/O and Memory Mode, Default */
3811     [0x0aa] = 0x41,             /* TPCE_IF = I/O and Memory, no BVD, no WP */
3812     [0x0ac] = 0x99,             /* TPCE_FS = Vcc only, I/O, Interrupt, Misc */
3813     [0x0ae] = 0x27,             /* NomV = 1, MinV = 1, MaxV = 1, Peakl = 1 */
3814     [0x0b0] = 0x55,             /* NomV: 5.0 V */
3815     [0x0b2] = 0x4d,             /* MinV: 4.5 V */
3816     [0x0b4] = 0x5d,             /* MaxV: 5.5 V */
3817     [0x0b6] = 0x4e,             /* Peakl: 450 mA */
3818     [0x0b8] = 0x64,             /* TPCE_IO = 16-byte boundary, 16/8 accesses */
3819     [0x0ba] = 0xf0,             /* TPCE_IR =  MASK, Level, Pulse, Share */
3820     [0x0bc] = 0xff,             /* IRQ0..IRQ7 supported */
3821     [0x0be] = 0xff,             /* IRQ8..IRQ15 supported */
3822     [0x0c0] = 0x20,             /* TPCE_MI = support power down mode */
3823
3824     [0x0c2] = CISTPL_CFTABLE_ENTRY,     /* 16-bit PC Card Configuration */
3825     [0x0c4] = 0x06,             /* Tuple length = 6 bytes */
3826     [0x0c6] = 0x01,             /* TPCE_INDX = I/O and Memory Mode */
3827     [0x0c8] = 0x01,             /* TPCE_FS = Vcc only, no I/O, no Memory */
3828     [0x0ca] = 0x21,             /* NomV = 1, MinV = 0, MaxV = 0, Peakl = 1 */
3829     [0x0cc] = 0xb5,             /* NomV: 3.3 V */
3830     [0x0ce] = 0x1e,
3831     [0x0d0] = 0x3e,             /* Peakl: 350 mA */
3832
3833     [0x0d2] = CISTPL_CFTABLE_ENTRY,     /* 16-bit PC Card Configuration */
3834     [0x0d4] = 0x12,             /* Tuple length = 18 bytes */
3835     [0x0d6] = 0xc2,             /* TPCE_INDX = I/O Primary Mode */
3836     [0x0d8] = 0x41,             /* TPCE_IF = I/O and Memory, no BVD, no WP */
3837     [0x0da] = 0x99,             /* TPCE_FS = Vcc only, I/O, Interrupt, Misc */
3838     [0x0dc] = 0x27,             /* NomV = 1, MinV = 1, MaxV = 1, Peakl = 1 */
3839     [0x0de] = 0x55,             /* NomV: 5.0 V */
3840     [0x0e0] = 0x4d,             /* MinV: 4.5 V */
3841     [0x0e2] = 0x5d,             /* MaxV: 5.5 V */
3842     [0x0e4] = 0x4e,             /* Peakl: 450 mA */
3843     [0x0e6] = 0xea,             /* TPCE_IO = 1K boundary, 16/8 access, Range */
3844     [0x0e8] = 0x61,             /* Range: 2 fields, 2 bytes addr, 1 byte len */
3845     [0x0ea] = 0xf0,             /* Field 1 address = 0x01f0 */
3846     [0x0ec] = 0x01,
3847     [0x0ee] = 0x07,             /* Address block length = 8 */
3848     [0x0f0] = 0xf6,             /* Field 2 address = 0x03f6 */
3849     [0x0f2] = 0x03,
3850     [0x0f4] = 0x01,             /* Address block length = 2 */
3851     [0x0f6] = 0xee,             /* TPCE_IR = IRQ E, Level, Pulse, Share */
3852     [0x0f8] = 0x20,             /* TPCE_MI = support power down mode */
3853
3854     [0x0fa] = CISTPL_CFTABLE_ENTRY,     /* 16-bit PC Card Configuration */
3855     [0x0fc] = 0x06,             /* Tuple length = 6 bytes */
3856     [0x0fe] = 0x02,             /* TPCE_INDX = I/O Primary Mode, no Default */
3857     [0x100] = 0x01,             /* TPCE_FS = Vcc only, no I/O, no Memory */
3858     [0x102] = 0x21,             /* NomV = 1, MinV = 0, MaxV = 0, Peakl = 1 */
3859     [0x104] = 0xb5,             /* NomV: 3.3 V */
3860     [0x106] = 0x1e,
3861     [0x108] = 0x3e,             /* Peakl: 350 mA */
3862
3863     [0x10a] = CISTPL_CFTABLE_ENTRY,     /* 16-bit PC Card Configuration */
3864     [0x10c] = 0x12,             /* Tuple length = 18 bytes */
3865     [0x10e] = 0xc3,             /* TPCE_INDX = I/O Secondary Mode, Default */
3866     [0x110] = 0x41,             /* TPCE_IF = I/O and Memory, no BVD, no WP */
3867     [0x112] = 0x99,             /* TPCE_FS = Vcc only, I/O, Interrupt, Misc */
3868     [0x114] = 0x27,             /* NomV = 1, MinV = 1, MaxV = 1, Peakl = 1 */
3869     [0x116] = 0x55,             /* NomV: 5.0 V */
3870     [0x118] = 0x4d,             /* MinV: 4.5 V */
3871     [0x11a] = 0x5d,             /* MaxV: 5.5 V */
3872     [0x11c] = 0x4e,             /* Peakl: 450 mA */
3873     [0x11e] = 0xea,             /* TPCE_IO = 1K boundary, 16/8 access, Range */
3874     [0x120] = 0x61,             /* Range: 2 fields, 2 byte addr, 1 byte len */
3875     [0x122] = 0x70,             /* Field 1 address = 0x0170 */
3876     [0x124] = 0x01,
3877     [0x126] = 0x07,             /* Address block length = 8 */
3878     [0x128] = 0x76,             /* Field 2 address = 0x0376 */
3879     [0x12a] = 0x03,
3880     [0x12c] = 0x01,             /* Address block length = 2 */
3881     [0x12e] = 0xee,             /* TPCE_IR = IRQ E, Level, Pulse, Share */
3882     [0x130] = 0x20,             /* TPCE_MI = support power down mode */
3883
3884     [0x132] = CISTPL_CFTABLE_ENTRY,     /* 16-bit PC Card Configuration */
3885     [0x134] = 0x06,             /* Tuple length = 6 bytes */
3886     [0x136] = 0x03,             /* TPCE_INDX = I/O Secondary Mode */
3887     [0x138] = 0x01,             /* TPCE_FS = Vcc only, no I/O, no Memory */
3888     [0x13a] = 0x21,             /* NomV = 1, MinV = 0, MaxV = 0, Peakl = 1 */
3889     [0x13c] = 0xb5,             /* NomV: 3.3 V */
3890     [0x13e] = 0x1e,
3891     [0x140] = 0x3e,             /* Peakl: 350 mA */
3892
3893     [0x142] = CISTPL_NO_LINK,   /* No Link */
3894     [0x144] = 0x00,             /* Tuple length = 0 bytes */
3895
3896     [0x146] = CISTPL_END,       /* Tuple End */
3897 };
3898
3899 static int dscm1xxxx_attach(void *opaque)
3900 {
3901     struct md_s *md = (struct md_s *) opaque;
3902     md->card.attr_read = md_attr_read;
3903     md->card.attr_write = md_attr_write;
3904     md->card.common_read = md_common_read;
3905     md->card.common_write = md_common_write;
3906     md->card.io_read = md_common_read;
3907     md->card.io_write = md_common_write;
3908
3909     md->attr_base = md->card.cis[0x74] | (md->card.cis[0x76] << 8);
3910     md->io_base = 0x0;
3911
3912     md_reset(md);
3913     md_interrupt_update(md);
3914
3915     md->card.slot->card_string = "DSCM-1xxxx Hitachi Microdrive";
3916     return 0;
3917 }
3918
3919 static int dscm1xxxx_detach(void *opaque)
3920 {
3921     struct md_s *md = (struct md_s *) opaque;
3922     md_reset(md);
3923     return 0;
3924 }
3925
3926 struct pcmcia_card_s *dscm1xxxx_init(BlockDriverState *bdrv)
3927 {
3928     struct md_s *md = (struct md_s *) qemu_mallocz(sizeof(struct md_s));
3929     md->card.state = md;
3930     md->card.attach = dscm1xxxx_attach;
3931     md->card.detach = dscm1xxxx_detach;
3932     md->card.cis = dscm1xxxx_cis;
3933     md->card.cis_len = sizeof(dscm1xxxx_cis);
3934
3935     ide_init2(md->ide, bdrv, 0, qemu_allocate_irqs(md_set_irq, md, 1)[0]);
3936     md->ide->is_cf = 1;
3937     md->ide->mdata_size = METADATA_SIZE;
3938     md->ide->mdata_storage = (uint8_t *) qemu_mallocz(METADATA_SIZE);
3939
3940     register_savevm("microdrive", -1, 0, md_save, md_load, md);
3941
3942     return &md->card;
3943 }