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