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
)
814 BlockDriverAIOCB
*acb
;
821 acb
= bdrv_aio_flush(s
->bs
, ide_flush_cb
, s
);
823 ide_flush_cb(s
, -EIO
);
827 static inline void cpu_to_ube16(uint8_t *buf
, int val
)
833 static inline void cpu_to_ube32(uint8_t *buf
, unsigned int val
)
841 static inline int ube16_to_cpu(const uint8_t *buf
)
843 return (buf
[0] << 8) | buf
[1];
846 static inline int ube32_to_cpu(const uint8_t *buf
)
848 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
851 static void lba_to_msf(uint8_t *buf
, int lba
)
854 buf
[0] = (lba
/ 75) / 60;
855 buf
[1] = (lba
/ 75) % 60;
859 static void cd_data_to_raw(uint8_t *buf
, int lba
)
863 memset(buf
+ 1, 0xff, 10);
867 lba_to_msf(buf
, lba
);
868 buf
[3] = 0x01; /* mode 1 data */
872 /* XXX: ECC not computed */
876 static int cd_read_sector(BlockDriverState
*bs
, int lba
, uint8_t *buf
,
881 switch(sector_size
) {
883 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
, 4);
886 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
+ 16, 4);
889 cd_data_to_raw(buf
, lba
);
898 void ide_atapi_io_error(IDEState
*s
, int ret
)
900 /* XXX: handle more errors */
901 if (ret
== -ENOMEDIUM
) {
902 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
903 ASC_MEDIUM_NOT_PRESENT
);
905 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
906 ASC_LOGICAL_BLOCK_OOR
);
910 /* The whole ATAPI transfer logic is handled in this function */
911 static void ide_atapi_cmd_reply_end(IDEState
*s
)
913 int byte_count_limit
, size
, ret
;
914 #ifdef DEBUG_IDE_ATAPI
915 printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
916 s
->packet_transfer_size
,
917 s
->elementary_transfer_size
,
920 if (s
->packet_transfer_size
<= 0) {
921 /* end of transfer */
922 ide_transfer_stop(s
);
923 s
->status
= READY_STAT
| SEEK_STAT
;
924 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
926 #ifdef DEBUG_IDE_ATAPI
927 printf("status=0x%x\n", s
->status
);
930 /* see if a new sector must be read */
931 if (s
->lba
!= -1 && s
->io_buffer_index
>= s
->cd_sector_size
) {
932 ret
= cd_read_sector(s
->bs
, s
->lba
, s
->io_buffer
, s
->cd_sector_size
);
934 ide_transfer_stop(s
);
935 ide_atapi_io_error(s
, ret
);
939 s
->io_buffer_index
= 0;
941 if (s
->elementary_transfer_size
> 0) {
942 /* there are some data left to transmit in this elementary
944 size
= s
->cd_sector_size
- s
->io_buffer_index
;
945 if (size
> s
->elementary_transfer_size
)
946 size
= s
->elementary_transfer_size
;
947 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
,
948 size
, ide_atapi_cmd_reply_end
);
949 s
->packet_transfer_size
-= size
;
950 s
->elementary_transfer_size
-= size
;
951 s
->io_buffer_index
+= size
;
953 /* a new transfer is needed */
954 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
;
955 byte_count_limit
= s
->lcyl
| (s
->hcyl
<< 8);
956 #ifdef DEBUG_IDE_ATAPI
957 printf("byte_count_limit=%d\n", byte_count_limit
);
959 if (byte_count_limit
== 0xffff)
961 size
= s
->packet_transfer_size
;
962 if (size
> byte_count_limit
) {
963 /* byte count limit must be even if this case */
964 if (byte_count_limit
& 1)
966 size
= byte_count_limit
;
970 s
->elementary_transfer_size
= size
;
971 /* we cannot transmit more than one sector at a time */
973 if (size
> (s
->cd_sector_size
- s
->io_buffer_index
))
974 size
= (s
->cd_sector_size
- s
->io_buffer_index
);
976 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
,
977 size
, ide_atapi_cmd_reply_end
);
978 s
->packet_transfer_size
-= size
;
979 s
->elementary_transfer_size
-= size
;
980 s
->io_buffer_index
+= size
;
982 #ifdef DEBUG_IDE_ATAPI
983 printf("status=0x%x\n", s
->status
);
989 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
990 static void ide_atapi_cmd_reply(IDEState
*s
, int size
, int max_size
)
994 s
->lba
= -1; /* no sector read */
995 s
->packet_transfer_size
= size
;
996 s
->io_buffer_size
= size
; /* dma: send the reply data as one chunk */
997 s
->elementary_transfer_size
= 0;
998 s
->io_buffer_index
= 0;
1001 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
;
1002 ide_dma_start(s
, ide_atapi_cmd_read_dma_cb
);
1004 s
->status
= READY_STAT
| SEEK_STAT
;
1005 ide_atapi_cmd_reply_end(s
);
1009 /* start a CD-CDROM read command */
1010 static void ide_atapi_cmd_read_pio(IDEState
*s
, int lba
, int nb_sectors
,
1014 s
->packet_transfer_size
= nb_sectors
* sector_size
;
1015 s
->elementary_transfer_size
= 0;
1016 s
->io_buffer_index
= sector_size
;
1017 s
->cd_sector_size
= sector_size
;
1019 s
->status
= READY_STAT
| SEEK_STAT
;
1020 ide_atapi_cmd_reply_end(s
);
1023 /* ATAPI DMA support */
1025 /* XXX: handle read errors */
1026 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
)
1028 BMDMAState
*bm
= opaque
;
1029 IDEState
*s
= bmdma_active_if(bm
);
1033 ide_atapi_io_error(s
, ret
);
1037 if (s
->io_buffer_size
> 0) {
1039 * For a cdrom read sector command (s->lba != -1),
1040 * adjust the lba for the next s->io_buffer_size chunk
1041 * and dma the current chunk.
1042 * For a command != read (s->lba == -1), just transfer
1046 if (s
->cd_sector_size
== 2352) {
1048 cd_data_to_raw(s
->io_buffer
, s
->lba
);
1050 n
= s
->io_buffer_size
>> 11;
1054 s
->packet_transfer_size
-= s
->io_buffer_size
;
1055 if (dma_buf_rw(bm
, 1) == 0)
1059 if (s
->packet_transfer_size
<= 0) {
1060 s
->status
= READY_STAT
| SEEK_STAT
;
1061 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
1062 ide_set_irq(s
->bus
);
1064 bm
->status
&= ~BM_STATUS_DMAING
;
1065 bm
->status
|= BM_STATUS_INT
;
1072 s
->io_buffer_index
= 0;
1073 if (s
->cd_sector_size
== 2352) {
1075 s
->io_buffer_size
= s
->cd_sector_size
;
1078 n
= s
->packet_transfer_size
>> 11;
1079 if (n
> (IDE_DMA_BUF_SECTORS
/ 4))
1080 n
= (IDE_DMA_BUF_SECTORS
/ 4);
1081 s
->io_buffer_size
= n
* 2048;
1085 printf("aio_read_cd: lba=%u n=%d\n", s
->lba
, n
);
1087 bm
->iov
.iov_base
= (void *)(s
->io_buffer
+ data_offset
);
1088 bm
->iov
.iov_len
= n
* 4 * 512;
1089 qemu_iovec_init_external(&bm
->qiov
, &bm
->iov
, 1);
1090 bm
->aiocb
= bdrv_aio_readv(s
->bs
, (int64_t)s
->lba
<< 2, &bm
->qiov
,
1091 n
* 4, ide_atapi_cmd_read_dma_cb
, bm
);
1093 /* Note: media not present is the most likely case */
1094 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1095 ASC_MEDIUM_NOT_PRESENT
);
1100 /* start a CD-CDROM read command with DMA */
1101 /* XXX: test if DMA is available */
1102 static void ide_atapi_cmd_read_dma(IDEState
*s
, int lba
, int nb_sectors
,
1106 s
->packet_transfer_size
= nb_sectors
* sector_size
;
1107 s
->io_buffer_index
= 0;
1108 s
->io_buffer_size
= 0;
1109 s
->cd_sector_size
= sector_size
;
1111 /* XXX: check if BUSY_STAT should be set */
1112 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
1113 ide_dma_start(s
, ide_atapi_cmd_read_dma_cb
);
1116 static void ide_atapi_cmd_read(IDEState
*s
, int lba
, int nb_sectors
,
1119 #ifdef DEBUG_IDE_ATAPI
1120 printf("read %s: LBA=%d nb_sectors=%d\n", s
->atapi_dma
? "dma" : "pio",
1124 ide_atapi_cmd_read_dma(s
, lba
, nb_sectors
, sector_size
);
1126 ide_atapi_cmd_read_pio(s
, lba
, nb_sectors
, sector_size
);
1130 static inline uint8_t ide_atapi_set_profile(uint8_t *buf
, uint8_t *index
,
1133 uint8_t *buf_profile
= buf
+ 12; /* start of profiles */
1135 buf_profile
+= ((*index
) * 4); /* start of indexed profile */
1136 cpu_to_ube16 (buf_profile
, profile
);
1137 buf_profile
[2] = ((buf_profile
[0] == buf
[6]) && (buf_profile
[1] == buf
[7]));
1139 /* each profile adds 4 bytes to the response */
1141 buf
[11] += 4; /* Additional Length */
1146 static int ide_dvd_read_structure(IDEState
*s
, int format
,
1147 const uint8_t *packet
, uint8_t *buf
)
1150 case 0x0: /* Physical format information */
1152 int layer
= packet
[6];
1153 uint64_t total_sectors
;
1156 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1158 bdrv_get_geometry(s
->bs
, &total_sectors
);
1159 total_sectors
>>= 2;
1160 if (total_sectors
== 0)
1161 return -ASC_MEDIUM_NOT_PRESENT
;
1163 buf
[4] = 1; /* DVD-ROM, part version 1 */
1164 buf
[5] = 0xf; /* 120mm disc, minimum rate unspecified */
1165 buf
[6] = 1; /* one layer, read-only (per MMC-2 spec) */
1166 buf
[7] = 0; /* default densities */
1168 /* FIXME: 0x30000 per spec? */
1169 cpu_to_ube32(buf
+ 8, 0); /* start sector */
1170 cpu_to_ube32(buf
+ 12, total_sectors
- 1); /* end sector */
1171 cpu_to_ube32(buf
+ 16, total_sectors
- 1); /* l0 end sector */
1173 /* Size of buffer, not including 2 byte size field */
1174 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
1176 /* 2k data + 4 byte header */
1180 case 0x01: /* DVD copyright information */
1181 buf
[4] = 0; /* no copyright data */
1182 buf
[5] = 0; /* no region restrictions */
1184 /* Size of buffer, not including 2 byte size field */
1185 cpu_to_be16wu((uint16_t *)buf
, 4 + 2);
1187 /* 4 byte header + 4 byte data */
1190 case 0x03: /* BCA information - invalid field for no BCA info */
1191 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1193 case 0x04: /* DVD disc manufacturing information */
1194 /* Size of buffer, not including 2 byte size field */
1195 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
1197 /* 2k data + 4 byte header */
1202 * This lists all the command capabilities above. Add new ones
1203 * in order and update the length and buffer return values.
1206 buf
[4] = 0x00; /* Physical format */
1207 buf
[5] = 0x40; /* Not writable, is readable */
1208 cpu_to_be16wu((uint16_t *)(buf
+ 6), 2048 + 4);
1210 buf
[8] = 0x01; /* Copyright info */
1211 buf
[9] = 0x40; /* Not writable, is readable */
1212 cpu_to_be16wu((uint16_t *)(buf
+ 10), 4 + 4);
1214 buf
[12] = 0x03; /* BCA info */
1215 buf
[13] = 0x40; /* Not writable, is readable */
1216 cpu_to_be16wu((uint16_t *)(buf
+ 14), 188 + 4);
1218 buf
[16] = 0x04; /* Manufacturing info */
1219 buf
[17] = 0x40; /* Not writable, is readable */
1220 cpu_to_be16wu((uint16_t *)(buf
+ 18), 2048 + 4);
1222 /* Size of buffer, not including 2 byte size field */
1223 cpu_to_be16wu((uint16_t *)buf
, 16 + 2);
1225 /* data written + 4 byte header */
1228 default: /* TODO: formats beyond DVD-ROM requires */
1229 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1233 static void ide_atapi_cmd(IDEState
*s
)
1235 const uint8_t *packet
;
1239 packet
= s
->io_buffer
;
1241 #ifdef DEBUG_IDE_ATAPI
1244 printf("ATAPI limit=0x%x packet:", s
->lcyl
| (s
->hcyl
<< 8));
1245 for(i
= 0; i
< ATAPI_PACKET_SIZE
; i
++) {
1246 printf(" %02x", packet
[i
]);
1251 /* If there's a UNIT_ATTENTION condition pending, only
1252 REQUEST_SENSE and INQUIRY commands are allowed to complete. */
1253 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
1254 s
->io_buffer
[0] != GPCMD_REQUEST_SENSE
&&
1255 s
->io_buffer
[0] != GPCMD_INQUIRY
) {
1256 ide_atapi_cmd_check_status(s
);
1259 switch(s
->io_buffer
[0]) {
1260 case GPCMD_TEST_UNIT_READY
:
1261 if (bdrv_is_inserted(s
->bs
) && !s
->cdrom_changed
) {
1262 ide_atapi_cmd_ok(s
);
1264 s
->cdrom_changed
= 0;
1265 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1266 ASC_MEDIUM_NOT_PRESENT
);
1269 case GPCMD_MODE_SENSE_6
:
1270 case GPCMD_MODE_SENSE_10
:
1273 if (packet
[0] == GPCMD_MODE_SENSE_10
)
1274 max_len
= ube16_to_cpu(packet
+ 7);
1276 max_len
= packet
[4];
1277 action
= packet
[2] >> 6;
1278 code
= packet
[2] & 0x3f;
1280 case 0: /* current values */
1282 case GPMODE_R_W_ERROR_PAGE
: /* error recovery */
1283 cpu_to_ube16(&buf
[0], 16 + 6);
1299 ide_atapi_cmd_reply(s
, 16, max_len
);
1301 case GPMODE_AUDIO_CTL_PAGE
:
1302 cpu_to_ube16(&buf
[0], 24 + 6);
1310 /* Fill with CDROM audio volume */
1316 ide_atapi_cmd_reply(s
, 24, max_len
);
1318 case GPMODE_CAPABILITIES_PAGE
:
1319 cpu_to_ube16(&buf
[0], 28 + 6);
1332 /* Claim PLAY_AUDIO capability (0x01) since some Linux
1333 code checks for this to automount media. */
1336 buf
[14] = (1 << 0) | (1 << 3) | (1 << 5);
1337 if (bdrv_is_locked(s
->bs
))
1340 cpu_to_ube16(&buf
[16], 706);
1343 cpu_to_ube16(&buf
[20], 512);
1344 cpu_to_ube16(&buf
[22], 706);
1349 ide_atapi_cmd_reply(s
, 28, max_len
);
1355 case 1: /* changeable values */
1357 case 2: /* default values */
1360 case 3: /* saved values */
1361 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1362 ASC_SAVING_PARAMETERS_NOT_SUPPORTED
);
1367 case GPCMD_REQUEST_SENSE
:
1368 max_len
= packet
[4];
1370 buf
[0] = 0x70 | (1 << 7);
1371 buf
[2] = s
->sense_key
;
1374 if (s
->sense_key
== SENSE_UNIT_ATTENTION
)
1375 s
->sense_key
= SENSE_NONE
;
1376 ide_atapi_cmd_reply(s
, 18, max_len
);
1378 case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
:
1379 if (bdrv_is_inserted(s
->bs
)) {
1380 bdrv_set_locked(s
->bs
, packet
[4] & 1);
1381 ide_atapi_cmd_ok(s
);
1383 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1384 ASC_MEDIUM_NOT_PRESENT
);
1390 int nb_sectors
, lba
;
1392 if (packet
[0] == GPCMD_READ_10
)
1393 nb_sectors
= ube16_to_cpu(packet
+ 7);
1395 nb_sectors
= ube32_to_cpu(packet
+ 6);
1396 lba
= ube32_to_cpu(packet
+ 2);
1397 if (nb_sectors
== 0) {
1398 ide_atapi_cmd_ok(s
);
1401 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
1406 int nb_sectors
, lba
, transfer_request
;
1408 nb_sectors
= (packet
[6] << 16) | (packet
[7] << 8) | packet
[8];
1409 lba
= ube32_to_cpu(packet
+ 2);
1410 if (nb_sectors
== 0) {
1411 ide_atapi_cmd_ok(s
);
1414 transfer_request
= packet
[9];
1415 switch(transfer_request
& 0xf8) {
1418 ide_atapi_cmd_ok(s
);
1422 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
1426 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2352);
1429 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1430 ASC_INV_FIELD_IN_CMD_PACKET
);
1438 uint64_t total_sectors
;
1440 bdrv_get_geometry(s
->bs
, &total_sectors
);
1441 total_sectors
>>= 2;
1442 if (total_sectors
== 0) {
1443 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1444 ASC_MEDIUM_NOT_PRESENT
);
1447 lba
= ube32_to_cpu(packet
+ 2);
1448 if (lba
>= total_sectors
) {
1449 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1450 ASC_LOGICAL_BLOCK_OOR
);
1453 ide_atapi_cmd_ok(s
);
1456 case GPCMD_START_STOP_UNIT
:
1458 int start
, eject
, err
= 0;
1459 start
= packet
[4] & 1;
1460 eject
= (packet
[4] >> 1) & 1;
1463 err
= bdrv_eject(s
->bs
, !start
);
1468 ide_atapi_cmd_ok(s
);
1471 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1472 ASC_MEDIA_REMOVAL_PREVENTED
);
1475 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1476 ASC_MEDIUM_NOT_PRESENT
);
1481 case GPCMD_MECHANISM_STATUS
:
1483 max_len
= ube16_to_cpu(packet
+ 8);
1484 cpu_to_ube16(buf
, 0);
1485 /* no current LBA */
1490 cpu_to_ube16(buf
+ 6, 0);
1491 ide_atapi_cmd_reply(s
, 8, max_len
);
1494 case GPCMD_READ_TOC_PMA_ATIP
:
1496 int format
, msf
, start_track
, len
;
1497 uint64_t total_sectors
;
1499 bdrv_get_geometry(s
->bs
, &total_sectors
);
1500 total_sectors
>>= 2;
1501 if (total_sectors
== 0) {
1502 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1503 ASC_MEDIUM_NOT_PRESENT
);
1506 max_len
= ube16_to_cpu(packet
+ 7);
1507 format
= packet
[9] >> 6;
1508 msf
= (packet
[1] >> 1) & 1;
1509 start_track
= packet
[6];
1512 len
= cdrom_read_toc(total_sectors
, buf
, msf
, start_track
);
1515 ide_atapi_cmd_reply(s
, len
, max_len
);
1518 /* multi session : only a single session defined */
1523 ide_atapi_cmd_reply(s
, 12, max_len
);
1526 len
= cdrom_read_toc_raw(total_sectors
, buf
, msf
, start_track
);
1529 ide_atapi_cmd_reply(s
, len
, max_len
);
1533 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1534 ASC_INV_FIELD_IN_CMD_PACKET
);
1539 case GPCMD_READ_CDVD_CAPACITY
:
1541 uint64_t total_sectors
;
1543 bdrv_get_geometry(s
->bs
, &total_sectors
);
1544 total_sectors
>>= 2;
1545 if (total_sectors
== 0) {
1546 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1547 ASC_MEDIUM_NOT_PRESENT
);
1550 /* NOTE: it is really the number of sectors minus 1 */
1551 cpu_to_ube32(buf
, total_sectors
- 1);
1552 cpu_to_ube32(buf
+ 4, 2048);
1553 ide_atapi_cmd_reply(s
, 8, 8);
1556 case GPCMD_READ_DVD_STRUCTURE
:
1558 int media
= packet
[1];
1559 int format
= packet
[7];
1562 max_len
= ube16_to_cpu(packet
+ 8);
1564 if (format
< 0xff) {
1565 if (media_is_cd(s
)) {
1566 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1567 ASC_INCOMPATIBLE_FORMAT
);
1569 } else if (!media_present(s
)) {
1570 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1571 ASC_INV_FIELD_IN_CMD_PACKET
);
1576 memset(buf
, 0, max_len
> IDE_DMA_BUF_SECTORS
* 512 + 4 ?
1577 IDE_DMA_BUF_SECTORS
* 512 + 4 : max_len
);
1583 ret
= ide_dvd_read_structure(s
, format
, packet
, buf
);
1586 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
, -ret
);
1588 ide_atapi_cmd_reply(s
, ret
, max_len
);
1592 /* TODO: BD support, fall through for now */
1594 /* Generic disk structures */
1595 case 0x80: /* TODO: AACS volume identifier */
1596 case 0x81: /* TODO: AACS media serial number */
1597 case 0x82: /* TODO: AACS media identifier */
1598 case 0x83: /* TODO: AACS media key block */
1599 case 0x90: /* TODO: List of recognized format layers */
1600 case 0xc0: /* TODO: Write protection status */
1602 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1603 ASC_INV_FIELD_IN_CMD_PACKET
);
1608 case GPCMD_SET_SPEED
:
1609 ide_atapi_cmd_ok(s
);
1612 max_len
= packet
[4];
1613 buf
[0] = 0x05; /* CD-ROM */
1614 buf
[1] = 0x80; /* removable */
1615 buf
[2] = 0x00; /* ISO */
1616 buf
[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1617 buf
[4] = 31; /* additional length */
1618 buf
[5] = 0; /* reserved */
1619 buf
[6] = 0; /* reserved */
1620 buf
[7] = 0; /* reserved */
1621 padstr8(buf
+ 8, 8, "QEMU");
1622 padstr8(buf
+ 16, 16, "QEMU DVD-ROM");
1623 padstr8(buf
+ 32, 4, s
->version
);
1624 ide_atapi_cmd_reply(s
, 36, max_len
);
1626 case GPCMD_GET_CONFIGURATION
:
1631 /* only feature 0 is supported */
1632 if (packet
[2] != 0 || packet
[3] != 0) {
1633 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1634 ASC_INV_FIELD_IN_CMD_PACKET
);
1638 /* XXX: could result in alignment problems in some architectures */
1639 max_len
= ube16_to_cpu(packet
+ 7);
1642 * XXX: avoid overflow for io_buffer if max_len is bigger than
1643 * the size of that buffer (dimensioned to max number of
1644 * sectors to transfer at once)
1646 * Only a problem if the feature/profiles grow.
1648 if (max_len
> 512) /* XXX: assume 1 sector */
1651 memset(buf
, 0, max_len
);
1653 * the number of sectors from the media tells us which profile
1654 * to use as current. 0 means there is no media
1656 if (media_is_dvd(s
))
1657 cpu_to_ube16(buf
+ 6, MMC_PROFILE_DVD_ROM
);
1658 else if (media_is_cd(s
))
1659 cpu_to_ube16(buf
+ 6, MMC_PROFILE_CD_ROM
);
1661 buf
[10] = 0x02 | 0x01; /* persistent and current */
1662 len
= 12; /* headers: 8 + 4 */
1663 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_DVD_ROM
);
1664 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_CD_ROM
);
1665 cpu_to_ube32(buf
, len
- 4); /* data length */
1667 ide_atapi_cmd_reply(s
, len
, max_len
);
1670 case GPCMD_GET_EVENT_STATUS_NOTIFICATION
:
1671 max_len
= ube16_to_cpu(packet
+ 7);
1673 if (packet
[1] & 0x01) { /* polling */
1674 /* We don't support any event class (yet). */
1675 cpu_to_ube16(buf
, 0x00); /* No event descriptor returned */
1676 buf
[2] = 0x80; /* No Event Available (NEA) */
1677 buf
[3] = 0x00; /* Empty supported event classes */
1678 ide_atapi_cmd_reply(s
, 4, max_len
);
1679 } else { /* asynchronous mode */
1680 /* Only polling is supported, asynchronous mode is not. */
1681 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1682 ASC_INV_FIELD_IN_CMD_PACKET
);
1686 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1687 ASC_ILLEGAL_OPCODE
);
1692 static void ide_cfata_metadata_inquiry(IDEState
*s
)
1697 p
= (uint16_t *) s
->io_buffer
;
1698 memset(p
, 0, 0x200);
1699 spd
= ((s
->mdata_size
- 1) >> 9) + 1;
1701 put_le16(p
+ 0, 0x0001); /* Data format revision */
1702 put_le16(p
+ 1, 0x0000); /* Media property: silicon */
1703 put_le16(p
+ 2, s
->media_changed
); /* Media status */
1704 put_le16(p
+ 3, s
->mdata_size
& 0xffff); /* Capacity in bytes (low) */
1705 put_le16(p
+ 4, s
->mdata_size
>> 16); /* Capacity in bytes (high) */
1706 put_le16(p
+ 5, spd
& 0xffff); /* Sectors per device (low) */
1707 put_le16(p
+ 6, spd
>> 16); /* Sectors per device (high) */
1710 static void ide_cfata_metadata_read(IDEState
*s
)
1714 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
1715 s
->status
= ERR_STAT
;
1716 s
->error
= ABRT_ERR
;
1720 p
= (uint16_t *) s
->io_buffer
;
1721 memset(p
, 0, 0x200);
1723 put_le16(p
+ 0, s
->media_changed
); /* Media status */
1724 memcpy(p
+ 1, s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1725 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1726 s
->nsector
<< 9), 0x200 - 2));
1729 static void ide_cfata_metadata_write(IDEState
*s
)
1731 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
1732 s
->status
= ERR_STAT
;
1733 s
->error
= ABRT_ERR
;
1737 s
->media_changed
= 0;
1739 memcpy(s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1741 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1742 s
->nsector
<< 9), 0x200 - 2));
1745 /* called when the inserted state of the media has changed */
1746 static void cdrom_change_cb(void *opaque
)
1748 IDEState
*s
= opaque
;
1749 uint64_t nb_sectors
;
1751 bdrv_get_geometry(s
->bs
, &nb_sectors
);
1752 s
->nb_sectors
= nb_sectors
;
1754 s
->sense_key
= SENSE_UNIT_ATTENTION
;
1755 s
->asc
= ASC_MEDIUM_MAY_HAVE_CHANGED
;
1756 s
->cdrom_changed
= 1;
1757 ide_set_irq(s
->bus
);
1760 static void ide_cmd_lba48_transform(IDEState
*s
, int lba48
)
1764 /* handle the 'magic' 0 nsector count conversion here. to avoid
1765 * fiddling with the rest of the read logic, we just store the
1766 * full sector count in ->nsector and ignore ->hob_nsector from now
1772 if (!s
->nsector
&& !s
->hob_nsector
)
1775 int lo
= s
->nsector
;
1776 int hi
= s
->hob_nsector
;
1778 s
->nsector
= (hi
<< 8) | lo
;
1783 static void ide_clear_hob(IDEBus
*bus
)
1785 /* any write clears HOB high bit of device control register */
1786 bus
->ifs
[0].select
&= ~(1 << 7);
1787 bus
->ifs
[1].select
&= ~(1 << 7);
1790 void ide_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
1792 IDEBus
*bus
= opaque
;
1798 printf("IDE: write addr=0x%x val=0x%02x\n", addr
, val
);
1803 /* ignore writes to command block while busy with previous command */
1804 if (addr
!= 7 && (idebus_active_if(bus
)->status
& (BUSY_STAT
|DRQ_STAT
)))
1812 /* NOTE: data is written to the two drives */
1813 bus
->ifs
[0].hob_feature
= bus
->ifs
[0].feature
;
1814 bus
->ifs
[1].hob_feature
= bus
->ifs
[1].feature
;
1815 bus
->ifs
[0].feature
= val
;
1816 bus
->ifs
[1].feature
= val
;
1820 bus
->ifs
[0].hob_nsector
= bus
->ifs
[0].nsector
;
1821 bus
->ifs
[1].hob_nsector
= bus
->ifs
[1].nsector
;
1822 bus
->ifs
[0].nsector
= val
;
1823 bus
->ifs
[1].nsector
= val
;
1827 bus
->ifs
[0].hob_sector
= bus
->ifs
[0].sector
;
1828 bus
->ifs
[1].hob_sector
= bus
->ifs
[1].sector
;
1829 bus
->ifs
[0].sector
= val
;
1830 bus
->ifs
[1].sector
= val
;
1834 bus
->ifs
[0].hob_lcyl
= bus
->ifs
[0].lcyl
;
1835 bus
->ifs
[1].hob_lcyl
= bus
->ifs
[1].lcyl
;
1836 bus
->ifs
[0].lcyl
= val
;
1837 bus
->ifs
[1].lcyl
= val
;
1841 bus
->ifs
[0].hob_hcyl
= bus
->ifs
[0].hcyl
;
1842 bus
->ifs
[1].hob_hcyl
= bus
->ifs
[1].hcyl
;
1843 bus
->ifs
[0].hcyl
= val
;
1844 bus
->ifs
[1].hcyl
= val
;
1847 /* FIXME: HOB readback uses bit 7 */
1848 bus
->ifs
[0].select
= (val
& ~0x10) | 0xa0;
1849 bus
->ifs
[1].select
= (val
| 0x10) | 0xa0;
1851 bus
->unit
= (val
>> 4) & 1;
1856 #if defined(DEBUG_IDE)
1857 printf("ide: CMD=%02x\n", val
);
1859 s
= idebus_active_if(bus
);
1860 /* ignore commands to non existant slave */
1861 if (s
!= bus
->ifs
&& !s
->bs
)
1864 /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
1865 if ((s
->status
& (BUSY_STAT
|DRQ_STAT
)) && val
!= WIN_DEVICE_RESET
)
1870 if (s
->bs
&& s
->drive_kind
!= IDE_CD
) {
1871 if (s
->drive_kind
!= IDE_CFATA
)
1874 ide_cfata_identify(s
);
1875 s
->status
= READY_STAT
| SEEK_STAT
;
1876 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
1878 if (s
->drive_kind
== IDE_CD
) {
1879 ide_set_signature(s
);
1881 ide_abort_command(s
);
1883 ide_set_irq(s
->bus
);
1888 s
->status
= READY_STAT
| SEEK_STAT
;
1889 ide_set_irq(s
->bus
);
1892 if (s
->drive_kind
== IDE_CFATA
&& s
->nsector
== 0) {
1893 /* Disable Read and Write Multiple */
1894 s
->mult_sectors
= 0;
1895 s
->status
= READY_STAT
| SEEK_STAT
;
1896 } else if ((s
->nsector
& 0xff) != 0 &&
1897 ((s
->nsector
& 0xff) > MAX_MULT_SECTORS
||
1898 (s
->nsector
& (s
->nsector
- 1)) != 0)) {
1899 ide_abort_command(s
);
1901 s
->mult_sectors
= s
->nsector
& 0xff;
1902 s
->status
= READY_STAT
| SEEK_STAT
;
1904 ide_set_irq(s
->bus
);
1906 case WIN_VERIFY_EXT
:
1909 case WIN_VERIFY_ONCE
:
1910 /* do sector number check ? */
1911 ide_cmd_lba48_transform(s
, lba48
);
1912 s
->status
= READY_STAT
| SEEK_STAT
;
1913 ide_set_irq(s
->bus
);
1921 ide_cmd_lba48_transform(s
, lba48
);
1922 s
->req_nb_sectors
= 1;
1928 case WIN_WRITE_ONCE
:
1929 case CFA_WRITE_SECT_WO_ERASE
:
1930 case WIN_WRITE_VERIFY
:
1931 ide_cmd_lba48_transform(s
, lba48
);
1933 s
->status
= SEEK_STAT
| READY_STAT
;
1934 s
->req_nb_sectors
= 1;
1935 ide_transfer_start(s
, s
->io_buffer
, 512, ide_sector_write
);
1936 s
->media_changed
= 1;
1938 case WIN_MULTREAD_EXT
:
1941 if (!s
->mult_sectors
)
1943 ide_cmd_lba48_transform(s
, lba48
);
1944 s
->req_nb_sectors
= s
->mult_sectors
;
1947 case WIN_MULTWRITE_EXT
:
1950 case CFA_WRITE_MULTI_WO_ERASE
:
1951 if (!s
->mult_sectors
)
1953 ide_cmd_lba48_transform(s
, lba48
);
1955 s
->status
= SEEK_STAT
| READY_STAT
;
1956 s
->req_nb_sectors
= s
->mult_sectors
;
1958 if (n
> s
->req_nb_sectors
)
1959 n
= s
->req_nb_sectors
;
1960 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_write
);
1961 s
->media_changed
= 1;
1963 case WIN_READDMA_EXT
:
1966 case WIN_READDMA_ONCE
:
1969 ide_cmd_lba48_transform(s
, lba48
);
1970 ide_sector_read_dma(s
);
1972 case WIN_WRITEDMA_EXT
:
1975 case WIN_WRITEDMA_ONCE
:
1978 ide_cmd_lba48_transform(s
, lba48
);
1979 ide_sector_write_dma(s
);
1980 s
->media_changed
= 1;
1982 case WIN_READ_NATIVE_MAX_EXT
:
1984 case WIN_READ_NATIVE_MAX
:
1985 ide_cmd_lba48_transform(s
, lba48
);
1986 ide_set_sector(s
, s
->nb_sectors
- 1);
1987 s
->status
= READY_STAT
| SEEK_STAT
;
1988 ide_set_irq(s
->bus
);
1990 case WIN_CHECKPOWERMODE1
:
1991 case WIN_CHECKPOWERMODE2
:
1992 s
->nsector
= 0xff; /* device active or idle */
1993 s
->status
= READY_STAT
| SEEK_STAT
;
1994 ide_set_irq(s
->bus
);
1996 case WIN_SETFEATURES
:
1999 /* XXX: valid for CDROM ? */
2000 switch(s
->feature
) {
2001 case 0xcc: /* reverting to power-on defaults enable */
2002 case 0x66: /* reverting to power-on defaults disable */
2003 case 0x02: /* write cache enable */
2004 case 0x82: /* write cache disable */
2005 case 0xaa: /* read look-ahead enable */
2006 case 0x55: /* read look-ahead disable */
2007 case 0x05: /* set advanced power management mode */
2008 case 0x85: /* disable advanced power management mode */
2009 case 0x69: /* NOP */
2010 case 0x67: /* NOP */
2011 case 0x96: /* NOP */
2012 case 0x9a: /* NOP */
2013 case 0x42: /* enable Automatic Acoustic Mode */
2014 case 0xc2: /* disable Automatic Acoustic Mode */
2015 s
->status
= READY_STAT
| SEEK_STAT
;
2016 ide_set_irq(s
->bus
);
2018 case 0x03: { /* set transfer mode */
2019 uint8_t val
= s
->nsector
& 0x07;
2020 uint16_t *identify_data
= (uint16_t *)s
->identify_data
;
2022 switch (s
->nsector
>> 3) {
2023 case 0x00: /* pio default */
2024 case 0x01: /* pio mode */
2025 put_le16(identify_data
+ 62,0x07);
2026 put_le16(identify_data
+ 63,0x07);
2027 put_le16(identify_data
+ 88,0x3f);
2029 case 0x02: /* sigle word dma mode*/
2030 put_le16(identify_data
+ 62,0x07 | (1 << (val
+ 8)));
2031 put_le16(identify_data
+ 63,0x07);
2032 put_le16(identify_data
+ 88,0x3f);
2034 case 0x04: /* mdma mode */
2035 put_le16(identify_data
+ 62,0x07);
2036 put_le16(identify_data
+ 63,0x07 | (1 << (val
+ 8)));
2037 put_le16(identify_data
+ 88,0x3f);
2039 case 0x08: /* udma mode */
2040 put_le16(identify_data
+ 62,0x07);
2041 put_le16(identify_data
+ 63,0x07);
2042 put_le16(identify_data
+ 88,0x3f | (1 << (val
+ 8)));
2047 s
->status
= READY_STAT
| SEEK_STAT
;
2048 ide_set_irq(s
->bus
);
2055 case WIN_FLUSH_CACHE
:
2056 case WIN_FLUSH_CACHE_EXT
:
2061 case WIN_STANDBYNOW1
:
2062 case WIN_STANDBYNOW2
:
2063 case WIN_IDLEIMMEDIATE
:
2064 case CFA_IDLEIMMEDIATE
:
2069 s
->status
= READY_STAT
;
2070 ide_set_irq(s
->bus
);
2073 if(s
->drive_kind
== IDE_CD
)
2075 /* XXX: Check that seek is within bounds */
2076 s
->status
= READY_STAT
| SEEK_STAT
;
2077 ide_set_irq(s
->bus
);
2079 /* ATAPI commands */
2081 if (s
->drive_kind
== IDE_CD
) {
2082 ide_atapi_identify(s
);
2083 s
->status
= READY_STAT
| SEEK_STAT
;
2084 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
2086 ide_abort_command(s
);
2088 ide_set_irq(s
->bus
);
2091 ide_set_signature(s
);
2092 if (s
->drive_kind
== IDE_CD
)
2093 s
->status
= 0; /* ATAPI spec (v6) section 9.10 defines packet
2094 * devices to return a clear status register
2095 * with READY_STAT *not* set. */
2097 s
->status
= READY_STAT
| SEEK_STAT
;
2098 s
->error
= 0x01; /* Device 0 passed, Device 1 passed or not
2101 ide_set_irq(s
->bus
);
2104 if (s
->drive_kind
!= IDE_CD
)
2106 ide_set_signature(s
);
2107 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2111 if (s
->drive_kind
!= IDE_CD
)
2113 /* overlapping commands not supported */
2114 if (s
->feature
& 0x02)
2116 s
->status
= READY_STAT
| SEEK_STAT
;
2117 s
->atapi_dma
= s
->feature
& 1;
2119 ide_transfer_start(s
, s
->io_buffer
, ATAPI_PACKET_SIZE
,
2122 /* CF-ATA commands */
2123 case CFA_REQ_EXT_ERROR_CODE
:
2124 if (s
->drive_kind
!= IDE_CFATA
)
2126 s
->error
= 0x09; /* miscellaneous error */
2127 s
->status
= READY_STAT
| SEEK_STAT
;
2128 ide_set_irq(s
->bus
);
2130 case CFA_ERASE_SECTORS
:
2131 case CFA_WEAR_LEVEL
:
2132 if (s
->drive_kind
!= IDE_CFATA
)
2134 if (val
== CFA_WEAR_LEVEL
)
2136 if (val
== CFA_ERASE_SECTORS
)
2137 s
->media_changed
= 1;
2139 s
->status
= READY_STAT
| SEEK_STAT
;
2140 ide_set_irq(s
->bus
);
2142 case CFA_TRANSLATE_SECTOR
:
2143 if (s
->drive_kind
!= IDE_CFATA
)
2146 s
->status
= READY_STAT
| SEEK_STAT
;
2147 memset(s
->io_buffer
, 0, 0x200);
2148 s
->io_buffer
[0x00] = s
->hcyl
; /* Cyl MSB */
2149 s
->io_buffer
[0x01] = s
->lcyl
; /* Cyl LSB */
2150 s
->io_buffer
[0x02] = s
->select
; /* Head */
2151 s
->io_buffer
[0x03] = s
->sector
; /* Sector */
2152 s
->io_buffer
[0x04] = ide_get_sector(s
) >> 16; /* LBA MSB */
2153 s
->io_buffer
[0x05] = ide_get_sector(s
) >> 8; /* LBA */
2154 s
->io_buffer
[0x06] = ide_get_sector(s
) >> 0; /* LBA LSB */
2155 s
->io_buffer
[0x13] = 0x00; /* Erase flag */
2156 s
->io_buffer
[0x18] = 0x00; /* Hot count */
2157 s
->io_buffer
[0x19] = 0x00; /* Hot count */
2158 s
->io_buffer
[0x1a] = 0x01; /* Hot count */
2159 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2160 ide_set_irq(s
->bus
);
2162 case CFA_ACCESS_METADATA_STORAGE
:
2163 if (s
->drive_kind
!= IDE_CFATA
)
2165 switch (s
->feature
) {
2166 case 0x02: /* Inquiry Metadata Storage */
2167 ide_cfata_metadata_inquiry(s
);
2169 case 0x03: /* Read Metadata Storage */
2170 ide_cfata_metadata_read(s
);
2172 case 0x04: /* Write Metadata Storage */
2173 ide_cfata_metadata_write(s
);
2178 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2179 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2180 ide_set_irq(s
->bus
);
2182 case IBM_SENSE_CONDITION
:
2183 if (s
->drive_kind
!= IDE_CFATA
)
2185 switch (s
->feature
) {
2186 case 0x01: /* sense temperature in device */
2187 s
->nsector
= 0x50; /* +20 C */
2192 s
->status
= READY_STAT
| SEEK_STAT
;
2193 ide_set_irq(s
->bus
);
2197 if (s
->drive_kind
== IDE_CD
)
2199 if (s
->hcyl
!= 0xc2 || s
->lcyl
!= 0x4f)
2201 if (!s
->smart_enabled
&& s
->feature
!= SMART_ENABLE
)
2203 switch (s
->feature
) {
2205 s
->smart_enabled
= 0;
2206 s
->status
= READY_STAT
| SEEK_STAT
;
2207 ide_set_irq(s
->bus
);
2210 s
->smart_enabled
= 1;
2211 s
->status
= READY_STAT
| SEEK_STAT
;
2212 ide_set_irq(s
->bus
);
2214 case SMART_ATTR_AUTOSAVE
:
2215 switch (s
->sector
) {
2217 s
->smart_autosave
= 0;
2220 s
->smart_autosave
= 1;
2225 s
->status
= READY_STAT
| SEEK_STAT
;
2226 ide_set_irq(s
->bus
);
2229 if (!s
->smart_errors
) {
2236 s
->status
= READY_STAT
| SEEK_STAT
;
2237 ide_set_irq(s
->bus
);
2239 case SMART_READ_THRESH
:
2240 memset(s
->io_buffer
, 0, 0x200);
2241 s
->io_buffer
[0] = 0x01; /* smart struct version */
2242 for (n
=0; n
<30; n
++) {
2243 if (smart_attributes
[n
][0] == 0)
2245 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
2246 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][4];
2248 for (n
=0; n
<511; n
++) /* checksum */
2249 s
->io_buffer
[511] += s
->io_buffer
[n
];
2250 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2251 s
->status
= READY_STAT
| SEEK_STAT
;
2252 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2253 ide_set_irq(s
->bus
);
2255 case SMART_READ_DATA
:
2256 memset(s
->io_buffer
, 0, 0x200);
2257 s
->io_buffer
[0] = 0x01; /* smart struct version */
2258 for (n
=0; n
<30; n
++) {
2259 if (smart_attributes
[n
][0] == 0)
2261 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
2262 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][1];
2263 s
->io_buffer
[2+3+(n
*12)] = smart_attributes
[n
][2];
2264 s
->io_buffer
[2+4+(n
*12)] = smart_attributes
[n
][3];
2266 s
->io_buffer
[362] = 0x02 | (s
->smart_autosave
?0x80:0x00);
2267 if (s
->smart_selftest_count
== 0) {
2268 s
->io_buffer
[363] = 0;
2271 s
->smart_selftest_data
[3 +
2272 (s
->smart_selftest_count
- 1) *
2275 s
->io_buffer
[364] = 0x20;
2276 s
->io_buffer
[365] = 0x01;
2277 /* offline data collection capacity: execute + self-test*/
2278 s
->io_buffer
[367] = (1<<4 | 1<<3 | 1);
2279 s
->io_buffer
[368] = 0x03; /* smart capability (1) */
2280 s
->io_buffer
[369] = 0x00; /* smart capability (2) */
2281 s
->io_buffer
[370] = 0x01; /* error logging supported */
2282 s
->io_buffer
[372] = 0x02; /* minutes for poll short test */
2283 s
->io_buffer
[373] = 0x36; /* minutes for poll ext test */
2284 s
->io_buffer
[374] = 0x01; /* minutes for poll conveyance */
2286 for (n
=0; n
<511; n
++)
2287 s
->io_buffer
[511] += s
->io_buffer
[n
];
2288 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2289 s
->status
= READY_STAT
| SEEK_STAT
;
2290 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2291 ide_set_irq(s
->bus
);
2293 case SMART_READ_LOG
:
2294 switch (s
->sector
) {
2295 case 0x01: /* summary smart error log */
2296 memset(s
->io_buffer
, 0, 0x200);
2297 s
->io_buffer
[0] = 0x01;
2298 s
->io_buffer
[1] = 0x00; /* no error entries */
2299 s
->io_buffer
[452] = s
->smart_errors
& 0xff;
2300 s
->io_buffer
[453] = (s
->smart_errors
& 0xff00) >> 8;
2302 for (n
=0; n
<511; n
++)
2303 s
->io_buffer
[511] += s
->io_buffer
[n
];
2304 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2306 case 0x06: /* smart self test log */
2307 memset(s
->io_buffer
, 0, 0x200);
2308 s
->io_buffer
[0] = 0x01;
2309 if (s
->smart_selftest_count
== 0) {
2310 s
->io_buffer
[508] = 0;
2312 s
->io_buffer
[508] = s
->smart_selftest_count
;
2313 for (n
=2; n
<506; n
++)
2314 s
->io_buffer
[n
] = s
->smart_selftest_data
[n
];
2316 for (n
=0; n
<511; n
++)
2317 s
->io_buffer
[511] += s
->io_buffer
[n
];
2318 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2323 s
->status
= READY_STAT
| SEEK_STAT
;
2324 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2325 ide_set_irq(s
->bus
);
2327 case SMART_EXECUTE_OFFLINE
:
2328 switch (s
->sector
) {
2329 case 0: /* off-line routine */
2330 case 1: /* short self test */
2331 case 2: /* extended self test */
2332 s
->smart_selftest_count
++;
2333 if(s
->smart_selftest_count
> 21)
2334 s
->smart_selftest_count
= 0;
2335 n
= 2 + (s
->smart_selftest_count
- 1) * 24;
2336 s
->smart_selftest_data
[n
] = s
->sector
;
2337 s
->smart_selftest_data
[n
+1] = 0x00; /* OK and finished */
2338 s
->smart_selftest_data
[n
+2] = 0x34; /* hour count lsb */
2339 s
->smart_selftest_data
[n
+3] = 0x12; /* hour count msb */
2340 s
->status
= READY_STAT
| SEEK_STAT
;
2341 ide_set_irq(s
->bus
);
2353 ide_abort_command(s
);
2354 ide_set_irq(s
->bus
);
2360 uint32_t ide_ioport_read(void *opaque
, uint32_t addr1
)
2362 IDEBus
*bus
= opaque
;
2363 IDEState
*s
= idebus_active_if(bus
);
2368 /* FIXME: HOB readback uses bit 7, but it's always set right now */
2369 //hob = s->select & (1 << 7);
2376 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2377 (s
!= bus
->ifs
&& !s
->bs
))
2382 ret
= s
->hob_feature
;
2385 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2388 ret
= s
->nsector
& 0xff;
2390 ret
= s
->hob_nsector
;
2393 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2398 ret
= s
->hob_sector
;
2401 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2409 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2417 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2424 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2425 (s
!= bus
->ifs
&& !s
->bs
))
2429 qemu_irq_lower(bus
->irq
);
2433 printf("ide: read addr=0x%x val=%02x\n", addr1
, ret
);
2438 uint32_t ide_status_read(void *opaque
, uint32_t addr
)
2440 IDEBus
*bus
= opaque
;
2441 IDEState
*s
= idebus_active_if(bus
);
2444 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2445 (s
!= bus
->ifs
&& !s
->bs
))
2450 printf("ide: read status addr=0x%x val=%02x\n", addr
, ret
);
2455 void ide_cmd_write(void *opaque
, uint32_t addr
, uint32_t val
)
2457 IDEBus
*bus
= opaque
;
2462 printf("ide: write control addr=0x%x val=%02x\n", addr
, val
);
2464 /* common for both drives */
2465 if (!(bus
->cmd
& IDE_CMD_RESET
) &&
2466 (val
& IDE_CMD_RESET
)) {
2467 /* reset low to high */
2468 for(i
= 0;i
< 2; i
++) {
2470 s
->status
= BUSY_STAT
| SEEK_STAT
;
2473 } else if ((bus
->cmd
& IDE_CMD_RESET
) &&
2474 !(val
& IDE_CMD_RESET
)) {
2476 for(i
= 0;i
< 2; i
++) {
2478 if (s
->drive_kind
== IDE_CD
)
2479 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2481 s
->status
= READY_STAT
| SEEK_STAT
;
2482 ide_set_signature(s
);
2489 void ide_data_writew(void *opaque
, uint32_t addr
, uint32_t val
)
2491 IDEBus
*bus
= opaque
;
2492 IDEState
*s
= idebus_active_if(bus
);
2495 /* PIO data access allowed only when DRQ bit is set */
2496 if (!(s
->status
& DRQ_STAT
))
2500 *(uint16_t *)p
= le16_to_cpu(val
);
2503 if (p
>= s
->data_end
)
2504 s
->end_transfer_func(s
);
2507 uint32_t ide_data_readw(void *opaque
, uint32_t addr
)
2509 IDEBus
*bus
= opaque
;
2510 IDEState
*s
= idebus_active_if(bus
);
2514 /* PIO data access allowed only when DRQ bit is set */
2515 if (!(s
->status
& DRQ_STAT
))
2519 ret
= cpu_to_le16(*(uint16_t *)p
);
2522 if (p
>= s
->data_end
)
2523 s
->end_transfer_func(s
);
2527 void ide_data_writel(void *opaque
, uint32_t addr
, uint32_t val
)
2529 IDEBus
*bus
= opaque
;
2530 IDEState
*s
= idebus_active_if(bus
);
2533 /* PIO data access allowed only when DRQ bit is set */
2534 if (!(s
->status
& DRQ_STAT
))
2538 *(uint32_t *)p
= le32_to_cpu(val
);
2541 if (p
>= s
->data_end
)
2542 s
->end_transfer_func(s
);
2545 uint32_t ide_data_readl(void *opaque
, uint32_t addr
)
2547 IDEBus
*bus
= opaque
;
2548 IDEState
*s
= idebus_active_if(bus
);
2552 /* PIO data access allowed only when DRQ bit is set */
2553 if (!(s
->status
& DRQ_STAT
))
2557 ret
= cpu_to_le32(*(uint32_t *)p
);
2560 if (p
>= s
->data_end
)
2561 s
->end_transfer_func(s
);
2565 static void ide_dummy_transfer_stop(IDEState
*s
)
2567 s
->data_ptr
= s
->io_buffer
;
2568 s
->data_end
= s
->io_buffer
;
2569 s
->io_buffer
[0] = 0xff;
2570 s
->io_buffer
[1] = 0xff;
2571 s
->io_buffer
[2] = 0xff;
2572 s
->io_buffer
[3] = 0xff;
2575 static void ide_reset(IDEState
*s
)
2578 printf("ide: reset\n");
2580 if (s
->drive_kind
== IDE_CFATA
)
2581 s
->mult_sectors
= 0;
2583 s
->mult_sectors
= MAX_MULT_SECTORS
;
2600 s
->status
= READY_STAT
| SEEK_STAT
;
2604 /* ATAPI specific */
2607 s
->cdrom_changed
= 0;
2608 s
->packet_transfer_size
= 0;
2609 s
->elementary_transfer_size
= 0;
2610 s
->io_buffer_index
= 0;
2611 s
->cd_sector_size
= 0;
2614 s
->io_buffer_size
= 0;
2615 s
->req_nb_sectors
= 0;
2617 ide_set_signature(s
);
2618 /* init the transfer handler so that 0xffff is returned on data
2620 s
->end_transfer_func
= ide_dummy_transfer_stop
;
2621 ide_dummy_transfer_stop(s
);
2622 s
->media_changed
= 0;
2625 void ide_bus_reset(IDEBus
*bus
)
2629 ide_reset(&bus
->ifs
[0]);
2630 ide_reset(&bus
->ifs
[1]);
2634 int ide_init_drive(IDEState
*s
, BlockDriverState
*bs
,
2635 const char *version
, const char *serial
)
2637 int cylinders
, heads
, secs
;
2638 uint64_t nb_sectors
;
2641 bdrv_get_geometry(bs
, &nb_sectors
);
2642 bdrv_guess_geometry(bs
, &cylinders
, &heads
, &secs
);
2643 if (cylinders
< 1 || cylinders
> 16383) {
2644 error_report("cyls must be between 1 and 16383");
2647 if (heads
< 1 || heads
> 16) {
2648 error_report("heads must be between 1 and 16");
2651 if (secs
< 1 || secs
> 63) {
2652 error_report("secs must be between 1 and 63");
2655 s
->cylinders
= cylinders
;
2658 s
->nb_sectors
= nb_sectors
;
2659 /* The SMART values should be preserved across power cycles
2661 s
->smart_enabled
= 1;
2662 s
->smart_autosave
= 1;
2663 s
->smart_errors
= 0;
2664 s
->smart_selftest_count
= 0;
2665 if (bdrv_get_type_hint(bs
) == BDRV_TYPE_CDROM
) {
2666 s
->drive_kind
= IDE_CD
;
2667 bdrv_set_change_cb(bs
, cdrom_change_cb
, s
);
2668 bs
->buffer_alignment
= 2048;
2670 if (!bdrv_is_inserted(s
->bs
)) {
2671 error_report("Device needs media, but drive is empty");
2674 if (bdrv_is_read_only(bs
)) {
2675 error_report("Can't use a read-only drive");
2680 strncpy(s
->drive_serial_str
, serial
, sizeof(s
->drive_serial_str
));
2682 snprintf(s
->drive_serial_str
, sizeof(s
->drive_serial_str
),
2683 "QM%05d", s
->drive_serial
);
2686 pstrcpy(s
->version
, sizeof(s
->version
), version
);
2688 pstrcpy(s
->version
, sizeof(s
->version
), QEMU_VERSION
);
2691 bdrv_set_removable(bs
, s
->drive_kind
== IDE_CD
);
2695 static void ide_init1(IDEBus
*bus
, int unit
)
2697 static int drive_serial
= 1;
2698 IDEState
*s
= &bus
->ifs
[unit
];
2702 s
->drive_serial
= drive_serial
++;
2703 /* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
2704 s
->io_buffer
= qemu_memalign(2048, IDE_DMA_BUF_SECTORS
*512 + 4);
2705 s
->io_buffer_total_len
= IDE_DMA_BUF_SECTORS
*512 + 4;
2706 s
->smart_selftest_data
= qemu_blockalign(s
->bs
, 512);
2707 s
->sector_write_timer
= qemu_new_timer(vm_clock
,
2708 ide_sector_write_timer_cb
, s
);
2711 void ide_init2(IDEBus
*bus
, qemu_irq irq
)
2715 for(i
= 0; i
< 2; i
++) {
2717 ide_reset(&bus
->ifs
[i
]);
2722 /* TODO convert users to qdev and remove */
2723 void ide_init2_with_non_qdev_drives(IDEBus
*bus
, DriveInfo
*hd0
,
2724 DriveInfo
*hd1
, qemu_irq irq
)
2729 for(i
= 0; i
< 2; i
++) {
2730 dinfo
= i
== 0 ? hd0
: hd1
;
2733 if (ide_init_drive(&bus
->ifs
[i
], dinfo
->bdrv
, NULL
,
2734 *dinfo
->serial
? dinfo
->serial
: NULL
) < 0) {
2735 error_report("Can't set up IDE drive %s", dinfo
->id
);
2739 ide_reset(&bus
->ifs
[i
]);
2745 void ide_init_ioport(IDEBus
*bus
, int iobase
, int iobase2
)
2747 register_ioport_write(iobase
, 8, 1, ide_ioport_write
, bus
);
2748 register_ioport_read(iobase
, 8, 1, ide_ioport_read
, bus
);
2750 register_ioport_read(iobase2
, 1, 1, ide_status_read
, bus
);
2751 register_ioport_write(iobase2
, 1, 1, ide_cmd_write
, bus
);
2755 register_ioport_write(iobase
, 2, 2, ide_data_writew
, bus
);
2756 register_ioport_read(iobase
, 2, 2, ide_data_readw
, bus
);
2757 register_ioport_write(iobase
, 4, 4, ide_data_writel
, bus
);
2758 register_ioport_read(iobase
, 4, 4, ide_data_readl
, bus
);
2761 static bool is_identify_set(void *opaque
, int version_id
)
2763 IDEState
*s
= opaque
;
2765 return s
->identify_set
!= 0;
2768 static EndTransferFunc
* transfer_end_table
[] = {
2772 ide_atapi_cmd_reply_end
,
2774 ide_dummy_transfer_stop
,
2777 static int transfer_end_table_idx(EndTransferFunc
*fn
)
2781 for (i
= 0; i
< ARRAY_SIZE(transfer_end_table
); i
++)
2782 if (transfer_end_table
[i
] == fn
)
2788 static int ide_drive_post_load(void *opaque
, int version_id
)
2790 IDEState
*s
= opaque
;
2792 if (version_id
< 3) {
2793 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
2794 s
->asc
== ASC_MEDIUM_MAY_HAVE_CHANGED
) {
2795 s
->cdrom_changed
= 1;
2801 static int ide_drive_pio_post_load(void *opaque
, int version_id
)
2803 IDEState
*s
= opaque
;
2805 if (s
->end_transfer_fn_idx
> ARRAY_SIZE(transfer_end_table
)) {
2808 s
->end_transfer_func
= transfer_end_table
[s
->end_transfer_fn_idx
];
2809 s
->data_ptr
= s
->io_buffer
+ s
->cur_io_buffer_offset
;
2810 s
->data_end
= s
->data_ptr
+ s
->cur_io_buffer_len
;
2815 static void ide_drive_pio_pre_save(void *opaque
)
2817 IDEState
*s
= opaque
;
2820 s
->cur_io_buffer_offset
= s
->data_ptr
- s
->io_buffer
;
2821 s
->cur_io_buffer_len
= s
->data_end
- s
->data_ptr
;
2823 idx
= transfer_end_table_idx(s
->end_transfer_func
);
2825 fprintf(stderr
, "%s: invalid end_transfer_func for DRQ_STAT\n",
2827 s
->end_transfer_fn_idx
= 2;
2829 s
->end_transfer_fn_idx
= idx
;
2833 static bool ide_drive_pio_state_needed(void *opaque
)
2835 IDEState
*s
= opaque
;
2837 return (s
->status
& DRQ_STAT
) != 0;
2840 const VMStateDescription vmstate_ide_drive_pio_state
= {
2841 .name
= "ide_drive/pio_state",
2843 .minimum_version_id
= 1,
2844 .minimum_version_id_old
= 1,
2845 .pre_save
= ide_drive_pio_pre_save
,
2846 .post_load
= ide_drive_pio_post_load
,
2847 .fields
= (VMStateField
[]) {
2848 VMSTATE_INT32(req_nb_sectors
, IDEState
),
2849 VMSTATE_VARRAY_INT32(io_buffer
, IDEState
, io_buffer_total_len
, 1,
2850 vmstate_info_uint8
, uint8_t),
2851 VMSTATE_INT32(cur_io_buffer_offset
, IDEState
),
2852 VMSTATE_INT32(cur_io_buffer_len
, IDEState
),
2853 VMSTATE_UINT8(end_transfer_fn_idx
, IDEState
),
2854 VMSTATE_INT32(elementary_transfer_size
, IDEState
),
2855 VMSTATE_INT32(packet_transfer_size
, IDEState
),
2856 VMSTATE_END_OF_LIST()
2860 const VMStateDescription vmstate_ide_drive
= {
2861 .name
= "ide_drive",
2863 .minimum_version_id
= 0,
2864 .minimum_version_id_old
= 0,
2865 .post_load
= ide_drive_post_load
,
2866 .fields
= (VMStateField
[]) {
2867 VMSTATE_INT32(mult_sectors
, IDEState
),
2868 VMSTATE_INT32(identify_set
, IDEState
),
2869 VMSTATE_BUFFER_TEST(identify_data
, IDEState
, is_identify_set
),
2870 VMSTATE_UINT8(feature
, IDEState
),
2871 VMSTATE_UINT8(error
, IDEState
),
2872 VMSTATE_UINT32(nsector
, IDEState
),
2873 VMSTATE_UINT8(sector
, IDEState
),
2874 VMSTATE_UINT8(lcyl
, IDEState
),
2875 VMSTATE_UINT8(hcyl
, IDEState
),
2876 VMSTATE_UINT8(hob_feature
, IDEState
),
2877 VMSTATE_UINT8(hob_sector
, IDEState
),
2878 VMSTATE_UINT8(hob_nsector
, IDEState
),
2879 VMSTATE_UINT8(hob_lcyl
, IDEState
),
2880 VMSTATE_UINT8(hob_hcyl
, IDEState
),
2881 VMSTATE_UINT8(select
, IDEState
),
2882 VMSTATE_UINT8(status
, IDEState
),
2883 VMSTATE_UINT8(lba48
, IDEState
),
2884 VMSTATE_UINT8(sense_key
, IDEState
),
2885 VMSTATE_UINT8(asc
, IDEState
),
2886 VMSTATE_UINT8_V(cdrom_changed
, IDEState
, 3),
2887 VMSTATE_END_OF_LIST()
2889 .subsections
= (VMStateSubsection
[]) {
2891 .vmsd
= &vmstate_ide_drive_pio_state
,
2892 .needed
= ide_drive_pio_state_needed
,
2899 const VMStateDescription vmstate_ide_bus
= {
2902 .minimum_version_id
= 1,
2903 .minimum_version_id_old
= 1,
2904 .fields
= (VMStateField
[]) {
2905 VMSTATE_UINT8(cmd
, IDEBus
),
2906 VMSTATE_UINT8(unit
, IDEBus
),
2907 VMSTATE_END_OF_LIST()
2911 /***********************************************************/
2912 /* PCI IDE definitions */
2914 static void ide_dma_start(IDEState
*s
, BlockDriverCompletionFunc
*dma_cb
)
2916 BMDMAState
*bm
= s
->bus
->bmdma
;
2920 bm
->dma_cb
= dma_cb
;
2921 bm
->cur_prd_last
= 0;
2922 bm
->cur_prd_addr
= 0;
2923 bm
->cur_prd_len
= 0;
2924 bm
->sector_num
= ide_get_sector(s
);
2925 bm
->nsector
= s
->nsector
;
2926 if (bm
->status
& BM_STATUS_DMAING
) {
2931 static void ide_dma_restart(IDEState
*s
, int is_read
)
2933 BMDMAState
*bm
= s
->bus
->bmdma
;
2934 ide_set_sector(s
, bm
->sector_num
);
2935 s
->io_buffer_index
= 0;
2936 s
->io_buffer_size
= 0;
2937 s
->nsector
= bm
->nsector
;
2938 bm
->cur_addr
= bm
->addr
;
2941 bm
->dma_cb
= ide_read_dma_cb
;
2943 bm
->dma_cb
= ide_write_dma_cb
;
2946 ide_dma_start(s
, bm
->dma_cb
);
2949 void ide_dma_cancel(BMDMAState
*bm
)
2951 if (bm
->status
& BM_STATUS_DMAING
) {
2954 printf("aio_cancel\n");
2956 bdrv_aio_cancel(bm
->aiocb
);
2959 bm
->status
&= ~BM_STATUS_DMAING
;
2960 /* cancel DMA request */
2966 void ide_dma_reset(BMDMAState
*bm
)
2969 printf("ide: dma_reset\n");
2976 bm
->cur_prd_last
= 0;
2977 bm
->cur_prd_addr
= 0;
2978 bm
->cur_prd_len
= 0;