2 * QEMU IDE disk and CD/DVD-ROM Emulator
4 * Copyright (c) 2003 Fabrice Bellard
5 * Copyright (c) 2006 Openedhand Ltd.
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:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
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
28 #include "qemu-error.h"
29 #include "qemu-timer.h"
34 #include <hw/ide/internal.h>
36 /* These values were based on a Seagate ST3500418AS but have been modified
37 to make more sense in QEMU */
38 static const int smart_attributes
[][12] = {
39 /* id, flags, hflags, val, wrst, raw (6 bytes), threshold */
40 /* raw read error rate*/
41 { 0x01, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06},
43 { 0x03, 0x03, 0x00, 0x64, 0x64, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
44 /* start stop count */
45 { 0x04, 0x02, 0x00, 0x64, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14},
46 /* remapped sectors */
47 { 0x05, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24},
49 { 0x09, 0x03, 0x00, 0x64, 0x64, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
50 /* power cycle count */
51 { 0x0c, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
52 /* airflow-temperature-celsius */
53 { 190, 0x03, 0x00, 0x45, 0x45, 0x1f, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x32},
55 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
58 static int ide_handle_rw_error(IDEState
*s
, int error
, int op
);
59 static void ide_dummy_transfer_stop(IDEState
*s
);
61 static void padstr(char *str
, const char *src
, int len
)
64 for(i
= 0; i
< len
; i
++) {
73 static void put_le16(uint16_t *p
, unsigned int v
)
78 static void ide_identify(IDEState
*s
)
82 IDEDevice
*dev
= s
->unit
? s
->bus
->slave
: s
->bus
->master
;
84 if (s
->identify_set
) {
85 memcpy(s
->io_buffer
, s
->identify_data
, sizeof(s
->identify_data
));
89 memset(s
->io_buffer
, 0, 512);
90 p
= (uint16_t *)s
->io_buffer
;
91 put_le16(p
+ 0, 0x0040);
92 put_le16(p
+ 1, s
->cylinders
);
93 put_le16(p
+ 3, s
->heads
);
94 put_le16(p
+ 4, 512 * s
->sectors
); /* XXX: retired, remove ? */
95 put_le16(p
+ 5, 512); /* XXX: retired, remove ? */
96 put_le16(p
+ 6, s
->sectors
);
97 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
98 put_le16(p
+ 20, 3); /* XXX: retired, remove ? */
99 put_le16(p
+ 21, 512); /* cache size in sectors */
100 put_le16(p
+ 22, 4); /* ecc bytes */
101 padstr((char *)(p
+ 23), s
->version
, 8); /* firmware version */
102 padstr((char *)(p
+ 27), "QEMU HARDDISK", 40); /* model */
103 #if MAX_MULT_SECTORS > 1
104 put_le16(p
+ 47, 0x8000 | MAX_MULT_SECTORS
);
106 put_le16(p
+ 48, 1); /* dword I/O */
107 put_le16(p
+ 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
108 put_le16(p
+ 51, 0x200); /* PIO transfer cycle */
109 put_le16(p
+ 52, 0x200); /* DMA transfer cycle */
110 put_le16(p
+ 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
111 put_le16(p
+ 54, s
->cylinders
);
112 put_le16(p
+ 55, s
->heads
);
113 put_le16(p
+ 56, s
->sectors
);
114 oldsize
= s
->cylinders
* s
->heads
* s
->sectors
;
115 put_le16(p
+ 57, oldsize
);
116 put_le16(p
+ 58, oldsize
>> 16);
118 put_le16(p
+ 59, 0x100 | s
->mult_sectors
);
119 put_le16(p
+ 60, s
->nb_sectors
);
120 put_le16(p
+ 61, s
->nb_sectors
>> 16);
121 put_le16(p
+ 62, 0x07); /* single word dma0-2 supported */
122 put_le16(p
+ 63, 0x07); /* mdma0-2 supported */
123 put_le16(p
+ 64, 0x03); /* pio3-4 supported */
124 put_le16(p
+ 65, 120);
125 put_le16(p
+ 66, 120);
126 put_le16(p
+ 67, 120);
127 put_le16(p
+ 68, 120);
128 if (dev
&& dev
->conf
.discard_granularity
) {
129 put_le16(p
+ 69, (1 << 14)); /* determinate TRIM behavior */
133 put_le16(p
+ 75, s
->ncq_queues
- 1);
135 put_le16(p
+ 76, (1 << 8));
138 put_le16(p
+ 80, 0xf0); /* ata3 -> ata6 supported */
139 put_le16(p
+ 81, 0x16); /* conforms to ata5 */
140 /* 14=NOP supported, 5=WCACHE supported, 0=SMART supported */
141 put_le16(p
+ 82, (1 << 14) | (1 << 5) | 1);
142 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
143 put_le16(p
+ 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
144 /* 14=set to 1, 1=SMART self test, 0=SMART error logging */
145 put_le16(p
+ 84, (1 << 14) | 0);
146 /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
147 if (bdrv_enable_write_cache(s
->bs
))
148 put_le16(p
+ 85, (1 << 14) | (1 << 5) | 1);
150 put_le16(p
+ 85, (1 << 14) | 1);
151 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
152 put_le16(p
+ 86, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
153 /* 14=set to 1, 1=smart self test, 0=smart error logging */
154 put_le16(p
+ 87, (1 << 14) | 0);
155 put_le16(p
+ 88, 0x3f | (1 << 13)); /* udma5 set and supported */
156 put_le16(p
+ 93, 1 | (1 << 14) | 0x2000);
157 put_le16(p
+ 100, s
->nb_sectors
);
158 put_le16(p
+ 101, s
->nb_sectors
>> 16);
159 put_le16(p
+ 102, s
->nb_sectors
>> 32);
160 put_le16(p
+ 103, s
->nb_sectors
>> 48);
162 if (dev
&& dev
->conf
.physical_block_size
)
163 put_le16(p
+ 106, 0x6000 | get_physical_block_exp(&dev
->conf
));
164 if (dev
&& dev
->conf
.discard_granularity
) {
165 put_le16(p
+ 169, 1); /* TRIM support */
168 memcpy(s
->identify_data
, p
, sizeof(s
->identify_data
));
172 static void ide_atapi_identify(IDEState
*s
)
176 if (s
->identify_set
) {
177 memcpy(s
->io_buffer
, s
->identify_data
, sizeof(s
->identify_data
));
181 memset(s
->io_buffer
, 0, 512);
182 p
= (uint16_t *)s
->io_buffer
;
183 /* Removable CDROM, 50us response, 12 byte packets */
184 put_le16(p
+ 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
185 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
186 put_le16(p
+ 20, 3); /* buffer type */
187 put_le16(p
+ 21, 512); /* cache size in sectors */
188 put_le16(p
+ 22, 4); /* ecc bytes */
189 padstr((char *)(p
+ 23), s
->version
, 8); /* firmware version */
190 padstr((char *)(p
+ 27), "QEMU DVD-ROM", 40); /* model */
191 put_le16(p
+ 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
193 put_le16(p
+ 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
194 put_le16(p
+ 53, 7); /* words 64-70, 54-58, 88 valid */
195 put_le16(p
+ 62, 7); /* single word dma0-2 supported */
196 put_le16(p
+ 63, 7); /* mdma0-2 supported */
198 put_le16(p
+ 49, 1 << 9); /* LBA supported, no DMA */
199 put_le16(p
+ 53, 3); /* words 64-70, 54-58 valid */
200 put_le16(p
+ 63, 0x103); /* DMA modes XXX: may be incorrect */
202 put_le16(p
+ 64, 3); /* pio3-4 supported */
203 put_le16(p
+ 65, 0xb4); /* minimum DMA multiword tx cycle time */
204 put_le16(p
+ 66, 0xb4); /* recommended DMA multiword tx cycle time */
205 put_le16(p
+ 67, 0x12c); /* minimum PIO cycle time without flow control */
206 put_le16(p
+ 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
208 put_le16(p
+ 71, 30); /* in ns */
209 put_le16(p
+ 72, 30); /* in ns */
212 put_le16(p
+ 75, s
->ncq_queues
- 1);
214 put_le16(p
+ 76, (1 << 8));
217 put_le16(p
+ 80, 0x1e); /* support up to ATA/ATAPI-4 */
219 put_le16(p
+ 88, 0x3f | (1 << 13)); /* udma5 set and supported */
221 memcpy(s
->identify_data
, p
, sizeof(s
->identify_data
));
225 static void ide_cfata_identify(IDEState
*s
)
230 p
= (uint16_t *) s
->identify_data
;
234 memset(p
, 0, sizeof(s
->identify_data
));
236 cur_sec
= s
->cylinders
* s
->heads
* s
->sectors
;
238 put_le16(p
+ 0, 0x848a); /* CF Storage Card signature */
239 put_le16(p
+ 1, s
->cylinders
); /* Default cylinders */
240 put_le16(p
+ 3, s
->heads
); /* Default heads */
241 put_le16(p
+ 6, s
->sectors
); /* Default sectors per track */
242 put_le16(p
+ 7, s
->nb_sectors
>> 16); /* Sectors per card */
243 put_le16(p
+ 8, s
->nb_sectors
); /* Sectors per card */
244 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
245 put_le16(p
+ 22, 0x0004); /* ECC bytes */
246 padstr((char *) (p
+ 23), s
->version
, 8); /* Firmware Revision */
247 padstr((char *) (p
+ 27), "QEMU MICRODRIVE", 40);/* Model number */
248 #if MAX_MULT_SECTORS > 1
249 put_le16(p
+ 47, 0x8000 | MAX_MULT_SECTORS
);
251 put_le16(p
+ 47, 0x0000);
253 put_le16(p
+ 49, 0x0f00); /* Capabilities */
254 put_le16(p
+ 51, 0x0002); /* PIO cycle timing mode */
255 put_le16(p
+ 52, 0x0001); /* DMA cycle timing mode */
256 put_le16(p
+ 53, 0x0003); /* Translation params valid */
257 put_le16(p
+ 54, s
->cylinders
); /* Current cylinders */
258 put_le16(p
+ 55, s
->heads
); /* Current heads */
259 put_le16(p
+ 56, s
->sectors
); /* Current sectors */
260 put_le16(p
+ 57, cur_sec
); /* Current capacity */
261 put_le16(p
+ 58, cur_sec
>> 16); /* Current capacity */
262 if (s
->mult_sectors
) /* Multiple sector setting */
263 put_le16(p
+ 59, 0x100 | s
->mult_sectors
);
264 put_le16(p
+ 60, s
->nb_sectors
); /* Total LBA sectors */
265 put_le16(p
+ 61, s
->nb_sectors
>> 16); /* Total LBA sectors */
266 put_le16(p
+ 63, 0x0203); /* Multiword DMA capability */
267 put_le16(p
+ 64, 0x0001); /* Flow Control PIO support */
268 put_le16(p
+ 65, 0x0096); /* Min. Multiword DMA cycle */
269 put_le16(p
+ 66, 0x0096); /* Rec. Multiword DMA cycle */
270 put_le16(p
+ 68, 0x00b4); /* Min. PIO cycle time */
271 put_le16(p
+ 82, 0x400c); /* Command Set supported */
272 put_le16(p
+ 83, 0x7068); /* Command Set supported */
273 put_le16(p
+ 84, 0x4000); /* Features supported */
274 put_le16(p
+ 85, 0x000c); /* Command Set enabled */
275 put_le16(p
+ 86, 0x7044); /* Command Set enabled */
276 put_le16(p
+ 87, 0x4000); /* Features enabled */
277 put_le16(p
+ 91, 0x4060); /* Current APM level */
278 put_le16(p
+ 129, 0x0002); /* Current features option */
279 put_le16(p
+ 130, 0x0005); /* Reassigned sectors */
280 put_le16(p
+ 131, 0x0001); /* Initial power mode */
281 put_le16(p
+ 132, 0x0000); /* User signature */
282 put_le16(p
+ 160, 0x8100); /* Power requirement */
283 put_le16(p
+ 161, 0x8001); /* CF command set */
288 memcpy(s
->io_buffer
, p
, sizeof(s
->identify_data
));
291 static void ide_set_signature(IDEState
*s
)
293 s
->select
&= 0xf0; /* clear head */
297 if (s
->drive_kind
== IDE_CD
) {
309 typedef struct TrimAIOCB
{
310 BlockDriverAIOCB common
;
315 static void trim_aio_cancel(BlockDriverAIOCB
*acb
)
317 TrimAIOCB
*iocb
= container_of(acb
, TrimAIOCB
, common
);
319 qemu_bh_delete(iocb
->bh
);
321 qemu_aio_release(iocb
);
324 static AIOPool trim_aio_pool
= {
325 .aiocb_size
= sizeof(TrimAIOCB
),
326 .cancel
= trim_aio_cancel
,
329 static void ide_trim_bh_cb(void *opaque
)
331 TrimAIOCB
*iocb
= opaque
;
333 iocb
->common
.cb(iocb
->common
.opaque
, iocb
->ret
);
335 qemu_bh_delete(iocb
->bh
);
338 qemu_aio_release(iocb
);
341 BlockDriverAIOCB
*ide_issue_trim(BlockDriverState
*bs
,
342 int64_t sector_num
, QEMUIOVector
*qiov
, int nb_sectors
,
343 BlockDriverCompletionFunc
*cb
, void *opaque
)
348 iocb
= qemu_aio_get(&trim_aio_pool
, bs
, cb
, opaque
);
349 iocb
->bh
= qemu_bh_new(ide_trim_bh_cb
, iocb
);
352 for (j
= 0; j
< qiov
->niov
; j
++) {
353 uint64_t *buffer
= qiov
->iov
[j
].iov_base
;
355 for (i
= 0; i
< qiov
->iov
[j
].iov_len
/ 8; i
++) {
356 /* 6-byte LBA + 2-byte range per entry */
357 uint64_t entry
= le64_to_cpu(buffer
[i
]);
358 uint64_t sector
= entry
& 0x0000ffffffffffffULL
;
359 uint16_t count
= entry
>> 48;
365 ret
= bdrv_discard(bs
, sector
, count
);
372 qemu_bh_schedule(iocb
->bh
);
374 return &iocb
->common
;
377 static inline void ide_abort_command(IDEState
*s
)
379 s
->status
= READY_STAT
| ERR_STAT
;
383 /* prepare data transfer and tell what to do after */
384 void ide_transfer_start(IDEState
*s
, uint8_t *buf
, int size
,
385 EndTransferFunc
*end_transfer_func
)
387 s
->end_transfer_func
= end_transfer_func
;
389 s
->data_end
= buf
+ size
;
390 if (!(s
->status
& ERR_STAT
)) {
391 s
->status
|= DRQ_STAT
;
393 s
->bus
->dma
->ops
->start_transfer(s
->bus
->dma
);
396 void ide_transfer_stop(IDEState
*s
)
398 s
->end_transfer_func
= ide_transfer_stop
;
399 s
->data_ptr
= s
->io_buffer
;
400 s
->data_end
= s
->io_buffer
;
401 s
->status
&= ~DRQ_STAT
;
404 int64_t ide_get_sector(IDEState
*s
)
407 if (s
->select
& 0x40) {
410 sector_num
= ((s
->select
& 0x0f) << 24) | (s
->hcyl
<< 16) |
411 (s
->lcyl
<< 8) | s
->sector
;
413 sector_num
= ((int64_t)s
->hob_hcyl
<< 40) |
414 ((int64_t) s
->hob_lcyl
<< 32) |
415 ((int64_t) s
->hob_sector
<< 24) |
416 ((int64_t) s
->hcyl
<< 16) |
417 ((int64_t) s
->lcyl
<< 8) | s
->sector
;
420 sector_num
= ((s
->hcyl
<< 8) | s
->lcyl
) * s
->heads
* s
->sectors
+
421 (s
->select
& 0x0f) * s
->sectors
+ (s
->sector
- 1);
426 void ide_set_sector(IDEState
*s
, int64_t sector_num
)
429 if (s
->select
& 0x40) {
431 s
->select
= (s
->select
& 0xf0) | (sector_num
>> 24);
432 s
->hcyl
= (sector_num
>> 16);
433 s
->lcyl
= (sector_num
>> 8);
434 s
->sector
= (sector_num
);
436 s
->sector
= sector_num
;
437 s
->lcyl
= sector_num
>> 8;
438 s
->hcyl
= sector_num
>> 16;
439 s
->hob_sector
= sector_num
>> 24;
440 s
->hob_lcyl
= sector_num
>> 32;
441 s
->hob_hcyl
= sector_num
>> 40;
444 cyl
= sector_num
/ (s
->heads
* s
->sectors
);
445 r
= sector_num
% (s
->heads
* s
->sectors
);
448 s
->select
= (s
->select
& 0xf0) | ((r
/ s
->sectors
) & 0x0f);
449 s
->sector
= (r
% s
->sectors
) + 1;
453 static void ide_rw_error(IDEState
*s
) {
454 ide_abort_command(s
);
458 void ide_sector_read(IDEState
*s
)
463 s
->status
= READY_STAT
| SEEK_STAT
;
464 s
->error
= 0; /* not needed by IDE spec, but needed by Windows */
465 sector_num
= ide_get_sector(s
);
468 /* no more sector to read from disk */
469 ide_transfer_stop(s
);
471 #if defined(DEBUG_IDE)
472 printf("read sector=%" PRId64
"\n", sector_num
);
474 if (n
> s
->req_nb_sectors
)
475 n
= s
->req_nb_sectors
;
477 bdrv_acct_start(s
->bs
, &s
->acct
, n
* BDRV_SECTOR_SIZE
, BDRV_ACCT_READ
);
478 ret
= bdrv_read(s
->bs
, sector_num
, s
->io_buffer
, n
);
479 bdrv_acct_done(s
->bs
, &s
->acct
);
481 if (ide_handle_rw_error(s
, -ret
,
482 BM_STATUS_PIO_RETRY
| BM_STATUS_RETRY_READ
))
487 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_read
);
489 ide_set_sector(s
, sector_num
+ n
);
494 static void dma_buf_commit(IDEState
*s
, int is_write
)
496 qemu_sglist_destroy(&s
->sg
);
499 void ide_set_inactive(IDEState
*s
)
501 s
->bus
->dma
->aiocb
= NULL
;
502 s
->bus
->dma
->ops
->set_inactive(s
->bus
->dma
);
505 void ide_dma_error(IDEState
*s
)
507 ide_transfer_stop(s
);
509 s
->status
= READY_STAT
| ERR_STAT
;
514 static int ide_handle_rw_error(IDEState
*s
, int error
, int op
)
516 int is_read
= (op
& BM_STATUS_RETRY_READ
);
517 BlockErrorAction action
= bdrv_get_on_error(s
->bs
, is_read
);
519 if (action
== BLOCK_ERR_IGNORE
) {
520 bdrv_mon_event(s
->bs
, BDRV_ACTION_IGNORE
, is_read
);
524 if ((error
== ENOSPC
&& action
== BLOCK_ERR_STOP_ENOSPC
)
525 || action
== BLOCK_ERR_STOP_ANY
) {
526 s
->bus
->dma
->ops
->set_unit(s
->bus
->dma
, s
->unit
);
527 s
->bus
->error_status
= op
;
528 bdrv_mon_event(s
->bs
, BDRV_ACTION_STOP
, is_read
);
529 vm_stop(VMSTOP_DISKFULL
);
531 if (op
& BM_STATUS_DMA_RETRY
) {
532 dma_buf_commit(s
, 0);
537 bdrv_mon_event(s
->bs
, BDRV_ACTION_REPORT
, is_read
);
543 void ide_dma_cb(void *opaque
, int ret
)
545 IDEState
*s
= opaque
;
551 int op
= BM_STATUS_DMA_RETRY
;
553 if (s
->dma_cmd
== IDE_DMA_READ
)
554 op
|= BM_STATUS_RETRY_READ
;
555 else if (s
->dma_cmd
== IDE_DMA_TRIM
)
556 op
|= BM_STATUS_RETRY_TRIM
;
558 if (ide_handle_rw_error(s
, -ret
, op
)) {
563 n
= s
->io_buffer_size
>> 9;
564 sector_num
= ide_get_sector(s
);
566 dma_buf_commit(s
, ide_cmd_is_read(s
));
568 ide_set_sector(s
, sector_num
);
572 /* end of transfer ? */
573 if (s
->nsector
== 0) {
574 s
->status
= READY_STAT
| SEEK_STAT
;
579 /* launch next transfer */
581 s
->io_buffer_index
= 0;
582 s
->io_buffer_size
= n
* 512;
583 if (s
->bus
->dma
->ops
->prepare_buf(s
->bus
->dma
, ide_cmd_is_read(s
)) == 0) {
584 /* The PRDs were too short. Reset the Active bit, but don't raise an
590 printf("ide_dma_cb: sector_num=%" PRId64
" n=%d, cmd_cmd=%d\n",
591 sector_num
, n
, s
->dma_cmd
);
594 switch (s
->dma_cmd
) {
596 s
->bus
->dma
->aiocb
= dma_bdrv_read(s
->bs
, &s
->sg
, sector_num
,
600 s
->bus
->dma
->aiocb
= dma_bdrv_write(s
->bs
, &s
->sg
, sector_num
,
604 s
->bus
->dma
->aiocb
= dma_bdrv_io(s
->bs
, &s
->sg
, sector_num
,
605 ide_issue_trim
, ide_dma_cb
, s
, 1);
609 if (!s
->bus
->dma
->aiocb
) {
611 goto handle_rw_error
;
616 if (s
->dma_cmd
== IDE_DMA_READ
|| s
->dma_cmd
== IDE_DMA_WRITE
) {
617 bdrv_acct_done(s
->bs
, &s
->acct
);
622 static void ide_sector_start_dma(IDEState
*s
, enum ide_dma_cmd dma_cmd
)
624 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
625 s
->io_buffer_index
= 0;
626 s
->io_buffer_size
= 0;
627 s
->dma_cmd
= dma_cmd
;
631 bdrv_acct_start(s
->bs
, &s
->acct
, s
->nsector
* BDRV_SECTOR_SIZE
,
635 bdrv_acct_start(s
->bs
, &s
->acct
, s
->nsector
* BDRV_SECTOR_SIZE
,
642 s
->bus
->dma
->ops
->start_dma(s
->bus
->dma
, s
, ide_dma_cb
);
645 static void ide_sector_write_timer_cb(void *opaque
)
647 IDEState
*s
= opaque
;
651 void ide_sector_write(IDEState
*s
)
656 s
->status
= READY_STAT
| SEEK_STAT
;
657 sector_num
= ide_get_sector(s
);
658 #if defined(DEBUG_IDE)
659 printf("write sector=%" PRId64
"\n", sector_num
);
662 if (n
> s
->req_nb_sectors
)
663 n
= s
->req_nb_sectors
;
665 bdrv_acct_start(s
->bs
, &s
->acct
, n
* BDRV_SECTOR_SIZE
, BDRV_ACCT_READ
);
666 ret
= bdrv_write(s
->bs
, sector_num
, s
->io_buffer
, n
);
667 bdrv_acct_done(s
->bs
, &s
->acct
);
670 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_PIO_RETRY
))
675 if (s
->nsector
== 0) {
676 /* no more sectors to write */
677 ide_transfer_stop(s
);
680 if (n1
> s
->req_nb_sectors
)
681 n1
= s
->req_nb_sectors
;
682 ide_transfer_start(s
, s
->io_buffer
, 512 * n1
, ide_sector_write
);
684 ide_set_sector(s
, sector_num
+ n
);
686 if (win2k_install_hack
&& ((++s
->irq_count
% 16) == 0)) {
687 /* It seems there is a bug in the Windows 2000 installer HDD
688 IDE driver which fills the disk with empty logs when the
689 IDE write IRQ comes too early. This hack tries to correct
690 that at the expense of slower write performances. Use this
691 option _only_ to install Windows 2000. You must disable it
693 qemu_mod_timer(s
->sector_write_timer
,
694 qemu_get_clock_ns(vm_clock
) + (get_ticks_per_sec() / 1000));
700 static void ide_flush_cb(void *opaque
, int ret
)
702 IDEState
*s
= opaque
;
705 /* XXX: What sector number to set here? */
706 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_RETRY_FLUSH
)) {
711 bdrv_acct_done(s
->bs
, &s
->acct
);
712 s
->status
= READY_STAT
| SEEK_STAT
;
716 void ide_flush_cache(IDEState
*s
)
718 BlockDriverAIOCB
*acb
;
725 bdrv_acct_start(s
->bs
, &s
->acct
, 0, BDRV_ACCT_FLUSH
);
726 acb
= bdrv_aio_flush(s
->bs
, ide_flush_cb
, s
);
728 ide_flush_cb(s
, -EIO
);
732 static void ide_cfata_metadata_inquiry(IDEState
*s
)
737 p
= (uint16_t *) s
->io_buffer
;
739 spd
= ((s
->mdata_size
- 1) >> 9) + 1;
741 put_le16(p
+ 0, 0x0001); /* Data format revision */
742 put_le16(p
+ 1, 0x0000); /* Media property: silicon */
743 put_le16(p
+ 2, s
->media_changed
); /* Media status */
744 put_le16(p
+ 3, s
->mdata_size
& 0xffff); /* Capacity in bytes (low) */
745 put_le16(p
+ 4, s
->mdata_size
>> 16); /* Capacity in bytes (high) */
746 put_le16(p
+ 5, spd
& 0xffff); /* Sectors per device (low) */
747 put_le16(p
+ 6, spd
>> 16); /* Sectors per device (high) */
750 static void ide_cfata_metadata_read(IDEState
*s
)
754 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
755 s
->status
= ERR_STAT
;
760 p
= (uint16_t *) s
->io_buffer
;
763 put_le16(p
+ 0, s
->media_changed
); /* Media status */
764 memcpy(p
+ 1, s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
765 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
766 s
->nsector
<< 9), 0x200 - 2));
769 static void ide_cfata_metadata_write(IDEState
*s
)
771 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
772 s
->status
= ERR_STAT
;
777 s
->media_changed
= 0;
779 memcpy(s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
781 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
782 s
->nsector
<< 9), 0x200 - 2));
785 /* called when the inserted state of the media has changed */
786 static void ide_cd_change_cb(void *opaque
)
788 IDEState
*s
= opaque
;
791 bdrv_get_geometry(s
->bs
, &nb_sectors
);
792 s
->nb_sectors
= nb_sectors
;
795 * First indicate to the guest that a CD has been removed. That's
796 * done on the next command the guest sends us.
798 * Then we set SENSE_UNIT_ATTENTION, by which the guest will
799 * detect a new CD in the drive. See ide_atapi_cmd() for details.
801 s
->cdrom_changed
= 1;
802 s
->events
.new_media
= true;
806 static void ide_cmd_lba48_transform(IDEState
*s
, int lba48
)
810 /* handle the 'magic' 0 nsector count conversion here. to avoid
811 * fiddling with the rest of the read logic, we just store the
812 * full sector count in ->nsector and ignore ->hob_nsector from now
818 if (!s
->nsector
&& !s
->hob_nsector
)
822 int hi
= s
->hob_nsector
;
824 s
->nsector
= (hi
<< 8) | lo
;
829 static void ide_clear_hob(IDEBus
*bus
)
831 /* any write clears HOB high bit of device control register */
832 bus
->ifs
[0].select
&= ~(1 << 7);
833 bus
->ifs
[1].select
&= ~(1 << 7);
836 void ide_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
838 IDEBus
*bus
= opaque
;
841 printf("IDE: write addr=0x%x val=0x%02x\n", addr
, val
);
846 /* ignore writes to command block while busy with previous command */
847 if (addr
!= 7 && (idebus_active_if(bus
)->status
& (BUSY_STAT
|DRQ_STAT
)))
855 /* NOTE: data is written to the two drives */
856 bus
->ifs
[0].hob_feature
= bus
->ifs
[0].feature
;
857 bus
->ifs
[1].hob_feature
= bus
->ifs
[1].feature
;
858 bus
->ifs
[0].feature
= val
;
859 bus
->ifs
[1].feature
= val
;
863 bus
->ifs
[0].hob_nsector
= bus
->ifs
[0].nsector
;
864 bus
->ifs
[1].hob_nsector
= bus
->ifs
[1].nsector
;
865 bus
->ifs
[0].nsector
= val
;
866 bus
->ifs
[1].nsector
= val
;
870 bus
->ifs
[0].hob_sector
= bus
->ifs
[0].sector
;
871 bus
->ifs
[1].hob_sector
= bus
->ifs
[1].sector
;
872 bus
->ifs
[0].sector
= val
;
873 bus
->ifs
[1].sector
= val
;
877 bus
->ifs
[0].hob_lcyl
= bus
->ifs
[0].lcyl
;
878 bus
->ifs
[1].hob_lcyl
= bus
->ifs
[1].lcyl
;
879 bus
->ifs
[0].lcyl
= val
;
880 bus
->ifs
[1].lcyl
= val
;
884 bus
->ifs
[0].hob_hcyl
= bus
->ifs
[0].hcyl
;
885 bus
->ifs
[1].hob_hcyl
= bus
->ifs
[1].hcyl
;
886 bus
->ifs
[0].hcyl
= val
;
887 bus
->ifs
[1].hcyl
= val
;
890 /* FIXME: HOB readback uses bit 7 */
891 bus
->ifs
[0].select
= (val
& ~0x10) | 0xa0;
892 bus
->ifs
[1].select
= (val
| 0x10) | 0xa0;
894 bus
->unit
= (val
>> 4) & 1;
899 ide_exec_cmd(bus
, val
);
904 #define HD_OK (1u << IDE_HD)
905 #define CD_OK (1u << IDE_CD)
906 #define CFA_OK (1u << IDE_CFATA)
907 #define HD_CFA_OK (HD_OK | CFA_OK)
908 #define ALL_OK (HD_OK | CD_OK | CFA_OK)
910 /* See ACS-2 T13/2015-D Table B.2 Command codes */
911 static const uint8_t ide_cmd_table
[0x100] = {
912 /* NOP not implemented, mandatory for CD */
913 [CFA_REQ_EXT_ERROR_CODE
] = CFA_OK
,
915 [WIN_DEVICE_RESET
] = CD_OK
,
916 [WIN_RECAL
] = HD_CFA_OK
,
918 [WIN_READ_ONCE
] = ALL_OK
,
919 [WIN_READ_EXT
] = HD_CFA_OK
,
920 [WIN_READDMA_EXT
] = HD_CFA_OK
,
921 [WIN_READ_NATIVE_MAX_EXT
] = HD_CFA_OK
,
922 [WIN_MULTREAD_EXT
] = HD_CFA_OK
,
923 [WIN_WRITE
] = HD_CFA_OK
,
924 [WIN_WRITE_ONCE
] = HD_CFA_OK
,
925 [WIN_WRITE_EXT
] = HD_CFA_OK
,
926 [WIN_WRITEDMA_EXT
] = HD_CFA_OK
,
927 [CFA_WRITE_SECT_WO_ERASE
] = CFA_OK
,
928 [WIN_MULTWRITE_EXT
] = HD_CFA_OK
,
929 [WIN_WRITE_VERIFY
] = HD_CFA_OK
,
930 [WIN_VERIFY
] = HD_CFA_OK
,
931 [WIN_VERIFY_ONCE
] = HD_CFA_OK
,
932 [WIN_VERIFY_EXT
] = HD_CFA_OK
,
933 [WIN_SEEK
] = HD_CFA_OK
,
934 [CFA_TRANSLATE_SECTOR
] = CFA_OK
,
935 [WIN_DIAGNOSE
] = ALL_OK
,
936 [WIN_SPECIFY
] = HD_CFA_OK
,
937 [WIN_STANDBYNOW2
] = ALL_OK
,
938 [WIN_IDLEIMMEDIATE2
] = ALL_OK
,
939 [WIN_STANDBY2
] = ALL_OK
,
940 [WIN_SETIDLE2
] = ALL_OK
,
941 [WIN_CHECKPOWERMODE2
] = ALL_OK
,
942 [WIN_SLEEPNOW2
] = ALL_OK
,
943 [WIN_PACKETCMD
] = CD_OK
,
944 [WIN_PIDENTIFY
] = CD_OK
,
945 [WIN_SMART
] = HD_CFA_OK
,
946 [CFA_ACCESS_METADATA_STORAGE
] = CFA_OK
,
947 [CFA_ERASE_SECTORS
] = CFA_OK
,
948 [WIN_MULTREAD
] = HD_CFA_OK
,
949 [WIN_MULTWRITE
] = HD_CFA_OK
,
950 [WIN_SETMULT
] = HD_CFA_OK
,
951 [WIN_READDMA
] = HD_CFA_OK
,
952 [WIN_READDMA_ONCE
] = HD_CFA_OK
,
953 [WIN_WRITEDMA
] = HD_CFA_OK
,
954 [WIN_WRITEDMA_ONCE
] = HD_CFA_OK
,
955 [CFA_WRITE_MULTI_WO_ERASE
] = CFA_OK
,
956 [WIN_STANDBYNOW1
] = ALL_OK
,
957 [WIN_IDLEIMMEDIATE
] = ALL_OK
,
958 [WIN_STANDBY
] = ALL_OK
,
959 [WIN_SETIDLE1
] = ALL_OK
,
960 [WIN_CHECKPOWERMODE1
] = ALL_OK
,
961 [WIN_SLEEPNOW1
] = ALL_OK
,
962 [WIN_FLUSH_CACHE
] = ALL_OK
,
963 [WIN_FLUSH_CACHE_EXT
] = HD_CFA_OK
,
964 [WIN_IDENTIFY
] = ALL_OK
,
965 [WIN_SETFEATURES
] = ALL_OK
,
966 [IBM_SENSE_CONDITION
] = CFA_OK
,
967 [CFA_WEAR_LEVEL
] = CFA_OK
,
968 [WIN_READ_NATIVE_MAX
] = ALL_OK
,
971 static bool ide_cmd_permitted(IDEState
*s
, uint32_t cmd
)
973 return cmd
< ARRAY_SIZE(ide_cmd_table
)
974 && (ide_cmd_table
[cmd
] & (1u << s
->drive_kind
));
977 void ide_exec_cmd(IDEBus
*bus
, uint32_t val
)
983 #if defined(DEBUG_IDE)
984 printf("ide: CMD=%02x\n", val
);
986 s
= idebus_active_if(bus
);
987 /* ignore commands to non existant slave */
988 if (s
!= bus
->ifs
&& !s
->bs
)
991 /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
992 if ((s
->status
& (BUSY_STAT
|DRQ_STAT
)) && val
!= WIN_DEVICE_RESET
)
995 if (!ide_cmd_permitted(s
, val
)) {
1001 switch (s
->feature
) {
1006 ide_sector_start_dma(s
, IDE_DMA_TRIM
);
1013 if (s
->bs
&& s
->drive_kind
!= IDE_CD
) {
1014 if (s
->drive_kind
!= IDE_CFATA
)
1017 ide_cfata_identify(s
);
1018 s
->status
= READY_STAT
| SEEK_STAT
;
1019 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
1021 if (s
->drive_kind
== IDE_CD
) {
1022 ide_set_signature(s
);
1024 ide_abort_command(s
);
1026 ide_set_irq(s
->bus
);
1031 s
->status
= READY_STAT
| SEEK_STAT
;
1032 ide_set_irq(s
->bus
);
1035 if (s
->drive_kind
== IDE_CFATA
&& s
->nsector
== 0) {
1036 /* Disable Read and Write Multiple */
1037 s
->mult_sectors
= 0;
1038 s
->status
= READY_STAT
| SEEK_STAT
;
1039 } else if ((s
->nsector
& 0xff) != 0 &&
1040 ((s
->nsector
& 0xff) > MAX_MULT_SECTORS
||
1041 (s
->nsector
& (s
->nsector
- 1)) != 0)) {
1042 ide_abort_command(s
);
1044 s
->mult_sectors
= s
->nsector
& 0xff;
1045 s
->status
= READY_STAT
| SEEK_STAT
;
1047 ide_set_irq(s
->bus
);
1049 case WIN_VERIFY_EXT
:
1052 case WIN_VERIFY_ONCE
:
1053 /* do sector number check ? */
1054 ide_cmd_lba48_transform(s
, lba48
);
1055 s
->status
= READY_STAT
| SEEK_STAT
;
1056 ide_set_irq(s
->bus
);
1062 if (s
->drive_kind
== IDE_CD
) {
1063 ide_set_signature(s
); /* odd, but ATA4 8.27.5.2 requires it */
1066 ide_cmd_lba48_transform(s
, lba48
);
1067 s
->req_nb_sectors
= 1;
1073 case WIN_WRITE_ONCE
:
1074 case CFA_WRITE_SECT_WO_ERASE
:
1075 case WIN_WRITE_VERIFY
:
1076 ide_cmd_lba48_transform(s
, lba48
);
1078 s
->status
= SEEK_STAT
| READY_STAT
;
1079 s
->req_nb_sectors
= 1;
1080 ide_transfer_start(s
, s
->io_buffer
, 512, ide_sector_write
);
1081 s
->media_changed
= 1;
1083 case WIN_MULTREAD_EXT
:
1086 if (!s
->mult_sectors
)
1088 ide_cmd_lba48_transform(s
, lba48
);
1089 s
->req_nb_sectors
= s
->mult_sectors
;
1092 case WIN_MULTWRITE_EXT
:
1095 case CFA_WRITE_MULTI_WO_ERASE
:
1096 if (!s
->mult_sectors
)
1098 ide_cmd_lba48_transform(s
, lba48
);
1100 s
->status
= SEEK_STAT
| READY_STAT
;
1101 s
->req_nb_sectors
= s
->mult_sectors
;
1103 if (n
> s
->req_nb_sectors
)
1104 n
= s
->req_nb_sectors
;
1105 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_write
);
1106 s
->media_changed
= 1;
1108 case WIN_READDMA_EXT
:
1111 case WIN_READDMA_ONCE
:
1114 ide_cmd_lba48_transform(s
, lba48
);
1115 ide_sector_start_dma(s
, IDE_DMA_READ
);
1117 case WIN_WRITEDMA_EXT
:
1120 case WIN_WRITEDMA_ONCE
:
1123 ide_cmd_lba48_transform(s
, lba48
);
1124 ide_sector_start_dma(s
, IDE_DMA_WRITE
);
1125 s
->media_changed
= 1;
1127 case WIN_READ_NATIVE_MAX_EXT
:
1129 case WIN_READ_NATIVE_MAX
:
1130 ide_cmd_lba48_transform(s
, lba48
);
1131 ide_set_sector(s
, s
->nb_sectors
- 1);
1132 s
->status
= READY_STAT
| SEEK_STAT
;
1133 ide_set_irq(s
->bus
);
1135 case WIN_CHECKPOWERMODE1
:
1136 case WIN_CHECKPOWERMODE2
:
1138 s
->nsector
= 0xff; /* device active or idle */
1139 s
->status
= READY_STAT
| SEEK_STAT
;
1140 ide_set_irq(s
->bus
);
1142 case WIN_SETFEATURES
:
1145 /* XXX: valid for CDROM ? */
1146 switch(s
->feature
) {
1147 case 0xcc: /* reverting to power-on defaults enable */
1148 case 0x66: /* reverting to power-on defaults disable */
1149 case 0x02: /* write cache enable */
1150 case 0x82: /* write cache disable */
1151 case 0xaa: /* read look-ahead enable */
1152 case 0x55: /* read look-ahead disable */
1153 case 0x05: /* set advanced power management mode */
1154 case 0x85: /* disable advanced power management mode */
1155 case 0x69: /* NOP */
1156 case 0x67: /* NOP */
1157 case 0x96: /* NOP */
1158 case 0x9a: /* NOP */
1159 case 0x42: /* enable Automatic Acoustic Mode */
1160 case 0xc2: /* disable Automatic Acoustic Mode */
1161 s
->status
= READY_STAT
| SEEK_STAT
;
1162 ide_set_irq(s
->bus
);
1164 case 0x03: { /* set transfer mode */
1165 uint8_t val
= s
->nsector
& 0x07;
1166 uint16_t *identify_data
= (uint16_t *)s
->identify_data
;
1168 switch (s
->nsector
>> 3) {
1169 case 0x00: /* pio default */
1170 case 0x01: /* pio mode */
1171 put_le16(identify_data
+ 62,0x07);
1172 put_le16(identify_data
+ 63,0x07);
1173 put_le16(identify_data
+ 88,0x3f);
1175 case 0x02: /* sigle word dma mode*/
1176 put_le16(identify_data
+ 62,0x07 | (1 << (val
+ 8)));
1177 put_le16(identify_data
+ 63,0x07);
1178 put_le16(identify_data
+ 88,0x3f);
1180 case 0x04: /* mdma mode */
1181 put_le16(identify_data
+ 62,0x07);
1182 put_le16(identify_data
+ 63,0x07 | (1 << (val
+ 8)));
1183 put_le16(identify_data
+ 88,0x3f);
1185 case 0x08: /* udma mode */
1186 put_le16(identify_data
+ 62,0x07);
1187 put_le16(identify_data
+ 63,0x07);
1188 put_le16(identify_data
+ 88,0x3f | (1 << (val
+ 8)));
1193 s
->status
= READY_STAT
| SEEK_STAT
;
1194 ide_set_irq(s
->bus
);
1201 case WIN_FLUSH_CACHE
:
1202 case WIN_FLUSH_CACHE_EXT
:
1207 case WIN_STANDBYNOW1
:
1208 case WIN_STANDBYNOW2
:
1209 case WIN_IDLEIMMEDIATE
:
1210 case WIN_IDLEIMMEDIATE2
:
1215 s
->status
= READY_STAT
;
1216 ide_set_irq(s
->bus
);
1219 /* XXX: Check that seek is within bounds */
1220 s
->status
= READY_STAT
| SEEK_STAT
;
1221 ide_set_irq(s
->bus
);
1223 /* ATAPI commands */
1225 ide_atapi_identify(s
);
1226 s
->status
= READY_STAT
| SEEK_STAT
;
1227 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
1228 ide_set_irq(s
->bus
);
1231 ide_set_signature(s
);
1232 if (s
->drive_kind
== IDE_CD
)
1233 s
->status
= 0; /* ATAPI spec (v6) section 9.10 defines packet
1234 * devices to return a clear status register
1235 * with READY_STAT *not* set. */
1237 s
->status
= READY_STAT
| SEEK_STAT
;
1238 s
->error
= 0x01; /* Device 0 passed, Device 1 passed or not
1241 ide_set_irq(s
->bus
);
1243 case WIN_DEVICE_RESET
:
1244 ide_set_signature(s
);
1245 s
->status
= 0x00; /* NOTE: READY is _not_ set */
1249 /* overlapping commands not supported */
1250 if (s
->feature
& 0x02)
1252 s
->status
= READY_STAT
| SEEK_STAT
;
1253 s
->atapi_dma
= s
->feature
& 1;
1255 ide_transfer_start(s
, s
->io_buffer
, ATAPI_PACKET_SIZE
,
1258 /* CF-ATA commands */
1259 case CFA_REQ_EXT_ERROR_CODE
:
1260 s
->error
= 0x09; /* miscellaneous error */
1261 s
->status
= READY_STAT
| SEEK_STAT
;
1262 ide_set_irq(s
->bus
);
1264 case CFA_ERASE_SECTORS
:
1265 case CFA_WEAR_LEVEL
:
1266 if (val
== CFA_WEAR_LEVEL
)
1268 if (val
== CFA_ERASE_SECTORS
)
1269 s
->media_changed
= 1;
1271 s
->status
= READY_STAT
| SEEK_STAT
;
1272 ide_set_irq(s
->bus
);
1274 case CFA_TRANSLATE_SECTOR
:
1276 s
->status
= READY_STAT
| SEEK_STAT
;
1277 memset(s
->io_buffer
, 0, 0x200);
1278 s
->io_buffer
[0x00] = s
->hcyl
; /* Cyl MSB */
1279 s
->io_buffer
[0x01] = s
->lcyl
; /* Cyl LSB */
1280 s
->io_buffer
[0x02] = s
->select
; /* Head */
1281 s
->io_buffer
[0x03] = s
->sector
; /* Sector */
1282 s
->io_buffer
[0x04] = ide_get_sector(s
) >> 16; /* LBA MSB */
1283 s
->io_buffer
[0x05] = ide_get_sector(s
) >> 8; /* LBA */
1284 s
->io_buffer
[0x06] = ide_get_sector(s
) >> 0; /* LBA LSB */
1285 s
->io_buffer
[0x13] = 0x00; /* Erase flag */
1286 s
->io_buffer
[0x18] = 0x00; /* Hot count */
1287 s
->io_buffer
[0x19] = 0x00; /* Hot count */
1288 s
->io_buffer
[0x1a] = 0x01; /* Hot count */
1289 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
1290 ide_set_irq(s
->bus
);
1292 case CFA_ACCESS_METADATA_STORAGE
:
1293 switch (s
->feature
) {
1294 case 0x02: /* Inquiry Metadata Storage */
1295 ide_cfata_metadata_inquiry(s
);
1297 case 0x03: /* Read Metadata Storage */
1298 ide_cfata_metadata_read(s
);
1300 case 0x04: /* Write Metadata Storage */
1301 ide_cfata_metadata_write(s
);
1306 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
1307 s
->status
= 0x00; /* NOTE: READY is _not_ set */
1308 ide_set_irq(s
->bus
);
1310 case IBM_SENSE_CONDITION
:
1311 switch (s
->feature
) {
1312 case 0x01: /* sense temperature in device */
1313 s
->nsector
= 0x50; /* +20 C */
1318 s
->status
= READY_STAT
| SEEK_STAT
;
1319 ide_set_irq(s
->bus
);
1323 if (s
->hcyl
!= 0xc2 || s
->lcyl
!= 0x4f)
1325 if (!s
->smart_enabled
&& s
->feature
!= SMART_ENABLE
)
1327 switch (s
->feature
) {
1329 s
->smart_enabled
= 0;
1330 s
->status
= READY_STAT
| SEEK_STAT
;
1331 ide_set_irq(s
->bus
);
1334 s
->smart_enabled
= 1;
1335 s
->status
= READY_STAT
| SEEK_STAT
;
1336 ide_set_irq(s
->bus
);
1338 case SMART_ATTR_AUTOSAVE
:
1339 switch (s
->sector
) {
1341 s
->smart_autosave
= 0;
1344 s
->smart_autosave
= 1;
1349 s
->status
= READY_STAT
| SEEK_STAT
;
1350 ide_set_irq(s
->bus
);
1353 if (!s
->smart_errors
) {
1360 s
->status
= READY_STAT
| SEEK_STAT
;
1361 ide_set_irq(s
->bus
);
1363 case SMART_READ_THRESH
:
1364 memset(s
->io_buffer
, 0, 0x200);
1365 s
->io_buffer
[0] = 0x01; /* smart struct version */
1366 for (n
=0; n
<30; n
++) {
1367 if (smart_attributes
[n
][0] == 0)
1369 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
1370 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][11];
1372 for (n
=0; n
<511; n
++) /* checksum */
1373 s
->io_buffer
[511] += s
->io_buffer
[n
];
1374 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
1375 s
->status
= READY_STAT
| SEEK_STAT
;
1376 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
1377 ide_set_irq(s
->bus
);
1379 case SMART_READ_DATA
:
1380 memset(s
->io_buffer
, 0, 0x200);
1381 s
->io_buffer
[0] = 0x01; /* smart struct version */
1382 for (n
=0; n
<30; n
++) {
1383 if (smart_attributes
[n
][0] == 0) {
1387 for(i
= 0; i
< 11; i
++) {
1388 s
->io_buffer
[2+i
+(n
*12)] = smart_attributes
[n
][i
];
1391 s
->io_buffer
[362] = 0x02 | (s
->smart_autosave
?0x80:0x00);
1392 if (s
->smart_selftest_count
== 0) {
1393 s
->io_buffer
[363] = 0;
1396 s
->smart_selftest_data
[3 +
1397 (s
->smart_selftest_count
- 1) *
1400 s
->io_buffer
[364] = 0x20;
1401 s
->io_buffer
[365] = 0x01;
1402 /* offline data collection capacity: execute + self-test*/
1403 s
->io_buffer
[367] = (1<<4 | 1<<3 | 1);
1404 s
->io_buffer
[368] = 0x03; /* smart capability (1) */
1405 s
->io_buffer
[369] = 0x00; /* smart capability (2) */
1406 s
->io_buffer
[370] = 0x01; /* error logging supported */
1407 s
->io_buffer
[372] = 0x02; /* minutes for poll short test */
1408 s
->io_buffer
[373] = 0x36; /* minutes for poll ext test */
1409 s
->io_buffer
[374] = 0x01; /* minutes for poll conveyance */
1411 for (n
=0; n
<511; n
++)
1412 s
->io_buffer
[511] += s
->io_buffer
[n
];
1413 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
1414 s
->status
= READY_STAT
| SEEK_STAT
;
1415 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
1416 ide_set_irq(s
->bus
);
1418 case SMART_READ_LOG
:
1419 switch (s
->sector
) {
1420 case 0x01: /* summary smart error log */
1421 memset(s
->io_buffer
, 0, 0x200);
1422 s
->io_buffer
[0] = 0x01;
1423 s
->io_buffer
[1] = 0x00; /* no error entries */
1424 s
->io_buffer
[452] = s
->smart_errors
& 0xff;
1425 s
->io_buffer
[453] = (s
->smart_errors
& 0xff00) >> 8;
1427 for (n
=0; n
<511; n
++)
1428 s
->io_buffer
[511] += s
->io_buffer
[n
];
1429 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
1431 case 0x06: /* smart self test log */
1432 memset(s
->io_buffer
, 0, 0x200);
1433 s
->io_buffer
[0] = 0x01;
1434 if (s
->smart_selftest_count
== 0) {
1435 s
->io_buffer
[508] = 0;
1437 s
->io_buffer
[508] = s
->smart_selftest_count
;
1438 for (n
=2; n
<506; n
++)
1439 s
->io_buffer
[n
] = s
->smart_selftest_data
[n
];
1441 for (n
=0; n
<511; n
++)
1442 s
->io_buffer
[511] += s
->io_buffer
[n
];
1443 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
1448 s
->status
= READY_STAT
| SEEK_STAT
;
1449 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
1450 ide_set_irq(s
->bus
);
1452 case SMART_EXECUTE_OFFLINE
:
1453 switch (s
->sector
) {
1454 case 0: /* off-line routine */
1455 case 1: /* short self test */
1456 case 2: /* extended self test */
1457 s
->smart_selftest_count
++;
1458 if(s
->smart_selftest_count
> 21)
1459 s
->smart_selftest_count
= 0;
1460 n
= 2 + (s
->smart_selftest_count
- 1) * 24;
1461 s
->smart_selftest_data
[n
] = s
->sector
;
1462 s
->smart_selftest_data
[n
+1] = 0x00; /* OK and finished */
1463 s
->smart_selftest_data
[n
+2] = 0x34; /* hour count lsb */
1464 s
->smart_selftest_data
[n
+3] = 0x12; /* hour count msb */
1465 s
->status
= READY_STAT
| SEEK_STAT
;
1466 ide_set_irq(s
->bus
);
1477 /* should not be reachable */
1479 ide_abort_command(s
);
1480 ide_set_irq(s
->bus
);
1485 uint32_t ide_ioport_read(void *opaque
, uint32_t addr1
)
1487 IDEBus
*bus
= opaque
;
1488 IDEState
*s
= idebus_active_if(bus
);
1493 /* FIXME: HOB readback uses bit 7, but it's always set right now */
1494 //hob = s->select & (1 << 7);
1501 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
1502 (s
!= bus
->ifs
&& !s
->bs
))
1507 ret
= s
->hob_feature
;
1510 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
1513 ret
= s
->nsector
& 0xff;
1515 ret
= s
->hob_nsector
;
1518 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
1523 ret
= s
->hob_sector
;
1526 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
1534 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
1542 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
1549 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
1550 (s
!= bus
->ifs
&& !s
->bs
))
1554 qemu_irq_lower(bus
->irq
);
1558 printf("ide: read addr=0x%x val=%02x\n", addr1
, ret
);
1563 uint32_t ide_status_read(void *opaque
, uint32_t addr
)
1565 IDEBus
*bus
= opaque
;
1566 IDEState
*s
= idebus_active_if(bus
);
1569 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
1570 (s
!= bus
->ifs
&& !s
->bs
))
1575 printf("ide: read status addr=0x%x val=%02x\n", addr
, ret
);
1580 void ide_cmd_write(void *opaque
, uint32_t addr
, uint32_t val
)
1582 IDEBus
*bus
= opaque
;
1587 printf("ide: write control addr=0x%x val=%02x\n", addr
, val
);
1589 /* common for both drives */
1590 if (!(bus
->cmd
& IDE_CMD_RESET
) &&
1591 (val
& IDE_CMD_RESET
)) {
1592 /* reset low to high */
1593 for(i
= 0;i
< 2; i
++) {
1595 s
->status
= BUSY_STAT
| SEEK_STAT
;
1598 } else if ((bus
->cmd
& IDE_CMD_RESET
) &&
1599 !(val
& IDE_CMD_RESET
)) {
1601 for(i
= 0;i
< 2; i
++) {
1603 if (s
->drive_kind
== IDE_CD
)
1604 s
->status
= 0x00; /* NOTE: READY is _not_ set */
1606 s
->status
= READY_STAT
| SEEK_STAT
;
1607 ide_set_signature(s
);
1615 * Returns true if the running PIO transfer is a PIO out (i.e. data is
1616 * transferred from the device to the guest), false if it's a PIO in
1618 static bool ide_is_pio_out(IDEState
*s
)
1620 if (s
->end_transfer_func
== ide_sector_write
||
1621 s
->end_transfer_func
== ide_atapi_cmd
) {
1623 } else if (s
->end_transfer_func
== ide_sector_read
||
1624 s
->end_transfer_func
== ide_transfer_stop
||
1625 s
->end_transfer_func
== ide_atapi_cmd_reply_end
||
1626 s
->end_transfer_func
== ide_dummy_transfer_stop
) {
1633 void ide_data_writew(void *opaque
, uint32_t addr
, uint32_t val
)
1635 IDEBus
*bus
= opaque
;
1636 IDEState
*s
= idebus_active_if(bus
);
1639 /* PIO data access allowed only when DRQ bit is set. The result of a write
1640 * during PIO out is indeterminate, just ignore it. */
1641 if (!(s
->status
& DRQ_STAT
) || ide_is_pio_out(s
)) {
1646 *(uint16_t *)p
= le16_to_cpu(val
);
1649 if (p
>= s
->data_end
)
1650 s
->end_transfer_func(s
);
1653 uint32_t ide_data_readw(void *opaque
, uint32_t addr
)
1655 IDEBus
*bus
= opaque
;
1656 IDEState
*s
= idebus_active_if(bus
);
1660 /* PIO data access allowed only when DRQ bit is set. The result of a read
1661 * during PIO in is indeterminate, return 0 and don't move forward. */
1662 if (!(s
->status
& DRQ_STAT
) || !ide_is_pio_out(s
)) {
1667 ret
= cpu_to_le16(*(uint16_t *)p
);
1670 if (p
>= s
->data_end
)
1671 s
->end_transfer_func(s
);
1675 void ide_data_writel(void *opaque
, uint32_t addr
, uint32_t val
)
1677 IDEBus
*bus
= opaque
;
1678 IDEState
*s
= idebus_active_if(bus
);
1681 /* PIO data access allowed only when DRQ bit is set. The result of a write
1682 * during PIO out is indeterminate, just ignore it. */
1683 if (!(s
->status
& DRQ_STAT
) || ide_is_pio_out(s
)) {
1688 *(uint32_t *)p
= le32_to_cpu(val
);
1691 if (p
>= s
->data_end
)
1692 s
->end_transfer_func(s
);
1695 uint32_t ide_data_readl(void *opaque
, uint32_t addr
)
1697 IDEBus
*bus
= opaque
;
1698 IDEState
*s
= idebus_active_if(bus
);
1702 /* PIO data access allowed only when DRQ bit is set. The result of a read
1703 * during PIO in is indeterminate, return 0 and don't move forward. */
1704 if (!(s
->status
& DRQ_STAT
) || !ide_is_pio_out(s
)) {
1709 ret
= cpu_to_le32(*(uint32_t *)p
);
1712 if (p
>= s
->data_end
)
1713 s
->end_transfer_func(s
);
1717 static void ide_dummy_transfer_stop(IDEState
*s
)
1719 s
->data_ptr
= s
->io_buffer
;
1720 s
->data_end
= s
->io_buffer
;
1721 s
->io_buffer
[0] = 0xff;
1722 s
->io_buffer
[1] = 0xff;
1723 s
->io_buffer
[2] = 0xff;
1724 s
->io_buffer
[3] = 0xff;
1727 static void ide_reset(IDEState
*s
)
1730 printf("ide: reset\n");
1732 if (s
->drive_kind
== IDE_CFATA
)
1733 s
->mult_sectors
= 0;
1735 s
->mult_sectors
= MAX_MULT_SECTORS
;
1752 s
->status
= READY_STAT
| SEEK_STAT
;
1756 /* ATAPI specific */
1759 s
->cdrom_changed
= 0;
1760 s
->packet_transfer_size
= 0;
1761 s
->elementary_transfer_size
= 0;
1762 s
->io_buffer_index
= 0;
1763 s
->cd_sector_size
= 0;
1766 s
->io_buffer_size
= 0;
1767 s
->req_nb_sectors
= 0;
1769 ide_set_signature(s
);
1770 /* init the transfer handler so that 0xffff is returned on data
1772 s
->end_transfer_func
= ide_dummy_transfer_stop
;
1773 ide_dummy_transfer_stop(s
);
1774 s
->media_changed
= 0;
1777 void ide_bus_reset(IDEBus
*bus
)
1781 ide_reset(&bus
->ifs
[0]);
1782 ide_reset(&bus
->ifs
[1]);
1785 /* pending async DMA */
1786 if (bus
->dma
->aiocb
) {
1788 printf("aio_cancel\n");
1790 bdrv_aio_cancel(bus
->dma
->aiocb
);
1791 bus
->dma
->aiocb
= NULL
;
1794 /* reset dma provider too */
1795 bus
->dma
->ops
->reset(bus
->dma
);
1798 static const BlockDevOps ide_cd_block_ops
= {
1799 .change_media_cb
= ide_cd_change_cb
,
1802 int ide_init_drive(IDEState
*s
, BlockDriverState
*bs
, IDEDriveKind kind
,
1803 const char *version
, const char *serial
)
1805 int cylinders
, heads
, secs
;
1806 uint64_t nb_sectors
;
1809 s
->drive_kind
= kind
;
1811 bdrv_get_geometry(bs
, &nb_sectors
);
1812 bdrv_guess_geometry(bs
, &cylinders
, &heads
, &secs
);
1813 if (cylinders
< 1 || cylinders
> 16383) {
1814 error_report("cyls must be between 1 and 16383");
1817 if (heads
< 1 || heads
> 16) {
1818 error_report("heads must be between 1 and 16");
1821 if (secs
< 1 || secs
> 63) {
1822 error_report("secs must be between 1 and 63");
1825 s
->cylinders
= cylinders
;
1828 s
->nb_sectors
= nb_sectors
;
1829 /* The SMART values should be preserved across power cycles
1831 s
->smart_enabled
= 1;
1832 s
->smart_autosave
= 1;
1833 s
->smart_errors
= 0;
1834 s
->smart_selftest_count
= 0;
1835 if (kind
== IDE_CD
) {
1836 bdrv_set_dev_ops(bs
, &ide_cd_block_ops
, s
);
1837 bs
->buffer_alignment
= 2048;
1839 if (!bdrv_is_inserted(s
->bs
)) {
1840 error_report("Device needs media, but drive is empty");
1843 if (bdrv_is_read_only(bs
)) {
1844 error_report("Can't use a read-only drive");
1849 strncpy(s
->drive_serial_str
, serial
, sizeof(s
->drive_serial_str
));
1851 snprintf(s
->drive_serial_str
, sizeof(s
->drive_serial_str
),
1852 "QM%05d", s
->drive_serial
);
1855 pstrcpy(s
->version
, sizeof(s
->version
), version
);
1857 pstrcpy(s
->version
, sizeof(s
->version
), QEMU_VERSION
);
1861 bdrv_set_removable(bs
, s
->drive_kind
== IDE_CD
);
1865 static void ide_init1(IDEBus
*bus
, int unit
)
1867 static int drive_serial
= 1;
1868 IDEState
*s
= &bus
->ifs
[unit
];
1872 s
->drive_serial
= drive_serial
++;
1873 /* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
1874 s
->io_buffer_total_len
= IDE_DMA_BUF_SECTORS
*512 + 4;
1875 s
->io_buffer
= qemu_memalign(2048, s
->io_buffer_total_len
);
1876 memset(s
->io_buffer
, 0, s
->io_buffer_total_len
);
1878 s
->smart_selftest_data
= qemu_blockalign(s
->bs
, 512);
1879 memset(s
->smart_selftest_data
, 0, 512);
1881 s
->sector_write_timer
= qemu_new_timer_ns(vm_clock
,
1882 ide_sector_write_timer_cb
, s
);
1885 static void ide_nop_start(IDEDMA
*dma
, IDEState
*s
,
1886 BlockDriverCompletionFunc
*cb
)
1890 static int ide_nop(IDEDMA
*dma
)
1895 static int ide_nop_int(IDEDMA
*dma
, int x
)
1900 static void ide_nop_restart(void *opaque
, int x
, int y
)
1904 static const IDEDMAOps ide_dma_nop_ops
= {
1905 .start_dma
= ide_nop_start
,
1906 .start_transfer
= ide_nop
,
1907 .prepare_buf
= ide_nop_int
,
1908 .rw_buf
= ide_nop_int
,
1909 .set_unit
= ide_nop_int
,
1910 .add_status
= ide_nop_int
,
1911 .set_inactive
= ide_nop
,
1912 .restart_cb
= ide_nop_restart
,
1916 static IDEDMA ide_dma_nop
= {
1917 .ops
= &ide_dma_nop_ops
,
1921 void ide_init2(IDEBus
*bus
, qemu_irq irq
)
1925 for(i
= 0; i
< 2; i
++) {
1927 ide_reset(&bus
->ifs
[i
]);
1930 bus
->dma
= &ide_dma_nop
;
1933 /* TODO convert users to qdev and remove */
1934 void ide_init2_with_non_qdev_drives(IDEBus
*bus
, DriveInfo
*hd0
,
1935 DriveInfo
*hd1
, qemu_irq irq
)
1940 for(i
= 0; i
< 2; i
++) {
1941 dinfo
= i
== 0 ? hd0
: hd1
;
1944 if (ide_init_drive(&bus
->ifs
[i
], dinfo
->bdrv
,
1945 dinfo
->media_cd
? IDE_CD
: IDE_HD
, NULL
,
1946 *dinfo
->serial
? dinfo
->serial
: NULL
) < 0) {
1947 error_report("Can't set up IDE drive %s", dinfo
->id
);
1950 bdrv_attach_dev_nofail(dinfo
->bdrv
, &bus
->ifs
[i
]);
1952 ide_reset(&bus
->ifs
[i
]);
1956 bus
->dma
= &ide_dma_nop
;
1959 void ide_init_ioport(IDEBus
*bus
, int iobase
, int iobase2
)
1961 register_ioport_write(iobase
, 8, 1, ide_ioport_write
, bus
);
1962 register_ioport_read(iobase
, 8, 1, ide_ioport_read
, bus
);
1964 register_ioport_read(iobase2
, 1, 1, ide_status_read
, bus
);
1965 register_ioport_write(iobase2
, 1, 1, ide_cmd_write
, bus
);
1969 register_ioport_write(iobase
, 2, 2, ide_data_writew
, bus
);
1970 register_ioport_read(iobase
, 2, 2, ide_data_readw
, bus
);
1971 register_ioport_write(iobase
, 4, 4, ide_data_writel
, bus
);
1972 register_ioport_read(iobase
, 4, 4, ide_data_readl
, bus
);
1975 static bool is_identify_set(void *opaque
, int version_id
)
1977 IDEState
*s
= opaque
;
1979 return s
->identify_set
!= 0;
1982 static EndTransferFunc
* transfer_end_table
[] = {
1986 ide_atapi_cmd_reply_end
,
1988 ide_dummy_transfer_stop
,
1991 static int transfer_end_table_idx(EndTransferFunc
*fn
)
1995 for (i
= 0; i
< ARRAY_SIZE(transfer_end_table
); i
++)
1996 if (transfer_end_table
[i
] == fn
)
2002 static int ide_drive_post_load(void *opaque
, int version_id
)
2004 IDEState
*s
= opaque
;
2006 if (version_id
< 3) {
2007 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
2008 s
->asc
== ASC_MEDIUM_MAY_HAVE_CHANGED
) {
2009 s
->cdrom_changed
= 1;
2015 static int ide_drive_pio_post_load(void *opaque
, int version_id
)
2017 IDEState
*s
= opaque
;
2019 if (s
->end_transfer_fn_idx
> ARRAY_SIZE(transfer_end_table
)) {
2022 s
->end_transfer_func
= transfer_end_table
[s
->end_transfer_fn_idx
];
2023 s
->data_ptr
= s
->io_buffer
+ s
->cur_io_buffer_offset
;
2024 s
->data_end
= s
->data_ptr
+ s
->cur_io_buffer_len
;
2029 static void ide_drive_pio_pre_save(void *opaque
)
2031 IDEState
*s
= opaque
;
2034 s
->cur_io_buffer_offset
= s
->data_ptr
- s
->io_buffer
;
2035 s
->cur_io_buffer_len
= s
->data_end
- s
->data_ptr
;
2037 idx
= transfer_end_table_idx(s
->end_transfer_func
);
2039 fprintf(stderr
, "%s: invalid end_transfer_func for DRQ_STAT\n",
2041 s
->end_transfer_fn_idx
= 2;
2043 s
->end_transfer_fn_idx
= idx
;
2047 static bool ide_drive_pio_state_needed(void *opaque
)
2049 IDEState
*s
= opaque
;
2051 return ((s
->status
& DRQ_STAT
) != 0)
2052 || (s
->bus
->error_status
& BM_STATUS_PIO_RETRY
);
2055 static bool ide_atapi_gesn_needed(void *opaque
)
2057 IDEState
*s
= opaque
;
2059 return s
->events
.new_media
|| s
->events
.eject_request
;
2062 static bool ide_error_needed(void *opaque
)
2064 IDEBus
*bus
= opaque
;
2066 return (bus
->error_status
!= 0);
2069 /* Fields for GET_EVENT_STATUS_NOTIFICATION ATAPI command */
2070 static const VMStateDescription vmstate_ide_atapi_gesn_state
= {
2071 .name
="ide_drive/atapi/gesn_state",
2073 .minimum_version_id
= 1,
2074 .minimum_version_id_old
= 1,
2075 .fields
= (VMStateField
[]) {
2076 VMSTATE_BOOL(events
.new_media
, IDEState
),
2077 VMSTATE_BOOL(events
.eject_request
, IDEState
),
2078 VMSTATE_END_OF_LIST()
2082 static const VMStateDescription vmstate_ide_drive_pio_state
= {
2083 .name
= "ide_drive/pio_state",
2085 .minimum_version_id
= 1,
2086 .minimum_version_id_old
= 1,
2087 .pre_save
= ide_drive_pio_pre_save
,
2088 .post_load
= ide_drive_pio_post_load
,
2089 .fields
= (VMStateField
[]) {
2090 VMSTATE_INT32(req_nb_sectors
, IDEState
),
2091 VMSTATE_VARRAY_INT32(io_buffer
, IDEState
, io_buffer_total_len
, 1,
2092 vmstate_info_uint8
, uint8_t),
2093 VMSTATE_INT32(cur_io_buffer_offset
, IDEState
),
2094 VMSTATE_INT32(cur_io_buffer_len
, IDEState
),
2095 VMSTATE_UINT8(end_transfer_fn_idx
, IDEState
),
2096 VMSTATE_INT32(elementary_transfer_size
, IDEState
),
2097 VMSTATE_INT32(packet_transfer_size
, IDEState
),
2098 VMSTATE_END_OF_LIST()
2102 const VMStateDescription vmstate_ide_drive
= {
2103 .name
= "ide_drive",
2105 .minimum_version_id
= 0,
2106 .minimum_version_id_old
= 0,
2107 .post_load
= ide_drive_post_load
,
2108 .fields
= (VMStateField
[]) {
2109 VMSTATE_INT32(mult_sectors
, IDEState
),
2110 VMSTATE_INT32(identify_set
, IDEState
),
2111 VMSTATE_BUFFER_TEST(identify_data
, IDEState
, is_identify_set
),
2112 VMSTATE_UINT8(feature
, IDEState
),
2113 VMSTATE_UINT8(error
, IDEState
),
2114 VMSTATE_UINT32(nsector
, IDEState
),
2115 VMSTATE_UINT8(sector
, IDEState
),
2116 VMSTATE_UINT8(lcyl
, IDEState
),
2117 VMSTATE_UINT8(hcyl
, IDEState
),
2118 VMSTATE_UINT8(hob_feature
, IDEState
),
2119 VMSTATE_UINT8(hob_sector
, IDEState
),
2120 VMSTATE_UINT8(hob_nsector
, IDEState
),
2121 VMSTATE_UINT8(hob_lcyl
, IDEState
),
2122 VMSTATE_UINT8(hob_hcyl
, IDEState
),
2123 VMSTATE_UINT8(select
, IDEState
),
2124 VMSTATE_UINT8(status
, IDEState
),
2125 VMSTATE_UINT8(lba48
, IDEState
),
2126 VMSTATE_UINT8(sense_key
, IDEState
),
2127 VMSTATE_UINT8(asc
, IDEState
),
2128 VMSTATE_UINT8_V(cdrom_changed
, IDEState
, 3),
2129 VMSTATE_END_OF_LIST()
2131 .subsections
= (VMStateSubsection
[]) {
2133 .vmsd
= &vmstate_ide_drive_pio_state
,
2134 .needed
= ide_drive_pio_state_needed
,
2136 .vmsd
= &vmstate_ide_atapi_gesn_state
,
2137 .needed
= ide_atapi_gesn_needed
,
2144 static const VMStateDescription vmstate_ide_error_status
= {
2145 .name
="ide_bus/error",
2147 .minimum_version_id
= 1,
2148 .minimum_version_id_old
= 1,
2149 .fields
= (VMStateField
[]) {
2150 VMSTATE_INT32(error_status
, IDEBus
),
2151 VMSTATE_END_OF_LIST()
2155 const VMStateDescription vmstate_ide_bus
= {
2158 .minimum_version_id
= 1,
2159 .minimum_version_id_old
= 1,
2160 .fields
= (VMStateField
[]) {
2161 VMSTATE_UINT8(cmd
, IDEBus
),
2162 VMSTATE_UINT8(unit
, IDEBus
),
2163 VMSTATE_END_OF_LIST()
2165 .subsections
= (VMStateSubsection
[]) {
2167 .vmsd
= &vmstate_ide_error_status
,
2168 .needed
= ide_error_needed
,
2175 void ide_drive_get(DriveInfo
**hd
, int max_bus
)
2179 if (drive_get_max_bus(IF_IDE
) >= max_bus
) {
2180 fprintf(stderr
, "qemu: too many IDE bus: %d\n", max_bus
);
2184 for(i
= 0; i
< max_bus
* MAX_IDE_DEVS
; i
++) {
2185 hd
[i
] = drive_get(IF_IDE
, i
/ MAX_IDE_DEVS
, i
% MAX_IDE_DEVS
);