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