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
29 #include "qemu-error.h"
30 #include "qemu-timer.h"
35 #include <hw/ide/internal.h>
37 #define IDE_PAGE_SIZE 4096
39 static const int smart_attributes
[][5] = {
40 /* id, flags, val, wrst, thrsh */
41 { 0x01, 0x03, 0x64, 0x64, 0x06}, /* raw read */
42 { 0x03, 0x03, 0x64, 0x64, 0x46}, /* spin up */
43 { 0x04, 0x02, 0x64, 0x64, 0x14}, /* start stop count */
44 { 0x05, 0x03, 0x64, 0x64, 0x36}, /* remapped sectors */
45 { 0x00, 0x00, 0x00, 0x00, 0x00}
48 /* XXX: DVDs that could fit on a CD will be reported as a CD */
49 static inline int media_present(IDEState
*s
)
51 return (s
->nb_sectors
> 0);
54 static inline int media_is_dvd(IDEState
*s
)
56 return (media_present(s
) && s
->nb_sectors
> CD_MAX_SECTORS
);
59 static inline int media_is_cd(IDEState
*s
)
61 return (media_present(s
) && s
->nb_sectors
<= CD_MAX_SECTORS
);
64 static void ide_dma_start(IDEState
*s
, BlockDriverCompletionFunc
*dma_cb
);
65 static void ide_dma_restart(IDEState
*s
, int is_read
);
66 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
);
67 static int ide_handle_rw_error(IDEState
*s
, int error
, int op
);
68 static void ide_flush_cache(IDEState
*s
);
70 static void padstr(char *str
, const char *src
, int len
)
73 for(i
= 0; i
< len
; i
++) {
82 static void padstr8(uint8_t *buf
, int buf_size
, const char *src
)
85 for(i
= 0; i
< buf_size
; i
++) {
93 static void put_le16(uint16_t *p
, unsigned int v
)
98 static void ide_identify(IDEState
*s
)
101 unsigned int oldsize
;
104 if (s
->identify_set
) {
105 memcpy(s
->io_buffer
, s
->identify_data
, sizeof(s
->identify_data
));
109 memset(s
->io_buffer
, 0, 512);
110 p
= (uint16_t *)s
->io_buffer
;
111 put_le16(p
+ 0, 0x0040);
112 put_le16(p
+ 1, s
->cylinders
);
113 put_le16(p
+ 3, s
->heads
);
114 put_le16(p
+ 4, 512 * s
->sectors
); /* XXX: retired, remove ? */
115 put_le16(p
+ 5, 512); /* XXX: retired, remove ? */
116 put_le16(p
+ 6, s
->sectors
);
117 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
118 put_le16(p
+ 20, 3); /* XXX: retired, remove ? */
119 put_le16(p
+ 21, 512); /* cache size in sectors */
120 put_le16(p
+ 22, 4); /* ecc bytes */
121 padstr((char *)(p
+ 23), s
->version
, 8); /* firmware version */
122 padstr((char *)(p
+ 27), "QEMU HARDDISK", 40); /* model */
123 #if MAX_MULT_SECTORS > 1
124 put_le16(p
+ 47, 0x8000 | MAX_MULT_SECTORS
);
126 put_le16(p
+ 48, 1); /* dword I/O */
127 put_le16(p
+ 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
128 put_le16(p
+ 51, 0x200); /* PIO transfer cycle */
129 put_le16(p
+ 52, 0x200); /* DMA transfer cycle */
130 put_le16(p
+ 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
131 put_le16(p
+ 54, s
->cylinders
);
132 put_le16(p
+ 55, s
->heads
);
133 put_le16(p
+ 56, s
->sectors
);
134 oldsize
= s
->cylinders
* s
->heads
* s
->sectors
;
135 put_le16(p
+ 57, oldsize
);
136 put_le16(p
+ 58, oldsize
>> 16);
138 put_le16(p
+ 59, 0x100 | s
->mult_sectors
);
139 put_le16(p
+ 60, s
->nb_sectors
);
140 put_le16(p
+ 61, s
->nb_sectors
>> 16);
141 put_le16(p
+ 62, 0x07); /* single word dma0-2 supported */
142 put_le16(p
+ 63, 0x07); /* mdma0-2 supported */
143 put_le16(p
+ 64, 0x03); /* pio3-4 supported */
144 put_le16(p
+ 65, 120);
145 put_le16(p
+ 66, 120);
146 put_le16(p
+ 67, 120);
147 put_le16(p
+ 68, 120);
148 put_le16(p
+ 80, 0xf0); /* ata3 -> ata6 supported */
149 put_le16(p
+ 81, 0x16); /* conforms to ata5 */
150 /* 14=NOP supported, 5=WCACHE supported, 0=SMART supported */
151 put_le16(p
+ 82, (1 << 14) | (1 << 5) | 1);
152 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
153 put_le16(p
+ 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
154 /* 14=set to 1, 1=SMART self test, 0=SMART error logging */
155 put_le16(p
+ 84, (1 << 14) | 0);
156 /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
157 if (bdrv_enable_write_cache(s
->bs
))
158 put_le16(p
+ 85, (1 << 14) | (1 << 5) | 1);
160 put_le16(p
+ 85, (1 << 14) | 1);
161 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
162 put_le16(p
+ 86, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
163 /* 14=set to 1, 1=smart self test, 0=smart error logging */
164 put_le16(p
+ 87, (1 << 14) | 0);
165 put_le16(p
+ 88, 0x3f | (1 << 13)); /* udma5 set and supported */
166 put_le16(p
+ 93, 1 | (1 << 14) | 0x2000);
167 put_le16(p
+ 100, s
->nb_sectors
);
168 put_le16(p
+ 101, s
->nb_sectors
>> 16);
169 put_le16(p
+ 102, s
->nb_sectors
>> 32);
170 put_le16(p
+ 103, s
->nb_sectors
>> 48);
171 dev
= s
->unit
? s
->bus
->slave
: s
->bus
->master
;
172 if (dev
&& dev
->conf
.physical_block_size
)
173 put_le16(p
+ 106, 0x6000 | get_physical_block_exp(&dev
->conf
));
175 memcpy(s
->identify_data
, p
, sizeof(s
->identify_data
));
179 static void ide_atapi_identify(IDEState
*s
)
183 if (s
->identify_set
) {
184 memcpy(s
->io_buffer
, s
->identify_data
, sizeof(s
->identify_data
));
188 memset(s
->io_buffer
, 0, 512);
189 p
= (uint16_t *)s
->io_buffer
;
190 /* Removable CDROM, 50us response, 12 byte packets */
191 put_le16(p
+ 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
192 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
193 put_le16(p
+ 20, 3); /* buffer type */
194 put_le16(p
+ 21, 512); /* cache size in sectors */
195 put_le16(p
+ 22, 4); /* ecc bytes */
196 padstr((char *)(p
+ 23), s
->version
, 8); /* firmware version */
197 padstr((char *)(p
+ 27), "QEMU DVD-ROM", 40); /* model */
198 put_le16(p
+ 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
200 put_le16(p
+ 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
201 put_le16(p
+ 53, 7); /* words 64-70, 54-58, 88 valid */
202 put_le16(p
+ 62, 7); /* single word dma0-2 supported */
203 put_le16(p
+ 63, 7); /* mdma0-2 supported */
205 put_le16(p
+ 49, 1 << 9); /* LBA supported, no DMA */
206 put_le16(p
+ 53, 3); /* words 64-70, 54-58 valid */
207 put_le16(p
+ 63, 0x103); /* DMA modes XXX: may be incorrect */
209 put_le16(p
+ 64, 3); /* pio3-4 supported */
210 put_le16(p
+ 65, 0xb4); /* minimum DMA multiword tx cycle time */
211 put_le16(p
+ 66, 0xb4); /* recommended DMA multiword tx cycle time */
212 put_le16(p
+ 67, 0x12c); /* minimum PIO cycle time without flow control */
213 put_le16(p
+ 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
215 put_le16(p
+ 71, 30); /* in ns */
216 put_le16(p
+ 72, 30); /* in ns */
218 put_le16(p
+ 80, 0x1e); /* support up to ATA/ATAPI-4 */
220 put_le16(p
+ 88, 0x3f | (1 << 13)); /* udma5 set and supported */
222 memcpy(s
->identify_data
, p
, sizeof(s
->identify_data
));
226 static void ide_cfata_identify(IDEState
*s
)
231 p
= (uint16_t *) s
->identify_data
;
235 memset(p
, 0, sizeof(s
->identify_data
));
237 cur_sec
= s
->cylinders
* s
->heads
* s
->sectors
;
239 put_le16(p
+ 0, 0x848a); /* CF Storage Card signature */
240 put_le16(p
+ 1, s
->cylinders
); /* Default cylinders */
241 put_le16(p
+ 3, s
->heads
); /* Default heads */
242 put_le16(p
+ 6, s
->sectors
); /* Default sectors per track */
243 put_le16(p
+ 7, s
->nb_sectors
>> 16); /* Sectors per card */
244 put_le16(p
+ 8, s
->nb_sectors
); /* Sectors per card */
245 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
246 put_le16(p
+ 22, 0x0004); /* ECC bytes */
247 padstr((char *) (p
+ 23), s
->version
, 8); /* Firmware Revision */
248 padstr((char *) (p
+ 27), "QEMU MICRODRIVE", 40);/* Model number */
249 #if MAX_MULT_SECTORS > 1
250 put_le16(p
+ 47, 0x8000 | MAX_MULT_SECTORS
);
252 put_le16(p
+ 47, 0x0000);
254 put_le16(p
+ 49, 0x0f00); /* Capabilities */
255 put_le16(p
+ 51, 0x0002); /* PIO cycle timing mode */
256 put_le16(p
+ 52, 0x0001); /* DMA cycle timing mode */
257 put_le16(p
+ 53, 0x0003); /* Translation params valid */
258 put_le16(p
+ 54, s
->cylinders
); /* Current cylinders */
259 put_le16(p
+ 55, s
->heads
); /* Current heads */
260 put_le16(p
+ 56, s
->sectors
); /* Current sectors */
261 put_le16(p
+ 57, cur_sec
); /* Current capacity */
262 put_le16(p
+ 58, cur_sec
>> 16); /* Current capacity */
263 if (s
->mult_sectors
) /* Multiple sector setting */
264 put_le16(p
+ 59, 0x100 | s
->mult_sectors
);
265 put_le16(p
+ 60, s
->nb_sectors
); /* Total LBA sectors */
266 put_le16(p
+ 61, s
->nb_sectors
>> 16); /* Total LBA sectors */
267 put_le16(p
+ 63, 0x0203); /* Multiword DMA capability */
268 put_le16(p
+ 64, 0x0001); /* Flow Control PIO support */
269 put_le16(p
+ 65, 0x0096); /* Min. Multiword DMA cycle */
270 put_le16(p
+ 66, 0x0096); /* Rec. Multiword DMA cycle */
271 put_le16(p
+ 68, 0x00b4); /* Min. PIO cycle time */
272 put_le16(p
+ 82, 0x400c); /* Command Set supported */
273 put_le16(p
+ 83, 0x7068); /* Command Set supported */
274 put_le16(p
+ 84, 0x4000); /* Features supported */
275 put_le16(p
+ 85, 0x000c); /* Command Set enabled */
276 put_le16(p
+ 86, 0x7044); /* Command Set enabled */
277 put_le16(p
+ 87, 0x4000); /* Features enabled */
278 put_le16(p
+ 91, 0x4060); /* Current APM level */
279 put_le16(p
+ 129, 0x0002); /* Current features option */
280 put_le16(p
+ 130, 0x0005); /* Reassigned sectors */
281 put_le16(p
+ 131, 0x0001); /* Initial power mode */
282 put_le16(p
+ 132, 0x0000); /* User signature */
283 put_le16(p
+ 160, 0x8100); /* Power requirement */
284 put_le16(p
+ 161, 0x8001); /* CF command set */
289 memcpy(s
->io_buffer
, p
, sizeof(s
->identify_data
));
292 static void ide_set_signature(IDEState
*s
)
294 s
->select
&= 0xf0; /* clear head */
298 if (s
->drive_kind
== IDE_CD
) {
310 static inline void ide_abort_command(IDEState
*s
)
312 s
->status
= READY_STAT
| ERR_STAT
;
316 static inline void ide_dma_submit_check(IDEState
*s
,
317 BlockDriverCompletionFunc
*dma_cb
, BMDMAState
*bm
)
324 /* prepare data transfer and tell what to do after */
325 static void ide_transfer_start(IDEState
*s
, uint8_t *buf
, int size
,
326 EndTransferFunc
*end_transfer_func
)
328 s
->end_transfer_func
= end_transfer_func
;
330 s
->data_end
= buf
+ size
;
331 if (!(s
->status
& ERR_STAT
))
332 s
->status
|= DRQ_STAT
;
335 static void ide_transfer_stop(IDEState
*s
)
337 s
->end_transfer_func
= ide_transfer_stop
;
338 s
->data_ptr
= s
->io_buffer
;
339 s
->data_end
= s
->io_buffer
;
340 s
->status
&= ~DRQ_STAT
;
343 int64_t ide_get_sector(IDEState
*s
)
346 if (s
->select
& 0x40) {
349 sector_num
= ((s
->select
& 0x0f) << 24) | (s
->hcyl
<< 16) |
350 (s
->lcyl
<< 8) | s
->sector
;
352 sector_num
= ((int64_t)s
->hob_hcyl
<< 40) |
353 ((int64_t) s
->hob_lcyl
<< 32) |
354 ((int64_t) s
->hob_sector
<< 24) |
355 ((int64_t) s
->hcyl
<< 16) |
356 ((int64_t) s
->lcyl
<< 8) | s
->sector
;
359 sector_num
= ((s
->hcyl
<< 8) | s
->lcyl
) * s
->heads
* s
->sectors
+
360 (s
->select
& 0x0f) * s
->sectors
+ (s
->sector
- 1);
365 void ide_set_sector(IDEState
*s
, int64_t sector_num
)
368 if (s
->select
& 0x40) {
370 s
->select
= (s
->select
& 0xf0) | (sector_num
>> 24);
371 s
->hcyl
= (sector_num
>> 16);
372 s
->lcyl
= (sector_num
>> 8);
373 s
->sector
= (sector_num
);
375 s
->sector
= sector_num
;
376 s
->lcyl
= sector_num
>> 8;
377 s
->hcyl
= sector_num
>> 16;
378 s
->hob_sector
= sector_num
>> 24;
379 s
->hob_lcyl
= sector_num
>> 32;
380 s
->hob_hcyl
= sector_num
>> 40;
383 cyl
= sector_num
/ (s
->heads
* s
->sectors
);
384 r
= sector_num
% (s
->heads
* s
->sectors
);
387 s
->select
= (s
->select
& 0xf0) | ((r
/ s
->sectors
) & 0x0f);
388 s
->sector
= (r
% s
->sectors
) + 1;
392 static void ide_rw_error(IDEState
*s
) {
393 ide_abort_command(s
);
397 static void ide_sector_read(IDEState
*s
)
402 s
->status
= READY_STAT
| SEEK_STAT
;
403 s
->error
= 0; /* not needed by IDE spec, but needed by Windows */
404 sector_num
= ide_get_sector(s
);
407 /* no more sector to read from disk */
408 ide_transfer_stop(s
);
410 #if defined(DEBUG_IDE)
411 printf("read sector=%" PRId64
"\n", sector_num
);
413 if (n
> s
->req_nb_sectors
)
414 n
= s
->req_nb_sectors
;
415 ret
= bdrv_read(s
->bs
, sector_num
, s
->io_buffer
, n
);
417 if (ide_handle_rw_error(s
, -ret
,
418 BM_STATUS_PIO_RETRY
| BM_STATUS_RETRY_READ
))
423 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_read
);
425 ide_set_sector(s
, sector_num
+ n
);
431 /* return 0 if buffer completed */
432 static int dma_buf_prepare(BMDMAState
*bm
, int is_write
)
434 IDEState
*s
= bmdma_active_if(bm
);
441 qemu_sglist_init(&s
->sg
, s
->nsector
/ (IDE_PAGE_SIZE
/ 512) + 1);
442 s
->io_buffer_size
= 0;
444 if (bm
->cur_prd_len
== 0) {
445 /* end of table (with a fail safe of one page) */
446 if (bm
->cur_prd_last
||
447 (bm
->cur_addr
- bm
->addr
) >= IDE_PAGE_SIZE
)
448 return s
->io_buffer_size
!= 0;
449 cpu_physical_memory_read(bm
->cur_addr
, (uint8_t *)&prd
, 8);
451 prd
.addr
= le32_to_cpu(prd
.addr
);
452 prd
.size
= le32_to_cpu(prd
.size
);
453 len
= prd
.size
& 0xfffe;
456 bm
->cur_prd_len
= len
;
457 bm
->cur_prd_addr
= prd
.addr
;
458 bm
->cur_prd_last
= (prd
.size
& 0x80000000);
462 qemu_sglist_add(&s
->sg
, bm
->cur_prd_addr
, l
);
463 bm
->cur_prd_addr
+= l
;
464 bm
->cur_prd_len
-= l
;
465 s
->io_buffer_size
+= l
;
471 static void dma_buf_commit(IDEState
*s
, int is_write
)
473 qemu_sglist_destroy(&s
->sg
);
476 void ide_dma_error(IDEState
*s
)
478 ide_transfer_stop(s
);
480 s
->status
= READY_STAT
| ERR_STAT
;
484 static int ide_handle_rw_error(IDEState
*s
, int error
, int op
)
486 int is_read
= (op
& BM_STATUS_RETRY_READ
);
487 BlockErrorAction action
= bdrv_get_on_error(s
->bs
, is_read
);
489 if (action
== BLOCK_ERR_IGNORE
) {
490 bdrv_mon_event(s
->bs
, BDRV_ACTION_IGNORE
, is_read
);
494 if ((error
== ENOSPC
&& action
== BLOCK_ERR_STOP_ENOSPC
)
495 || action
== BLOCK_ERR_STOP_ANY
) {
496 s
->bus
->bmdma
->unit
= s
->unit
;
497 s
->bus
->bmdma
->status
|= op
;
498 bdrv_mon_event(s
->bs
, BDRV_ACTION_STOP
, is_read
);
501 if (op
& BM_STATUS_DMA_RETRY
) {
502 dma_buf_commit(s
, 0);
507 bdrv_mon_event(s
->bs
, BDRV_ACTION_REPORT
, is_read
);
513 /* return 0 if buffer completed */
514 static int dma_buf_rw(BMDMAState
*bm
, int is_write
)
516 IDEState
*s
= bmdma_active_if(bm
);
524 l
= s
->io_buffer_size
- s
->io_buffer_index
;
527 if (bm
->cur_prd_len
== 0) {
528 /* end of table (with a fail safe of one page) */
529 if (bm
->cur_prd_last
||
530 (bm
->cur_addr
- bm
->addr
) >= IDE_PAGE_SIZE
)
532 cpu_physical_memory_read(bm
->cur_addr
, (uint8_t *)&prd
, 8);
534 prd
.addr
= le32_to_cpu(prd
.addr
);
535 prd
.size
= le32_to_cpu(prd
.size
);
536 len
= prd
.size
& 0xfffe;
539 bm
->cur_prd_len
= len
;
540 bm
->cur_prd_addr
= prd
.addr
;
541 bm
->cur_prd_last
= (prd
.size
& 0x80000000);
543 if (l
> bm
->cur_prd_len
)
547 cpu_physical_memory_write(bm
->cur_prd_addr
,
548 s
->io_buffer
+ s
->io_buffer_index
, l
);
550 cpu_physical_memory_read(bm
->cur_prd_addr
,
551 s
->io_buffer
+ s
->io_buffer_index
, l
);
553 bm
->cur_prd_addr
+= l
;
554 bm
->cur_prd_len
-= l
;
555 s
->io_buffer_index
+= l
;
561 static void ide_read_dma_cb(void *opaque
, int ret
)
563 BMDMAState
*bm
= opaque
;
564 IDEState
*s
= bmdma_active_if(bm
);
569 if (ide_handle_rw_error(s
, -ret
,
570 BM_STATUS_DMA_RETRY
| BM_STATUS_RETRY_READ
))
576 n
= s
->io_buffer_size
>> 9;
577 sector_num
= ide_get_sector(s
);
579 dma_buf_commit(s
, 1);
581 ide_set_sector(s
, sector_num
);
585 /* end of transfer ? */
586 if (s
->nsector
== 0) {
587 s
->status
= READY_STAT
| SEEK_STAT
;
590 bm
->status
&= ~BM_STATUS_DMAING
;
591 bm
->status
|= BM_STATUS_INT
;
598 /* launch next transfer */
600 s
->io_buffer_index
= 0;
601 s
->io_buffer_size
= n
* 512;
602 if (dma_buf_prepare(bm
, 1) == 0)
605 printf("aio_read: sector_num=%" PRId64
" n=%d\n", sector_num
, n
);
607 bm
->aiocb
= dma_bdrv_read(s
->bs
, &s
->sg
, sector_num
, ide_read_dma_cb
, bm
);
608 ide_dma_submit_check(s
, ide_read_dma_cb
, bm
);
611 static void ide_sector_read_dma(IDEState
*s
)
613 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
614 s
->io_buffer_index
= 0;
615 s
->io_buffer_size
= 0;
617 ide_dma_start(s
, ide_read_dma_cb
);
620 static void ide_sector_write_timer_cb(void *opaque
)
622 IDEState
*s
= opaque
;
626 static void ide_sector_write(IDEState
*s
)
631 s
->status
= READY_STAT
| SEEK_STAT
;
632 sector_num
= ide_get_sector(s
);
633 #if defined(DEBUG_IDE)
634 printf("write sector=%" PRId64
"\n", sector_num
);
637 if (n
> s
->req_nb_sectors
)
638 n
= s
->req_nb_sectors
;
639 ret
= bdrv_write(s
->bs
, sector_num
, s
->io_buffer
, n
);
642 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_PIO_RETRY
))
647 if (s
->nsector
== 0) {
648 /* no more sectors to write */
649 ide_transfer_stop(s
);
652 if (n1
> s
->req_nb_sectors
)
653 n1
= s
->req_nb_sectors
;
654 ide_transfer_start(s
, s
->io_buffer
, 512 * n1
, ide_sector_write
);
656 ide_set_sector(s
, sector_num
+ n
);
658 if (win2k_install_hack
&& ((++s
->irq_count
% 16) == 0)) {
659 /* It seems there is a bug in the Windows 2000 installer HDD
660 IDE driver which fills the disk with empty logs when the
661 IDE write IRQ comes too early. This hack tries to correct
662 that at the expense of slower write performances. Use this
663 option _only_ to install Windows 2000. You must disable it
665 qemu_mod_timer(s
->sector_write_timer
,
666 qemu_get_clock(vm_clock
) + (get_ticks_per_sec() / 1000));
672 static void ide_dma_restart_bh(void *opaque
)
674 BMDMAState
*bm
= opaque
;
677 qemu_bh_delete(bm
->bh
);
680 is_read
= !!(bm
->status
& BM_STATUS_RETRY_READ
);
682 if (bm
->status
& BM_STATUS_DMA_RETRY
) {
683 bm
->status
&= ~(BM_STATUS_DMA_RETRY
| BM_STATUS_RETRY_READ
);
684 ide_dma_restart(bmdma_active_if(bm
), is_read
);
685 } else if (bm
->status
& BM_STATUS_PIO_RETRY
) {
686 bm
->status
&= ~(BM_STATUS_PIO_RETRY
| BM_STATUS_RETRY_READ
);
688 ide_sector_read(bmdma_active_if(bm
));
690 ide_sector_write(bmdma_active_if(bm
));
692 } else if (bm
->status
& BM_STATUS_RETRY_FLUSH
) {
693 ide_flush_cache(bmdma_active_if(bm
));
697 void ide_dma_restart_cb(void *opaque
, int running
, int reason
)
699 BMDMAState
*bm
= opaque
;
705 bm
->bh
= qemu_bh_new(ide_dma_restart_bh
, bm
);
706 qemu_bh_schedule(bm
->bh
);
710 static void ide_write_dma_cb(void *opaque
, int ret
)
712 BMDMAState
*bm
= opaque
;
713 IDEState
*s
= bmdma_active_if(bm
);
718 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_DMA_RETRY
))
722 n
= s
->io_buffer_size
>> 9;
723 sector_num
= ide_get_sector(s
);
725 dma_buf_commit(s
, 0);
727 ide_set_sector(s
, sector_num
);
731 /* end of transfer ? */
732 if (s
->nsector
== 0) {
733 s
->status
= READY_STAT
| SEEK_STAT
;
736 bm
->status
&= ~BM_STATUS_DMAING
;
737 bm
->status
|= BM_STATUS_INT
;
745 s
->io_buffer_size
= n
* 512;
746 /* launch next transfer */
747 if (dma_buf_prepare(bm
, 0) == 0)
750 printf("aio_write: sector_num=%" PRId64
" n=%d\n", sector_num
, n
);
752 bm
->aiocb
= dma_bdrv_write(s
->bs
, &s
->sg
, sector_num
, ide_write_dma_cb
, bm
);
753 ide_dma_submit_check(s
, ide_write_dma_cb
, bm
);
756 static void ide_sector_write_dma(IDEState
*s
)
758 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
759 s
->io_buffer_index
= 0;
760 s
->io_buffer_size
= 0;
762 ide_dma_start(s
, ide_write_dma_cb
);
765 void ide_atapi_cmd_ok(IDEState
*s
)
768 s
->status
= READY_STAT
| SEEK_STAT
;
769 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
773 void ide_atapi_cmd_error(IDEState
*s
, int sense_key
, int asc
)
775 #ifdef DEBUG_IDE_ATAPI
776 printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key
, asc
);
778 s
->error
= sense_key
<< 4;
779 s
->status
= READY_STAT
| ERR_STAT
;
780 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
781 s
->sense_key
= sense_key
;
786 static void ide_atapi_cmd_check_status(IDEState
*s
)
788 #ifdef DEBUG_IDE_ATAPI
789 printf("atapi_cmd_check_status\n");
791 s
->error
= MC_ERR
| (SENSE_UNIT_ATTENTION
<< 4);
792 s
->status
= ERR_STAT
;
797 static void ide_flush_cb(void *opaque
, int ret
)
799 IDEState
*s
= opaque
;
802 /* XXX: What sector number to set here? */
803 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_RETRY_FLUSH
)) {
808 s
->status
= READY_STAT
| SEEK_STAT
;
812 static void ide_flush_cache(IDEState
*s
)
815 bdrv_aio_flush(s
->bs
, ide_flush_cb
, s
);
821 static inline void cpu_to_ube16(uint8_t *buf
, int val
)
827 static inline void cpu_to_ube32(uint8_t *buf
, unsigned int val
)
835 static inline int ube16_to_cpu(const uint8_t *buf
)
837 return (buf
[0] << 8) | buf
[1];
840 static inline int ube32_to_cpu(const uint8_t *buf
)
842 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
845 static void lba_to_msf(uint8_t *buf
, int lba
)
848 buf
[0] = (lba
/ 75) / 60;
849 buf
[1] = (lba
/ 75) % 60;
853 static void cd_data_to_raw(uint8_t *buf
, int lba
)
857 memset(buf
+ 1, 0xff, 10);
861 lba_to_msf(buf
, lba
);
862 buf
[3] = 0x01; /* mode 1 data */
866 /* XXX: ECC not computed */
870 static int cd_read_sector(BlockDriverState
*bs
, int lba
, uint8_t *buf
,
875 switch(sector_size
) {
877 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
, 4);
880 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
+ 16, 4);
883 cd_data_to_raw(buf
, lba
);
892 void ide_atapi_io_error(IDEState
*s
, int ret
)
894 /* XXX: handle more errors */
895 if (ret
== -ENOMEDIUM
) {
896 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
897 ASC_MEDIUM_NOT_PRESENT
);
899 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
900 ASC_LOGICAL_BLOCK_OOR
);
904 /* The whole ATAPI transfer logic is handled in this function */
905 static void ide_atapi_cmd_reply_end(IDEState
*s
)
907 int byte_count_limit
, size
, ret
;
908 #ifdef DEBUG_IDE_ATAPI
909 printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
910 s
->packet_transfer_size
,
911 s
->elementary_transfer_size
,
914 if (s
->packet_transfer_size
<= 0) {
915 /* end of transfer */
916 ide_transfer_stop(s
);
917 s
->status
= READY_STAT
| SEEK_STAT
;
918 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
920 #ifdef DEBUG_IDE_ATAPI
921 printf("status=0x%x\n", s
->status
);
924 /* see if a new sector must be read */
925 if (s
->lba
!= -1 && s
->io_buffer_index
>= s
->cd_sector_size
) {
926 ret
= cd_read_sector(s
->bs
, s
->lba
, s
->io_buffer
, s
->cd_sector_size
);
928 ide_transfer_stop(s
);
929 ide_atapi_io_error(s
, ret
);
933 s
->io_buffer_index
= 0;
935 if (s
->elementary_transfer_size
> 0) {
936 /* there are some data left to transmit in this elementary
938 size
= s
->cd_sector_size
- s
->io_buffer_index
;
939 if (size
> s
->elementary_transfer_size
)
940 size
= s
->elementary_transfer_size
;
941 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
,
942 size
, ide_atapi_cmd_reply_end
);
943 s
->packet_transfer_size
-= size
;
944 s
->elementary_transfer_size
-= size
;
945 s
->io_buffer_index
+= size
;
947 /* a new transfer is needed */
948 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
;
949 byte_count_limit
= s
->lcyl
| (s
->hcyl
<< 8);
950 #ifdef DEBUG_IDE_ATAPI
951 printf("byte_count_limit=%d\n", byte_count_limit
);
953 if (byte_count_limit
== 0xffff)
955 size
= s
->packet_transfer_size
;
956 if (size
> byte_count_limit
) {
957 /* byte count limit must be even if this case */
958 if (byte_count_limit
& 1)
960 size
= byte_count_limit
;
964 s
->elementary_transfer_size
= size
;
965 /* we cannot transmit more than one sector at a time */
967 if (size
> (s
->cd_sector_size
- s
->io_buffer_index
))
968 size
= (s
->cd_sector_size
- s
->io_buffer_index
);
970 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
,
971 size
, ide_atapi_cmd_reply_end
);
972 s
->packet_transfer_size
-= size
;
973 s
->elementary_transfer_size
-= size
;
974 s
->io_buffer_index
+= size
;
976 #ifdef DEBUG_IDE_ATAPI
977 printf("status=0x%x\n", s
->status
);
983 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
984 static void ide_atapi_cmd_reply(IDEState
*s
, int size
, int max_size
)
988 s
->lba
= -1; /* no sector read */
989 s
->packet_transfer_size
= size
;
990 s
->io_buffer_size
= size
; /* dma: send the reply data as one chunk */
991 s
->elementary_transfer_size
= 0;
992 s
->io_buffer_index
= 0;
995 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
;
996 ide_dma_start(s
, ide_atapi_cmd_read_dma_cb
);
998 s
->status
= READY_STAT
| SEEK_STAT
;
999 ide_atapi_cmd_reply_end(s
);
1003 /* start a CD-CDROM read command */
1004 static void ide_atapi_cmd_read_pio(IDEState
*s
, int lba
, int nb_sectors
,
1008 s
->packet_transfer_size
= nb_sectors
* sector_size
;
1009 s
->elementary_transfer_size
= 0;
1010 s
->io_buffer_index
= sector_size
;
1011 s
->cd_sector_size
= sector_size
;
1013 s
->status
= READY_STAT
| SEEK_STAT
;
1014 ide_atapi_cmd_reply_end(s
);
1017 /* ATAPI DMA support */
1019 /* XXX: handle read errors */
1020 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
)
1022 BMDMAState
*bm
= opaque
;
1023 IDEState
*s
= bmdma_active_if(bm
);
1027 ide_atapi_io_error(s
, ret
);
1031 if (s
->io_buffer_size
> 0) {
1033 * For a cdrom read sector command (s->lba != -1),
1034 * adjust the lba for the next s->io_buffer_size chunk
1035 * and dma the current chunk.
1036 * For a command != read (s->lba == -1), just transfer
1040 if (s
->cd_sector_size
== 2352) {
1042 cd_data_to_raw(s
->io_buffer
, s
->lba
);
1044 n
= s
->io_buffer_size
>> 11;
1048 s
->packet_transfer_size
-= s
->io_buffer_size
;
1049 if (dma_buf_rw(bm
, 1) == 0)
1053 if (s
->packet_transfer_size
<= 0) {
1054 s
->status
= READY_STAT
| SEEK_STAT
;
1055 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
1056 ide_set_irq(s
->bus
);
1058 bm
->status
&= ~BM_STATUS_DMAING
;
1059 bm
->status
|= BM_STATUS_INT
;
1066 s
->io_buffer_index
= 0;
1067 if (s
->cd_sector_size
== 2352) {
1069 s
->io_buffer_size
= s
->cd_sector_size
;
1072 n
= s
->packet_transfer_size
>> 11;
1073 if (n
> (IDE_DMA_BUF_SECTORS
/ 4))
1074 n
= (IDE_DMA_BUF_SECTORS
/ 4);
1075 s
->io_buffer_size
= n
* 2048;
1079 printf("aio_read_cd: lba=%u n=%d\n", s
->lba
, n
);
1081 bm
->iov
.iov_base
= (void *)(s
->io_buffer
+ data_offset
);
1082 bm
->iov
.iov_len
= n
* 4 * 512;
1083 qemu_iovec_init_external(&bm
->qiov
, &bm
->iov
, 1);
1084 bm
->aiocb
= bdrv_aio_readv(s
->bs
, (int64_t)s
->lba
<< 2, &bm
->qiov
,
1085 n
* 4, ide_atapi_cmd_read_dma_cb
, bm
);
1087 /* Note: media not present is the most likely case */
1088 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1089 ASC_MEDIUM_NOT_PRESENT
);
1094 /* start a CD-CDROM read command with DMA */
1095 /* XXX: test if DMA is available */
1096 static void ide_atapi_cmd_read_dma(IDEState
*s
, int lba
, int nb_sectors
,
1100 s
->packet_transfer_size
= nb_sectors
* sector_size
;
1101 s
->io_buffer_index
= 0;
1102 s
->io_buffer_size
= 0;
1103 s
->cd_sector_size
= sector_size
;
1105 /* XXX: check if BUSY_STAT should be set */
1106 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
1107 ide_dma_start(s
, ide_atapi_cmd_read_dma_cb
);
1110 static void ide_atapi_cmd_read(IDEState
*s
, int lba
, int nb_sectors
,
1113 #ifdef DEBUG_IDE_ATAPI
1114 printf("read %s: LBA=%d nb_sectors=%d\n", s
->atapi_dma
? "dma" : "pio",
1118 ide_atapi_cmd_read_dma(s
, lba
, nb_sectors
, sector_size
);
1120 ide_atapi_cmd_read_pio(s
, lba
, nb_sectors
, sector_size
);
1124 static inline uint8_t ide_atapi_set_profile(uint8_t *buf
, uint8_t *index
,
1127 uint8_t *buf_profile
= buf
+ 12; /* start of profiles */
1129 buf_profile
+= ((*index
) * 4); /* start of indexed profile */
1130 cpu_to_ube16 (buf_profile
, profile
);
1131 buf_profile
[2] = ((buf_profile
[0] == buf
[6]) && (buf_profile
[1] == buf
[7]));
1133 /* each profile adds 4 bytes to the response */
1135 buf
[11] += 4; /* Additional Length */
1140 static int ide_dvd_read_structure(IDEState
*s
, int format
,
1141 const uint8_t *packet
, uint8_t *buf
)
1144 case 0x0: /* Physical format information */
1146 int layer
= packet
[6];
1147 uint64_t total_sectors
;
1150 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1152 bdrv_get_geometry(s
->bs
, &total_sectors
);
1153 total_sectors
>>= 2;
1154 if (total_sectors
== 0)
1155 return -ASC_MEDIUM_NOT_PRESENT
;
1157 buf
[4] = 1; /* DVD-ROM, part version 1 */
1158 buf
[5] = 0xf; /* 120mm disc, minimum rate unspecified */
1159 buf
[6] = 1; /* one layer, read-only (per MMC-2 spec) */
1160 buf
[7] = 0; /* default densities */
1162 /* FIXME: 0x30000 per spec? */
1163 cpu_to_ube32(buf
+ 8, 0); /* start sector */
1164 cpu_to_ube32(buf
+ 12, total_sectors
- 1); /* end sector */
1165 cpu_to_ube32(buf
+ 16, total_sectors
- 1); /* l0 end sector */
1167 /* Size of buffer, not including 2 byte size field */
1168 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
1170 /* 2k data + 4 byte header */
1174 case 0x01: /* DVD copyright information */
1175 buf
[4] = 0; /* no copyright data */
1176 buf
[5] = 0; /* no region restrictions */
1178 /* Size of buffer, not including 2 byte size field */
1179 cpu_to_be16wu((uint16_t *)buf
, 4 + 2);
1181 /* 4 byte header + 4 byte data */
1184 case 0x03: /* BCA information - invalid field for no BCA info */
1185 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1187 case 0x04: /* DVD disc manufacturing information */
1188 /* Size of buffer, not including 2 byte size field */
1189 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
1191 /* 2k data + 4 byte header */
1196 * This lists all the command capabilities above. Add new ones
1197 * in order and update the length and buffer return values.
1200 buf
[4] = 0x00; /* Physical format */
1201 buf
[5] = 0x40; /* Not writable, is readable */
1202 cpu_to_be16wu((uint16_t *)(buf
+ 6), 2048 + 4);
1204 buf
[8] = 0x01; /* Copyright info */
1205 buf
[9] = 0x40; /* Not writable, is readable */
1206 cpu_to_be16wu((uint16_t *)(buf
+ 10), 4 + 4);
1208 buf
[12] = 0x03; /* BCA info */
1209 buf
[13] = 0x40; /* Not writable, is readable */
1210 cpu_to_be16wu((uint16_t *)(buf
+ 14), 188 + 4);
1212 buf
[16] = 0x04; /* Manufacturing info */
1213 buf
[17] = 0x40; /* Not writable, is readable */
1214 cpu_to_be16wu((uint16_t *)(buf
+ 18), 2048 + 4);
1216 /* Size of buffer, not including 2 byte size field */
1217 cpu_to_be16wu((uint16_t *)buf
, 16 + 2);
1219 /* data written + 4 byte header */
1222 default: /* TODO: formats beyond DVD-ROM requires */
1223 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1227 static void ide_atapi_cmd(IDEState
*s
)
1229 const uint8_t *packet
;
1233 packet
= s
->io_buffer
;
1235 #ifdef DEBUG_IDE_ATAPI
1238 printf("ATAPI limit=0x%x packet:", s
->lcyl
| (s
->hcyl
<< 8));
1239 for(i
= 0; i
< ATAPI_PACKET_SIZE
; i
++) {
1240 printf(" %02x", packet
[i
]);
1245 /* If there's a UNIT_ATTENTION condition pending, only
1246 REQUEST_SENSE and INQUIRY commands are allowed to complete. */
1247 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
1248 s
->io_buffer
[0] != GPCMD_REQUEST_SENSE
&&
1249 s
->io_buffer
[0] != GPCMD_INQUIRY
) {
1250 ide_atapi_cmd_check_status(s
);
1253 switch(s
->io_buffer
[0]) {
1254 case GPCMD_TEST_UNIT_READY
:
1255 if (bdrv_is_inserted(s
->bs
) && !s
->cdrom_changed
) {
1256 ide_atapi_cmd_ok(s
);
1258 s
->cdrom_changed
= 0;
1259 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1260 ASC_MEDIUM_NOT_PRESENT
);
1263 case GPCMD_MODE_SENSE_6
:
1264 case GPCMD_MODE_SENSE_10
:
1267 if (packet
[0] == GPCMD_MODE_SENSE_10
)
1268 max_len
= ube16_to_cpu(packet
+ 7);
1270 max_len
= packet
[4];
1271 action
= packet
[2] >> 6;
1272 code
= packet
[2] & 0x3f;
1274 case 0: /* current values */
1276 case GPMODE_R_W_ERROR_PAGE
: /* error recovery */
1277 cpu_to_ube16(&buf
[0], 16 + 6);
1293 ide_atapi_cmd_reply(s
, 16, max_len
);
1295 case GPMODE_AUDIO_CTL_PAGE
:
1296 cpu_to_ube16(&buf
[0], 24 + 6);
1304 /* Fill with CDROM audio volume */
1310 ide_atapi_cmd_reply(s
, 24, max_len
);
1312 case GPMODE_CAPABILITIES_PAGE
:
1313 cpu_to_ube16(&buf
[0], 28 + 6);
1326 /* Claim PLAY_AUDIO capability (0x01) since some Linux
1327 code checks for this to automount media. */
1330 buf
[14] = (1 << 0) | (1 << 3) | (1 << 5);
1331 if (bdrv_is_locked(s
->bs
))
1334 cpu_to_ube16(&buf
[16], 706);
1337 cpu_to_ube16(&buf
[20], 512);
1338 cpu_to_ube16(&buf
[22], 706);
1343 ide_atapi_cmd_reply(s
, 28, max_len
);
1349 case 1: /* changeable values */
1351 case 2: /* default values */
1354 case 3: /* saved values */
1355 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1356 ASC_SAVING_PARAMETERS_NOT_SUPPORTED
);
1361 case GPCMD_REQUEST_SENSE
:
1362 max_len
= packet
[4];
1364 buf
[0] = 0x70 | (1 << 7);
1365 buf
[2] = s
->sense_key
;
1368 if (s
->sense_key
== SENSE_UNIT_ATTENTION
)
1369 s
->sense_key
= SENSE_NONE
;
1370 ide_atapi_cmd_reply(s
, 18, max_len
);
1372 case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
:
1373 if (bdrv_is_inserted(s
->bs
)) {
1374 bdrv_set_locked(s
->bs
, packet
[4] & 1);
1375 ide_atapi_cmd_ok(s
);
1377 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1378 ASC_MEDIUM_NOT_PRESENT
);
1384 int nb_sectors
, lba
;
1386 if (packet
[0] == GPCMD_READ_10
)
1387 nb_sectors
= ube16_to_cpu(packet
+ 7);
1389 nb_sectors
= ube32_to_cpu(packet
+ 6);
1390 lba
= ube32_to_cpu(packet
+ 2);
1391 if (nb_sectors
== 0) {
1392 ide_atapi_cmd_ok(s
);
1395 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
1400 int nb_sectors
, lba
, transfer_request
;
1402 nb_sectors
= (packet
[6] << 16) | (packet
[7] << 8) | packet
[8];
1403 lba
= ube32_to_cpu(packet
+ 2);
1404 if (nb_sectors
== 0) {
1405 ide_atapi_cmd_ok(s
);
1408 transfer_request
= packet
[9];
1409 switch(transfer_request
& 0xf8) {
1412 ide_atapi_cmd_ok(s
);
1416 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
1420 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2352);
1423 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1424 ASC_INV_FIELD_IN_CMD_PACKET
);
1432 uint64_t total_sectors
;
1434 bdrv_get_geometry(s
->bs
, &total_sectors
);
1435 total_sectors
>>= 2;
1436 if (total_sectors
== 0) {
1437 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1438 ASC_MEDIUM_NOT_PRESENT
);
1441 lba
= ube32_to_cpu(packet
+ 2);
1442 if (lba
>= total_sectors
) {
1443 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1444 ASC_LOGICAL_BLOCK_OOR
);
1447 ide_atapi_cmd_ok(s
);
1450 case GPCMD_START_STOP_UNIT
:
1452 int start
, eject
, err
= 0;
1453 start
= packet
[4] & 1;
1454 eject
= (packet
[4] >> 1) & 1;
1457 err
= bdrv_eject(s
->bs
, !start
);
1462 ide_atapi_cmd_ok(s
);
1465 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1466 ASC_MEDIA_REMOVAL_PREVENTED
);
1469 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1470 ASC_MEDIUM_NOT_PRESENT
);
1475 case GPCMD_MECHANISM_STATUS
:
1477 max_len
= ube16_to_cpu(packet
+ 8);
1478 cpu_to_ube16(buf
, 0);
1479 /* no current LBA */
1484 cpu_to_ube16(buf
+ 6, 0);
1485 ide_atapi_cmd_reply(s
, 8, max_len
);
1488 case GPCMD_READ_TOC_PMA_ATIP
:
1490 int format
, msf
, start_track
, len
;
1491 uint64_t total_sectors
;
1493 bdrv_get_geometry(s
->bs
, &total_sectors
);
1494 total_sectors
>>= 2;
1495 if (total_sectors
== 0) {
1496 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1497 ASC_MEDIUM_NOT_PRESENT
);
1500 max_len
= ube16_to_cpu(packet
+ 7);
1501 format
= packet
[9] >> 6;
1502 msf
= (packet
[1] >> 1) & 1;
1503 start_track
= packet
[6];
1506 len
= cdrom_read_toc(total_sectors
, buf
, msf
, start_track
);
1509 ide_atapi_cmd_reply(s
, len
, max_len
);
1512 /* multi session : only a single session defined */
1517 ide_atapi_cmd_reply(s
, 12, max_len
);
1520 len
= cdrom_read_toc_raw(total_sectors
, buf
, msf
, start_track
);
1523 ide_atapi_cmd_reply(s
, len
, max_len
);
1527 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1528 ASC_INV_FIELD_IN_CMD_PACKET
);
1533 case GPCMD_READ_CDVD_CAPACITY
:
1535 uint64_t total_sectors
;
1537 bdrv_get_geometry(s
->bs
, &total_sectors
);
1538 total_sectors
>>= 2;
1539 if (total_sectors
== 0) {
1540 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1541 ASC_MEDIUM_NOT_PRESENT
);
1544 /* NOTE: it is really the number of sectors minus 1 */
1545 cpu_to_ube32(buf
, total_sectors
- 1);
1546 cpu_to_ube32(buf
+ 4, 2048);
1547 ide_atapi_cmd_reply(s
, 8, 8);
1550 case GPCMD_READ_DVD_STRUCTURE
:
1552 int media
= packet
[1];
1553 int format
= packet
[7];
1556 max_len
= ube16_to_cpu(packet
+ 8);
1558 if (format
< 0xff) {
1559 if (media_is_cd(s
)) {
1560 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1561 ASC_INCOMPATIBLE_FORMAT
);
1563 } else if (!media_present(s
)) {
1564 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1565 ASC_INV_FIELD_IN_CMD_PACKET
);
1570 memset(buf
, 0, max_len
> IDE_DMA_BUF_SECTORS
* 512 + 4 ?
1571 IDE_DMA_BUF_SECTORS
* 512 + 4 : max_len
);
1577 ret
= ide_dvd_read_structure(s
, format
, packet
, buf
);
1580 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
, -ret
);
1582 ide_atapi_cmd_reply(s
, ret
, max_len
);
1586 /* TODO: BD support, fall through for now */
1588 /* Generic disk structures */
1589 case 0x80: /* TODO: AACS volume identifier */
1590 case 0x81: /* TODO: AACS media serial number */
1591 case 0x82: /* TODO: AACS media identifier */
1592 case 0x83: /* TODO: AACS media key block */
1593 case 0x90: /* TODO: List of recognized format layers */
1594 case 0xc0: /* TODO: Write protection status */
1596 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1597 ASC_INV_FIELD_IN_CMD_PACKET
);
1602 case GPCMD_SET_SPEED
:
1603 ide_atapi_cmd_ok(s
);
1606 max_len
= packet
[4];
1607 buf
[0] = 0x05; /* CD-ROM */
1608 buf
[1] = 0x80; /* removable */
1609 buf
[2] = 0x00; /* ISO */
1610 buf
[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1611 buf
[4] = 31; /* additional length */
1612 buf
[5] = 0; /* reserved */
1613 buf
[6] = 0; /* reserved */
1614 buf
[7] = 0; /* reserved */
1615 padstr8(buf
+ 8, 8, "QEMU");
1616 padstr8(buf
+ 16, 16, "QEMU DVD-ROM");
1617 padstr8(buf
+ 32, 4, s
->version
);
1618 ide_atapi_cmd_reply(s
, 36, max_len
);
1620 case GPCMD_GET_CONFIGURATION
:
1625 /* only feature 0 is supported */
1626 if (packet
[2] != 0 || packet
[3] != 0) {
1627 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1628 ASC_INV_FIELD_IN_CMD_PACKET
);
1632 /* XXX: could result in alignment problems in some architectures */
1633 max_len
= ube16_to_cpu(packet
+ 7);
1636 * XXX: avoid overflow for io_buffer if max_len is bigger than
1637 * the size of that buffer (dimensioned to max number of
1638 * sectors to transfer at once)
1640 * Only a problem if the feature/profiles grow.
1642 if (max_len
> 512) /* XXX: assume 1 sector */
1645 memset(buf
, 0, max_len
);
1647 * the number of sectors from the media tells us which profile
1648 * to use as current. 0 means there is no media
1650 if (media_is_dvd(s
))
1651 cpu_to_ube16(buf
+ 6, MMC_PROFILE_DVD_ROM
);
1652 else if (media_is_cd(s
))
1653 cpu_to_ube16(buf
+ 6, MMC_PROFILE_CD_ROM
);
1655 buf
[10] = 0x02 | 0x01; /* persistent and current */
1656 len
= 12; /* headers: 8 + 4 */
1657 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_DVD_ROM
);
1658 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_CD_ROM
);
1659 cpu_to_ube32(buf
, len
- 4); /* data length */
1661 ide_atapi_cmd_reply(s
, len
, max_len
);
1664 case GPCMD_GET_EVENT_STATUS_NOTIFICATION
:
1665 max_len
= ube16_to_cpu(packet
+ 7);
1667 if (packet
[1] & 0x01) { /* polling */
1668 /* We don't support any event class (yet). */
1669 cpu_to_ube16(buf
, 0x00); /* No event descriptor returned */
1670 buf
[2] = 0x80; /* No Event Available (NEA) */
1671 buf
[3] = 0x00; /* Empty supported event classes */
1672 ide_atapi_cmd_reply(s
, 4, max_len
);
1673 } else { /* asynchronous mode */
1674 /* Only polling is supported, asynchronous mode is not. */
1675 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1676 ASC_INV_FIELD_IN_CMD_PACKET
);
1680 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1681 ASC_ILLEGAL_OPCODE
);
1686 static void ide_cfata_metadata_inquiry(IDEState
*s
)
1691 p
= (uint16_t *) s
->io_buffer
;
1692 memset(p
, 0, 0x200);
1693 spd
= ((s
->mdata_size
- 1) >> 9) + 1;
1695 put_le16(p
+ 0, 0x0001); /* Data format revision */
1696 put_le16(p
+ 1, 0x0000); /* Media property: silicon */
1697 put_le16(p
+ 2, s
->media_changed
); /* Media status */
1698 put_le16(p
+ 3, s
->mdata_size
& 0xffff); /* Capacity in bytes (low) */
1699 put_le16(p
+ 4, s
->mdata_size
>> 16); /* Capacity in bytes (high) */
1700 put_le16(p
+ 5, spd
& 0xffff); /* Sectors per device (low) */
1701 put_le16(p
+ 6, spd
>> 16); /* Sectors per device (high) */
1704 static void ide_cfata_metadata_read(IDEState
*s
)
1708 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
1709 s
->status
= ERR_STAT
;
1710 s
->error
= ABRT_ERR
;
1714 p
= (uint16_t *) s
->io_buffer
;
1715 memset(p
, 0, 0x200);
1717 put_le16(p
+ 0, s
->media_changed
); /* Media status */
1718 memcpy(p
+ 1, s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1719 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1720 s
->nsector
<< 9), 0x200 - 2));
1723 static void ide_cfata_metadata_write(IDEState
*s
)
1725 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
1726 s
->status
= ERR_STAT
;
1727 s
->error
= ABRT_ERR
;
1731 s
->media_changed
= 0;
1733 memcpy(s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1735 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1736 s
->nsector
<< 9), 0x200 - 2));
1739 /* called when the inserted state of the media has changed */
1740 static void cdrom_change_cb(void *opaque
)
1742 IDEState
*s
= opaque
;
1743 uint64_t nb_sectors
;
1745 bdrv_get_geometry(s
->bs
, &nb_sectors
);
1746 s
->nb_sectors
= nb_sectors
;
1748 s
->sense_key
= SENSE_UNIT_ATTENTION
;
1749 s
->asc
= ASC_MEDIUM_MAY_HAVE_CHANGED
;
1750 s
->cdrom_changed
= 1;
1751 ide_set_irq(s
->bus
);
1754 static void ide_cmd_lba48_transform(IDEState
*s
, int lba48
)
1758 /* handle the 'magic' 0 nsector count conversion here. to avoid
1759 * fiddling with the rest of the read logic, we just store the
1760 * full sector count in ->nsector and ignore ->hob_nsector from now
1766 if (!s
->nsector
&& !s
->hob_nsector
)
1769 int lo
= s
->nsector
;
1770 int hi
= s
->hob_nsector
;
1772 s
->nsector
= (hi
<< 8) | lo
;
1777 static void ide_clear_hob(IDEBus
*bus
)
1779 /* any write clears HOB high bit of device control register */
1780 bus
->ifs
[0].select
&= ~(1 << 7);
1781 bus
->ifs
[1].select
&= ~(1 << 7);
1784 void ide_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
1786 IDEBus
*bus
= opaque
;
1792 printf("IDE: write addr=0x%x val=0x%02x\n", addr
, val
);
1797 /* ignore writes to command block while busy with previous command */
1798 if (addr
!= 7 && (idebus_active_if(bus
)->status
& (BUSY_STAT
|DRQ_STAT
)))
1806 /* NOTE: data is written to the two drives */
1807 bus
->ifs
[0].hob_feature
= bus
->ifs
[0].feature
;
1808 bus
->ifs
[1].hob_feature
= bus
->ifs
[1].feature
;
1809 bus
->ifs
[0].feature
= val
;
1810 bus
->ifs
[1].feature
= val
;
1814 bus
->ifs
[0].hob_nsector
= bus
->ifs
[0].nsector
;
1815 bus
->ifs
[1].hob_nsector
= bus
->ifs
[1].nsector
;
1816 bus
->ifs
[0].nsector
= val
;
1817 bus
->ifs
[1].nsector
= val
;
1821 bus
->ifs
[0].hob_sector
= bus
->ifs
[0].sector
;
1822 bus
->ifs
[1].hob_sector
= bus
->ifs
[1].sector
;
1823 bus
->ifs
[0].sector
= val
;
1824 bus
->ifs
[1].sector
= val
;
1828 bus
->ifs
[0].hob_lcyl
= bus
->ifs
[0].lcyl
;
1829 bus
->ifs
[1].hob_lcyl
= bus
->ifs
[1].lcyl
;
1830 bus
->ifs
[0].lcyl
= val
;
1831 bus
->ifs
[1].lcyl
= val
;
1835 bus
->ifs
[0].hob_hcyl
= bus
->ifs
[0].hcyl
;
1836 bus
->ifs
[1].hob_hcyl
= bus
->ifs
[1].hcyl
;
1837 bus
->ifs
[0].hcyl
= val
;
1838 bus
->ifs
[1].hcyl
= val
;
1841 /* FIXME: HOB readback uses bit 7 */
1842 bus
->ifs
[0].select
= (val
& ~0x10) | 0xa0;
1843 bus
->ifs
[1].select
= (val
| 0x10) | 0xa0;
1845 bus
->unit
= (val
>> 4) & 1;
1850 #if defined(DEBUG_IDE)
1851 printf("ide: CMD=%02x\n", val
);
1853 s
= idebus_active_if(bus
);
1854 /* ignore commands to non existant slave */
1855 if (s
!= bus
->ifs
&& !s
->bs
)
1858 /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
1859 if ((s
->status
& (BUSY_STAT
|DRQ_STAT
)) && val
!= WIN_DEVICE_RESET
)
1864 if (s
->bs
&& s
->drive_kind
!= IDE_CD
) {
1865 if (s
->drive_kind
!= IDE_CFATA
)
1868 ide_cfata_identify(s
);
1869 s
->status
= READY_STAT
| SEEK_STAT
;
1870 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
1872 if (s
->drive_kind
== IDE_CD
) {
1873 ide_set_signature(s
);
1875 ide_abort_command(s
);
1877 ide_set_irq(s
->bus
);
1882 s
->status
= READY_STAT
| SEEK_STAT
;
1883 ide_set_irq(s
->bus
);
1886 if (s
->drive_kind
== IDE_CFATA
&& s
->nsector
== 0) {
1887 /* Disable Read and Write Multiple */
1888 s
->mult_sectors
= 0;
1889 s
->status
= READY_STAT
| SEEK_STAT
;
1890 } else if ((s
->nsector
& 0xff) != 0 &&
1891 ((s
->nsector
& 0xff) > MAX_MULT_SECTORS
||
1892 (s
->nsector
& (s
->nsector
- 1)) != 0)) {
1893 ide_abort_command(s
);
1895 s
->mult_sectors
= s
->nsector
& 0xff;
1896 s
->status
= READY_STAT
| SEEK_STAT
;
1898 ide_set_irq(s
->bus
);
1900 case WIN_VERIFY_EXT
:
1903 case WIN_VERIFY_ONCE
:
1904 /* do sector number check ? */
1905 ide_cmd_lba48_transform(s
, lba48
);
1906 s
->status
= READY_STAT
| SEEK_STAT
;
1907 ide_set_irq(s
->bus
);
1915 ide_cmd_lba48_transform(s
, lba48
);
1916 s
->req_nb_sectors
= 1;
1922 case WIN_WRITE_ONCE
:
1923 case CFA_WRITE_SECT_WO_ERASE
:
1924 case WIN_WRITE_VERIFY
:
1925 ide_cmd_lba48_transform(s
, lba48
);
1927 s
->status
= SEEK_STAT
| READY_STAT
;
1928 s
->req_nb_sectors
= 1;
1929 ide_transfer_start(s
, s
->io_buffer
, 512, ide_sector_write
);
1930 s
->media_changed
= 1;
1932 case WIN_MULTREAD_EXT
:
1935 if (!s
->mult_sectors
)
1937 ide_cmd_lba48_transform(s
, lba48
);
1938 s
->req_nb_sectors
= s
->mult_sectors
;
1941 case WIN_MULTWRITE_EXT
:
1944 case CFA_WRITE_MULTI_WO_ERASE
:
1945 if (!s
->mult_sectors
)
1947 ide_cmd_lba48_transform(s
, lba48
);
1949 s
->status
= SEEK_STAT
| READY_STAT
;
1950 s
->req_nb_sectors
= s
->mult_sectors
;
1952 if (n
> s
->req_nb_sectors
)
1953 n
= s
->req_nb_sectors
;
1954 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_write
);
1955 s
->media_changed
= 1;
1957 case WIN_READDMA_EXT
:
1960 case WIN_READDMA_ONCE
:
1963 ide_cmd_lba48_transform(s
, lba48
);
1964 ide_sector_read_dma(s
);
1966 case WIN_WRITEDMA_EXT
:
1969 case WIN_WRITEDMA_ONCE
:
1972 ide_cmd_lba48_transform(s
, lba48
);
1973 ide_sector_write_dma(s
);
1974 s
->media_changed
= 1;
1976 case WIN_READ_NATIVE_MAX_EXT
:
1978 case WIN_READ_NATIVE_MAX
:
1979 ide_cmd_lba48_transform(s
, lba48
);
1980 ide_set_sector(s
, s
->nb_sectors
- 1);
1981 s
->status
= READY_STAT
| SEEK_STAT
;
1982 ide_set_irq(s
->bus
);
1984 case WIN_CHECKPOWERMODE1
:
1985 case WIN_CHECKPOWERMODE2
:
1986 s
->nsector
= 0xff; /* device active or idle */
1987 s
->status
= READY_STAT
| SEEK_STAT
;
1988 ide_set_irq(s
->bus
);
1990 case WIN_SETFEATURES
:
1993 /* XXX: valid for CDROM ? */
1994 switch(s
->feature
) {
1995 case 0xcc: /* reverting to power-on defaults enable */
1996 case 0x66: /* reverting to power-on defaults disable */
1997 case 0x02: /* write cache enable */
1998 case 0x82: /* write cache disable */
1999 case 0xaa: /* read look-ahead enable */
2000 case 0x55: /* read look-ahead disable */
2001 case 0x05: /* set advanced power management mode */
2002 case 0x85: /* disable advanced power management mode */
2003 case 0x69: /* NOP */
2004 case 0x67: /* NOP */
2005 case 0x96: /* NOP */
2006 case 0x9a: /* NOP */
2007 case 0x42: /* enable Automatic Acoustic Mode */
2008 case 0xc2: /* disable Automatic Acoustic Mode */
2009 s
->status
= READY_STAT
| SEEK_STAT
;
2010 ide_set_irq(s
->bus
);
2012 case 0x03: { /* set transfer mode */
2013 uint8_t val
= s
->nsector
& 0x07;
2014 uint16_t *identify_data
= (uint16_t *)s
->identify_data
;
2016 switch (s
->nsector
>> 3) {
2017 case 0x00: /* pio default */
2018 case 0x01: /* pio mode */
2019 put_le16(identify_data
+ 62,0x07);
2020 put_le16(identify_data
+ 63,0x07);
2021 put_le16(identify_data
+ 88,0x3f);
2023 case 0x02: /* sigle word dma mode*/
2024 put_le16(identify_data
+ 62,0x07 | (1 << (val
+ 8)));
2025 put_le16(identify_data
+ 63,0x07);
2026 put_le16(identify_data
+ 88,0x3f);
2028 case 0x04: /* mdma mode */
2029 put_le16(identify_data
+ 62,0x07);
2030 put_le16(identify_data
+ 63,0x07 | (1 << (val
+ 8)));
2031 put_le16(identify_data
+ 88,0x3f);
2033 case 0x08: /* udma mode */
2034 put_le16(identify_data
+ 62,0x07);
2035 put_le16(identify_data
+ 63,0x07);
2036 put_le16(identify_data
+ 88,0x3f | (1 << (val
+ 8)));
2041 s
->status
= READY_STAT
| SEEK_STAT
;
2042 ide_set_irq(s
->bus
);
2049 case WIN_FLUSH_CACHE
:
2050 case WIN_FLUSH_CACHE_EXT
:
2055 case WIN_STANDBYNOW1
:
2056 case WIN_STANDBYNOW2
:
2057 case WIN_IDLEIMMEDIATE
:
2058 case CFA_IDLEIMMEDIATE
:
2063 s
->status
= READY_STAT
;
2064 ide_set_irq(s
->bus
);
2067 if(s
->drive_kind
== IDE_CD
)
2069 /* XXX: Check that seek is within bounds */
2070 s
->status
= READY_STAT
| SEEK_STAT
;
2071 ide_set_irq(s
->bus
);
2073 /* ATAPI commands */
2075 if (s
->drive_kind
== IDE_CD
) {
2076 ide_atapi_identify(s
);
2077 s
->status
= READY_STAT
| SEEK_STAT
;
2078 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
2080 ide_abort_command(s
);
2082 ide_set_irq(s
->bus
);
2085 ide_set_signature(s
);
2086 if (s
->drive_kind
== IDE_CD
)
2087 s
->status
= 0; /* ATAPI spec (v6) section 9.10 defines packet
2088 * devices to return a clear status register
2089 * with READY_STAT *not* set. */
2091 s
->status
= READY_STAT
| SEEK_STAT
;
2092 s
->error
= 0x01; /* Device 0 passed, Device 1 passed or not
2095 ide_set_irq(s
->bus
);
2098 if (s
->drive_kind
!= IDE_CD
)
2100 ide_set_signature(s
);
2101 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2105 if (s
->drive_kind
!= IDE_CD
)
2107 /* overlapping commands not supported */
2108 if (s
->feature
& 0x02)
2110 s
->status
= READY_STAT
| SEEK_STAT
;
2111 s
->atapi_dma
= s
->feature
& 1;
2113 ide_transfer_start(s
, s
->io_buffer
, ATAPI_PACKET_SIZE
,
2116 /* CF-ATA commands */
2117 case CFA_REQ_EXT_ERROR_CODE
:
2118 if (s
->drive_kind
!= IDE_CFATA
)
2120 s
->error
= 0x09; /* miscellaneous error */
2121 s
->status
= READY_STAT
| SEEK_STAT
;
2122 ide_set_irq(s
->bus
);
2124 case CFA_ERASE_SECTORS
:
2125 case CFA_WEAR_LEVEL
:
2126 if (s
->drive_kind
!= IDE_CFATA
)
2128 if (val
== CFA_WEAR_LEVEL
)
2130 if (val
== CFA_ERASE_SECTORS
)
2131 s
->media_changed
= 1;
2133 s
->status
= READY_STAT
| SEEK_STAT
;
2134 ide_set_irq(s
->bus
);
2136 case CFA_TRANSLATE_SECTOR
:
2137 if (s
->drive_kind
!= IDE_CFATA
)
2140 s
->status
= READY_STAT
| SEEK_STAT
;
2141 memset(s
->io_buffer
, 0, 0x200);
2142 s
->io_buffer
[0x00] = s
->hcyl
; /* Cyl MSB */
2143 s
->io_buffer
[0x01] = s
->lcyl
; /* Cyl LSB */
2144 s
->io_buffer
[0x02] = s
->select
; /* Head */
2145 s
->io_buffer
[0x03] = s
->sector
; /* Sector */
2146 s
->io_buffer
[0x04] = ide_get_sector(s
) >> 16; /* LBA MSB */
2147 s
->io_buffer
[0x05] = ide_get_sector(s
) >> 8; /* LBA */
2148 s
->io_buffer
[0x06] = ide_get_sector(s
) >> 0; /* LBA LSB */
2149 s
->io_buffer
[0x13] = 0x00; /* Erase flag */
2150 s
->io_buffer
[0x18] = 0x00; /* Hot count */
2151 s
->io_buffer
[0x19] = 0x00; /* Hot count */
2152 s
->io_buffer
[0x1a] = 0x01; /* Hot count */
2153 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2154 ide_set_irq(s
->bus
);
2156 case CFA_ACCESS_METADATA_STORAGE
:
2157 if (s
->drive_kind
!= IDE_CFATA
)
2159 switch (s
->feature
) {
2160 case 0x02: /* Inquiry Metadata Storage */
2161 ide_cfata_metadata_inquiry(s
);
2163 case 0x03: /* Read Metadata Storage */
2164 ide_cfata_metadata_read(s
);
2166 case 0x04: /* Write Metadata Storage */
2167 ide_cfata_metadata_write(s
);
2172 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2173 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2174 ide_set_irq(s
->bus
);
2176 case IBM_SENSE_CONDITION
:
2177 if (s
->drive_kind
!= IDE_CFATA
)
2179 switch (s
->feature
) {
2180 case 0x01: /* sense temperature in device */
2181 s
->nsector
= 0x50; /* +20 C */
2186 s
->status
= READY_STAT
| SEEK_STAT
;
2187 ide_set_irq(s
->bus
);
2191 if (s
->drive_kind
== IDE_CD
)
2193 if (s
->hcyl
!= 0xc2 || s
->lcyl
!= 0x4f)
2195 if (!s
->smart_enabled
&& s
->feature
!= SMART_ENABLE
)
2197 switch (s
->feature
) {
2199 s
->smart_enabled
= 0;
2200 s
->status
= READY_STAT
| SEEK_STAT
;
2201 ide_set_irq(s
->bus
);
2204 s
->smart_enabled
= 1;
2205 s
->status
= READY_STAT
| SEEK_STAT
;
2206 ide_set_irq(s
->bus
);
2208 case SMART_ATTR_AUTOSAVE
:
2209 switch (s
->sector
) {
2211 s
->smart_autosave
= 0;
2214 s
->smart_autosave
= 1;
2219 s
->status
= READY_STAT
| SEEK_STAT
;
2220 ide_set_irq(s
->bus
);
2223 if (!s
->smart_errors
) {
2230 s
->status
= READY_STAT
| SEEK_STAT
;
2231 ide_set_irq(s
->bus
);
2233 case SMART_READ_THRESH
:
2234 memset(s
->io_buffer
, 0, 0x200);
2235 s
->io_buffer
[0] = 0x01; /* smart struct version */
2236 for (n
=0; n
<30; n
++) {
2237 if (smart_attributes
[n
][0] == 0)
2239 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
2240 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][4];
2242 for (n
=0; n
<511; n
++) /* checksum */
2243 s
->io_buffer
[511] += s
->io_buffer
[n
];
2244 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2245 s
->status
= READY_STAT
| SEEK_STAT
;
2246 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2247 ide_set_irq(s
->bus
);
2249 case SMART_READ_DATA
:
2250 memset(s
->io_buffer
, 0, 0x200);
2251 s
->io_buffer
[0] = 0x01; /* smart struct version */
2252 for (n
=0; n
<30; n
++) {
2253 if (smart_attributes
[n
][0] == 0)
2255 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
2256 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][1];
2257 s
->io_buffer
[2+3+(n
*12)] = smart_attributes
[n
][2];
2258 s
->io_buffer
[2+4+(n
*12)] = smart_attributes
[n
][3];
2260 s
->io_buffer
[362] = 0x02 | (s
->smart_autosave
?0x80:0x00);
2261 if (s
->smart_selftest_count
== 0) {
2262 s
->io_buffer
[363] = 0;
2265 s
->smart_selftest_data
[3 +
2266 (s
->smart_selftest_count
- 1) *
2269 s
->io_buffer
[364] = 0x20;
2270 s
->io_buffer
[365] = 0x01;
2271 /* offline data collection capacity: execute + self-test*/
2272 s
->io_buffer
[367] = (1<<4 | 1<<3 | 1);
2273 s
->io_buffer
[368] = 0x03; /* smart capability (1) */
2274 s
->io_buffer
[369] = 0x00; /* smart capability (2) */
2275 s
->io_buffer
[370] = 0x01; /* error logging supported */
2276 s
->io_buffer
[372] = 0x02; /* minutes for poll short test */
2277 s
->io_buffer
[373] = 0x36; /* minutes for poll ext test */
2278 s
->io_buffer
[374] = 0x01; /* minutes for poll conveyance */
2280 for (n
=0; n
<511; n
++)
2281 s
->io_buffer
[511] += s
->io_buffer
[n
];
2282 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2283 s
->status
= READY_STAT
| SEEK_STAT
;
2284 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2285 ide_set_irq(s
->bus
);
2287 case SMART_READ_LOG
:
2288 switch (s
->sector
) {
2289 case 0x01: /* summary smart error log */
2290 memset(s
->io_buffer
, 0, 0x200);
2291 s
->io_buffer
[0] = 0x01;
2292 s
->io_buffer
[1] = 0x00; /* no error entries */
2293 s
->io_buffer
[452] = s
->smart_errors
& 0xff;
2294 s
->io_buffer
[453] = (s
->smart_errors
& 0xff00) >> 8;
2296 for (n
=0; n
<511; n
++)
2297 s
->io_buffer
[511] += s
->io_buffer
[n
];
2298 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2300 case 0x06: /* smart self test log */
2301 memset(s
->io_buffer
, 0, 0x200);
2302 s
->io_buffer
[0] = 0x01;
2303 if (s
->smart_selftest_count
== 0) {
2304 s
->io_buffer
[508] = 0;
2306 s
->io_buffer
[508] = s
->smart_selftest_count
;
2307 for (n
=2; n
<506; n
++)
2308 s
->io_buffer
[n
] = s
->smart_selftest_data
[n
];
2310 for (n
=0; n
<511; n
++)
2311 s
->io_buffer
[511] += s
->io_buffer
[n
];
2312 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2317 s
->status
= READY_STAT
| SEEK_STAT
;
2318 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2319 ide_set_irq(s
->bus
);
2321 case SMART_EXECUTE_OFFLINE
:
2322 switch (s
->sector
) {
2323 case 0: /* off-line routine */
2324 case 1: /* short self test */
2325 case 2: /* extended self test */
2326 s
->smart_selftest_count
++;
2327 if(s
->smart_selftest_count
> 21)
2328 s
->smart_selftest_count
= 0;
2329 n
= 2 + (s
->smart_selftest_count
- 1) * 24;
2330 s
->smart_selftest_data
[n
] = s
->sector
;
2331 s
->smart_selftest_data
[n
+1] = 0x00; /* OK and finished */
2332 s
->smart_selftest_data
[n
+2] = 0x34; /* hour count lsb */
2333 s
->smart_selftest_data
[n
+3] = 0x12; /* hour count msb */
2334 s
->status
= READY_STAT
| SEEK_STAT
;
2335 ide_set_irq(s
->bus
);
2347 ide_abort_command(s
);
2348 ide_set_irq(s
->bus
);
2354 uint32_t ide_ioport_read(void *opaque
, uint32_t addr1
)
2356 IDEBus
*bus
= opaque
;
2357 IDEState
*s
= idebus_active_if(bus
);
2362 /* FIXME: HOB readback uses bit 7, but it's always set right now */
2363 //hob = s->select & (1 << 7);
2370 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2371 (s
!= bus
->ifs
&& !s
->bs
))
2376 ret
= s
->hob_feature
;
2379 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2382 ret
= s
->nsector
& 0xff;
2384 ret
= s
->hob_nsector
;
2387 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2392 ret
= s
->hob_sector
;
2395 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2403 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2411 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2418 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2419 (s
!= bus
->ifs
&& !s
->bs
))
2423 qemu_irq_lower(bus
->irq
);
2427 printf("ide: read addr=0x%x val=%02x\n", addr1
, ret
);
2432 uint32_t ide_status_read(void *opaque
, uint32_t addr
)
2434 IDEBus
*bus
= opaque
;
2435 IDEState
*s
= idebus_active_if(bus
);
2438 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2439 (s
!= bus
->ifs
&& !s
->bs
))
2444 printf("ide: read status addr=0x%x val=%02x\n", addr
, ret
);
2449 void ide_cmd_write(void *opaque
, uint32_t addr
, uint32_t val
)
2451 IDEBus
*bus
= opaque
;
2456 printf("ide: write control addr=0x%x val=%02x\n", addr
, val
);
2458 /* common for both drives */
2459 if (!(bus
->cmd
& IDE_CMD_RESET
) &&
2460 (val
& IDE_CMD_RESET
)) {
2461 /* reset low to high */
2462 for(i
= 0;i
< 2; i
++) {
2464 s
->status
= BUSY_STAT
| SEEK_STAT
;
2467 } else if ((bus
->cmd
& IDE_CMD_RESET
) &&
2468 !(val
& IDE_CMD_RESET
)) {
2470 for(i
= 0;i
< 2; i
++) {
2472 if (s
->drive_kind
== IDE_CD
)
2473 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2475 s
->status
= READY_STAT
| SEEK_STAT
;
2476 ide_set_signature(s
);
2483 void ide_data_writew(void *opaque
, uint32_t addr
, uint32_t val
)
2485 IDEBus
*bus
= opaque
;
2486 IDEState
*s
= idebus_active_if(bus
);
2489 /* PIO data access allowed only when DRQ bit is set */
2490 if (!(s
->status
& DRQ_STAT
))
2494 *(uint16_t *)p
= le16_to_cpu(val
);
2497 if (p
>= s
->data_end
)
2498 s
->end_transfer_func(s
);
2501 uint32_t ide_data_readw(void *opaque
, uint32_t addr
)
2503 IDEBus
*bus
= opaque
;
2504 IDEState
*s
= idebus_active_if(bus
);
2508 /* PIO data access allowed only when DRQ bit is set */
2509 if (!(s
->status
& DRQ_STAT
))
2513 ret
= cpu_to_le16(*(uint16_t *)p
);
2516 if (p
>= s
->data_end
)
2517 s
->end_transfer_func(s
);
2521 void ide_data_writel(void *opaque
, uint32_t addr
, uint32_t val
)
2523 IDEBus
*bus
= opaque
;
2524 IDEState
*s
= idebus_active_if(bus
);
2527 /* PIO data access allowed only when DRQ bit is set */
2528 if (!(s
->status
& DRQ_STAT
))
2532 *(uint32_t *)p
= le32_to_cpu(val
);
2535 if (p
>= s
->data_end
)
2536 s
->end_transfer_func(s
);
2539 uint32_t ide_data_readl(void *opaque
, uint32_t addr
)
2541 IDEBus
*bus
= opaque
;
2542 IDEState
*s
= idebus_active_if(bus
);
2546 /* PIO data access allowed only when DRQ bit is set */
2547 if (!(s
->status
& DRQ_STAT
))
2551 ret
= cpu_to_le32(*(uint32_t *)p
);
2554 if (p
>= s
->data_end
)
2555 s
->end_transfer_func(s
);
2559 static void ide_dummy_transfer_stop(IDEState
*s
)
2561 s
->data_ptr
= s
->io_buffer
;
2562 s
->data_end
= s
->io_buffer
;
2563 s
->io_buffer
[0] = 0xff;
2564 s
->io_buffer
[1] = 0xff;
2565 s
->io_buffer
[2] = 0xff;
2566 s
->io_buffer
[3] = 0xff;
2569 static void ide_reset(IDEState
*s
)
2572 printf("ide: reset\n");
2574 if (s
->drive_kind
== IDE_CFATA
)
2575 s
->mult_sectors
= 0;
2577 s
->mult_sectors
= MAX_MULT_SECTORS
;
2594 s
->status
= READY_STAT
| SEEK_STAT
;
2598 /* ATAPI specific */
2601 s
->cdrom_changed
= 0;
2602 s
->packet_transfer_size
= 0;
2603 s
->elementary_transfer_size
= 0;
2604 s
->io_buffer_index
= 0;
2605 s
->cd_sector_size
= 0;
2608 s
->io_buffer_size
= 0;
2609 s
->req_nb_sectors
= 0;
2611 ide_set_signature(s
);
2612 /* init the transfer handler so that 0xffff is returned on data
2614 s
->end_transfer_func
= ide_dummy_transfer_stop
;
2615 ide_dummy_transfer_stop(s
);
2616 s
->media_changed
= 0;
2619 void ide_bus_reset(IDEBus
*bus
)
2623 ide_reset(&bus
->ifs
[0]);
2624 ide_reset(&bus
->ifs
[1]);
2628 int ide_init_drive(IDEState
*s
, BlockDriverState
*bs
,
2629 const char *version
, const char *serial
)
2631 int cylinders
, heads
, secs
;
2632 uint64_t nb_sectors
;
2635 bdrv_get_geometry(bs
, &nb_sectors
);
2636 bdrv_guess_geometry(bs
, &cylinders
, &heads
, &secs
);
2637 if (cylinders
< 1 || cylinders
> 16383) {
2638 error_report("cyls must be between 1 and 16383");
2641 if (heads
< 1 || heads
> 16) {
2642 error_report("heads must be between 1 and 16");
2645 if (secs
< 1 || secs
> 63) {
2646 error_report("secs must be between 1 and 63");
2649 s
->cylinders
= cylinders
;
2652 s
->nb_sectors
= nb_sectors
;
2653 /* The SMART values should be preserved across power cycles
2655 s
->smart_enabled
= 1;
2656 s
->smart_autosave
= 1;
2657 s
->smart_errors
= 0;
2658 s
->smart_selftest_count
= 0;
2659 if (bdrv_get_type_hint(bs
) == BDRV_TYPE_CDROM
) {
2660 s
->drive_kind
= IDE_CD
;
2661 bdrv_set_change_cb(bs
, cdrom_change_cb
, s
);
2662 bs
->buffer_alignment
= 2048;
2664 if (!bdrv_is_inserted(s
->bs
)) {
2665 error_report("Device needs media, but drive is empty");
2668 if (bdrv_is_read_only(bs
)) {
2669 error_report("Can't use a read-only drive");
2674 strncpy(s
->drive_serial_str
, serial
, sizeof(s
->drive_serial_str
));
2676 snprintf(s
->drive_serial_str
, sizeof(s
->drive_serial_str
),
2677 "QM%05d", s
->drive_serial
);
2680 pstrcpy(s
->version
, sizeof(s
->version
), version
);
2682 pstrcpy(s
->version
, sizeof(s
->version
), QEMU_VERSION
);
2685 bdrv_set_removable(bs
, s
->drive_kind
== IDE_CD
);
2689 static void ide_init1(IDEBus
*bus
, int unit
)
2691 static int drive_serial
= 1;
2692 IDEState
*s
= &bus
->ifs
[unit
];
2696 s
->drive_serial
= drive_serial
++;
2697 /* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
2698 s
->io_buffer
= qemu_memalign(2048, IDE_DMA_BUF_SECTORS
*512 + 4);
2699 s
->io_buffer_total_len
= IDE_DMA_BUF_SECTORS
*512 + 4;
2700 s
->smart_selftest_data
= qemu_blockalign(s
->bs
, 512);
2701 s
->sector_write_timer
= qemu_new_timer(vm_clock
,
2702 ide_sector_write_timer_cb
, s
);
2705 void ide_init2(IDEBus
*bus
, qemu_irq irq
)
2709 for(i
= 0; i
< 2; i
++) {
2711 ide_reset(&bus
->ifs
[i
]);
2716 /* TODO convert users to qdev and remove */
2717 void ide_init2_with_non_qdev_drives(IDEBus
*bus
, DriveInfo
*hd0
,
2718 DriveInfo
*hd1
, qemu_irq irq
)
2723 for(i
= 0; i
< 2; i
++) {
2724 dinfo
= i
== 0 ? hd0
: hd1
;
2727 if (ide_init_drive(&bus
->ifs
[i
], dinfo
->bdrv
, NULL
,
2728 *dinfo
->serial
? dinfo
->serial
: NULL
) < 0) {
2729 error_report("Can't set up IDE drive %s", dinfo
->id
);
2733 ide_reset(&bus
->ifs
[i
]);
2739 void ide_init_ioport(IDEBus
*bus
, int iobase
, int iobase2
)
2741 register_ioport_write(iobase
, 8, 1, ide_ioport_write
, bus
);
2742 register_ioport_read(iobase
, 8, 1, ide_ioport_read
, bus
);
2744 register_ioport_read(iobase2
, 1, 1, ide_status_read
, bus
);
2745 register_ioport_write(iobase2
, 1, 1, ide_cmd_write
, bus
);
2749 register_ioport_write(iobase
, 2, 2, ide_data_writew
, bus
);
2750 register_ioport_read(iobase
, 2, 2, ide_data_readw
, bus
);
2751 register_ioport_write(iobase
, 4, 4, ide_data_writel
, bus
);
2752 register_ioport_read(iobase
, 4, 4, ide_data_readl
, bus
);
2755 static bool is_identify_set(void *opaque
, int version_id
)
2757 IDEState
*s
= opaque
;
2759 return s
->identify_set
!= 0;
2762 static EndTransferFunc
* transfer_end_table
[] = {
2766 ide_atapi_cmd_reply_end
,
2768 ide_dummy_transfer_stop
,
2771 static int transfer_end_table_idx(EndTransferFunc
*fn
)
2775 for (i
= 0; i
< ARRAY_SIZE(transfer_end_table
); i
++)
2776 if (transfer_end_table
[i
] == fn
)
2782 static int ide_drive_post_load(void *opaque
, int version_id
)
2784 IDEState
*s
= opaque
;
2786 if (version_id
< 3) {
2787 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
2788 s
->asc
== ASC_MEDIUM_MAY_HAVE_CHANGED
) {
2789 s
->cdrom_changed
= 1;
2795 static int ide_drive_pio_post_load(void *opaque
, int version_id
)
2797 IDEState
*s
= opaque
;
2799 if (s
->end_transfer_fn_idx
> ARRAY_SIZE(transfer_end_table
)) {
2802 s
->end_transfer_func
= transfer_end_table
[s
->end_transfer_fn_idx
];
2803 s
->data_ptr
= s
->io_buffer
+ s
->cur_io_buffer_offset
;
2804 s
->data_end
= s
->data_ptr
+ s
->cur_io_buffer_len
;
2809 static void ide_drive_pio_pre_save(void *opaque
)
2811 IDEState
*s
= opaque
;
2814 s
->cur_io_buffer_offset
= s
->data_ptr
- s
->io_buffer
;
2815 s
->cur_io_buffer_len
= s
->data_end
- s
->data_ptr
;
2817 idx
= transfer_end_table_idx(s
->end_transfer_func
);
2819 fprintf(stderr
, "%s: invalid end_transfer_func for DRQ_STAT\n",
2821 s
->end_transfer_fn_idx
= 2;
2823 s
->end_transfer_fn_idx
= idx
;
2827 static bool ide_drive_pio_state_needed(void *opaque
)
2829 IDEState
*s
= opaque
;
2831 return (s
->status
& DRQ_STAT
) != 0;
2834 const VMStateDescription vmstate_ide_drive_pio_state
= {
2835 .name
= "ide_drive/pio_state",
2837 .minimum_version_id
= 1,
2838 .minimum_version_id_old
= 1,
2839 .pre_save
= ide_drive_pio_pre_save
,
2840 .post_load
= ide_drive_pio_post_load
,
2841 .fields
= (VMStateField
[]) {
2842 VMSTATE_INT32(req_nb_sectors
, IDEState
),
2843 VMSTATE_VARRAY_INT32(io_buffer
, IDEState
, io_buffer_total_len
, 1,
2844 vmstate_info_uint8
, uint8_t),
2845 VMSTATE_INT32(cur_io_buffer_offset
, IDEState
),
2846 VMSTATE_INT32(cur_io_buffer_len
, IDEState
),
2847 VMSTATE_UINT8(end_transfer_fn_idx
, IDEState
),
2848 VMSTATE_INT32(elementary_transfer_size
, IDEState
),
2849 VMSTATE_INT32(packet_transfer_size
, IDEState
),
2850 VMSTATE_END_OF_LIST()
2854 const VMStateDescription vmstate_ide_drive
= {
2855 .name
= "ide_drive",
2857 .minimum_version_id
= 0,
2858 .minimum_version_id_old
= 0,
2859 .post_load
= ide_drive_post_load
,
2860 .fields
= (VMStateField
[]) {
2861 VMSTATE_INT32(mult_sectors
, IDEState
),
2862 VMSTATE_INT32(identify_set
, IDEState
),
2863 VMSTATE_BUFFER_TEST(identify_data
, IDEState
, is_identify_set
),
2864 VMSTATE_UINT8(feature
, IDEState
),
2865 VMSTATE_UINT8(error
, IDEState
),
2866 VMSTATE_UINT32(nsector
, IDEState
),
2867 VMSTATE_UINT8(sector
, IDEState
),
2868 VMSTATE_UINT8(lcyl
, IDEState
),
2869 VMSTATE_UINT8(hcyl
, IDEState
),
2870 VMSTATE_UINT8(hob_feature
, IDEState
),
2871 VMSTATE_UINT8(hob_sector
, IDEState
),
2872 VMSTATE_UINT8(hob_nsector
, IDEState
),
2873 VMSTATE_UINT8(hob_lcyl
, IDEState
),
2874 VMSTATE_UINT8(hob_hcyl
, IDEState
),
2875 VMSTATE_UINT8(select
, IDEState
),
2876 VMSTATE_UINT8(status
, IDEState
),
2877 VMSTATE_UINT8(lba48
, IDEState
),
2878 VMSTATE_UINT8(sense_key
, IDEState
),
2879 VMSTATE_UINT8(asc
, IDEState
),
2880 VMSTATE_UINT8_V(cdrom_changed
, IDEState
, 3),
2881 VMSTATE_END_OF_LIST()
2883 .subsections
= (VMStateSubsection
[]) {
2885 .vmsd
= &vmstate_ide_drive_pio_state
,
2886 .needed
= ide_drive_pio_state_needed
,
2893 const VMStateDescription vmstate_ide_bus
= {
2896 .minimum_version_id
= 1,
2897 .minimum_version_id_old
= 1,
2898 .fields
= (VMStateField
[]) {
2899 VMSTATE_UINT8(cmd
, IDEBus
),
2900 VMSTATE_UINT8(unit
, IDEBus
),
2901 VMSTATE_END_OF_LIST()
2905 /***********************************************************/
2906 /* PCI IDE definitions */
2908 static void ide_dma_start(IDEState
*s
, BlockDriverCompletionFunc
*dma_cb
)
2910 BMDMAState
*bm
= s
->bus
->bmdma
;
2914 bm
->dma_cb
= dma_cb
;
2915 bm
->cur_prd_last
= 0;
2916 bm
->cur_prd_addr
= 0;
2917 bm
->cur_prd_len
= 0;
2918 bm
->sector_num
= ide_get_sector(s
);
2919 bm
->nsector
= s
->nsector
;
2920 if (bm
->status
& BM_STATUS_DMAING
) {
2925 static void ide_dma_restart(IDEState
*s
, int is_read
)
2927 BMDMAState
*bm
= s
->bus
->bmdma
;
2928 ide_set_sector(s
, bm
->sector_num
);
2929 s
->io_buffer_index
= 0;
2930 s
->io_buffer_size
= 0;
2931 s
->nsector
= bm
->nsector
;
2932 bm
->cur_addr
= bm
->addr
;
2935 bm
->dma_cb
= ide_read_dma_cb
;
2937 bm
->dma_cb
= ide_write_dma_cb
;
2940 ide_dma_start(s
, bm
->dma_cb
);
2943 void ide_dma_cancel(BMDMAState
*bm
)
2945 if (bm
->status
& BM_STATUS_DMAING
) {
2948 printf("aio_cancel\n");
2950 bdrv_aio_cancel(bm
->aiocb
);
2953 bm
->status
&= ~BM_STATUS_DMAING
;
2954 /* cancel DMA request */
2960 void ide_dma_reset(BMDMAState
*bm
)
2963 printf("ide: dma_reset\n");
2970 bm
->cur_prd_last
= 0;
2971 bm
->cur_prd_addr
= 0;
2972 bm
->cur_prd_len
= 0;