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
31 #include "block_int.h"
32 #include "qemu-timer.h"
36 #include <hw/ide/internal.h>
38 static int smart_attributes
[][5] = {
39 /* id, flags, val, wrst, thrsh */
40 { 0x01, 0x03, 0x64, 0x64, 0x06}, /* raw read */
41 { 0x03, 0x03, 0x64, 0x64, 0x46}, /* spin up */
42 { 0x04, 0x02, 0x64, 0x64, 0x14}, /* start stop count */
43 { 0x05, 0x03, 0x64, 0x64, 0x36}, /* remapped sectors */
44 { 0x00, 0x00, 0x00, 0x00, 0x00}
47 /* XXX: DVDs that could fit on a CD will be reported as a CD */
48 static inline int media_present(IDEState
*s
)
50 return (s
->nb_sectors
> 0);
53 static inline int media_is_dvd(IDEState
*s
)
55 return (media_present(s
) && s
->nb_sectors
> CD_MAX_SECTORS
);
58 static inline int media_is_cd(IDEState
*s
)
60 return (media_present(s
) && s
->nb_sectors
<= CD_MAX_SECTORS
);
63 static void ide_dma_start(IDEState
*s
, BlockDriverCompletionFunc
*dma_cb
);
64 static void ide_dma_restart(IDEState
*s
, int is_read
);
65 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
);
66 static int ide_handle_rw_error(IDEState
*s
, int error
, int op
);
68 static void padstr(char *str
, const char *src
, int len
)
71 for(i
= 0; i
< len
; i
++) {
80 static void padstr8(uint8_t *buf
, int buf_size
, const char *src
)
83 for(i
= 0; i
< buf_size
; i
++) {
91 static void put_le16(uint16_t *p
, unsigned int v
)
96 static void ide_identify(IDEState
*s
)
101 if (s
->identify_set
) {
102 memcpy(s
->io_buffer
, s
->identify_data
, sizeof(s
->identify_data
));
106 memset(s
->io_buffer
, 0, 512);
107 p
= (uint16_t *)s
->io_buffer
;
108 put_le16(p
+ 0, 0x0040);
109 put_le16(p
+ 1, s
->cylinders
);
110 put_le16(p
+ 3, s
->heads
);
111 put_le16(p
+ 4, 512 * s
->sectors
); /* XXX: retired, remove ? */
112 put_le16(p
+ 5, 512); /* XXX: retired, remove ? */
113 put_le16(p
+ 6, s
->sectors
);
114 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
115 put_le16(p
+ 20, 3); /* XXX: retired, remove ? */
116 put_le16(p
+ 21, 512); /* cache size in sectors */
117 put_le16(p
+ 22, 4); /* ecc bytes */
118 padstr((char *)(p
+ 23), s
->version
, 8); /* firmware version */
119 padstr((char *)(p
+ 27), "QEMU HARDDISK", 40); /* model */
120 #if MAX_MULT_SECTORS > 1
121 put_le16(p
+ 47, 0x8000 | MAX_MULT_SECTORS
);
123 put_le16(p
+ 48, 1); /* dword I/O */
124 put_le16(p
+ 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
125 put_le16(p
+ 51, 0x200); /* PIO transfer cycle */
126 put_le16(p
+ 52, 0x200); /* DMA transfer cycle */
127 put_le16(p
+ 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
128 put_le16(p
+ 54, s
->cylinders
);
129 put_le16(p
+ 55, s
->heads
);
130 put_le16(p
+ 56, s
->sectors
);
131 oldsize
= s
->cylinders
* s
->heads
* s
->sectors
;
132 put_le16(p
+ 57, oldsize
);
133 put_le16(p
+ 58, oldsize
>> 16);
135 put_le16(p
+ 59, 0x100 | s
->mult_sectors
);
136 put_le16(p
+ 60, s
->nb_sectors
);
137 put_le16(p
+ 61, s
->nb_sectors
>> 16);
138 put_le16(p
+ 62, 0x07); /* single word dma0-2 supported */
139 put_le16(p
+ 63, 0x07); /* mdma0-2 supported */
140 put_le16(p
+ 65, 120);
141 put_le16(p
+ 66, 120);
142 put_le16(p
+ 67, 120);
143 put_le16(p
+ 68, 120);
144 put_le16(p
+ 80, 0xf0); /* ata3 -> ata6 supported */
145 put_le16(p
+ 81, 0x16); /* conforms to ata5 */
146 /* 14=NOP supported, 0=SMART supported */
147 put_le16(p
+ 82, (1 << 14) | 1);
148 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
149 put_le16(p
+ 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
150 /* 14=set to 1, 1=SMART self test, 0=SMART error logging */
151 put_le16(p
+ 84, (1 << 14) | 0);
152 /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
153 if (bdrv_enable_write_cache(s
->bs
))
154 put_le16(p
+ 85, (1 << 14) | (1 << 5) | 1);
156 put_le16(p
+ 85, (1 << 14) | 1);
157 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
158 put_le16(p
+ 86, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
159 /* 14=set to 1, 1=smart self test, 0=smart error logging */
160 put_le16(p
+ 87, (1 << 14) | 0);
161 put_le16(p
+ 88, 0x3f | (1 << 13)); /* udma5 set and supported */
162 put_le16(p
+ 93, 1 | (1 << 14) | 0x2000);
163 put_le16(p
+ 100, s
->nb_sectors
);
164 put_le16(p
+ 101, s
->nb_sectors
>> 16);
165 put_le16(p
+ 102, s
->nb_sectors
>> 32);
166 put_le16(p
+ 103, s
->nb_sectors
>> 48);
167 if (s
->conf
&& s
->conf
->physical_block_size
)
168 put_le16(p
+ 106, 0x6000 | get_physical_block_exp(s
->conf
));
170 memcpy(s
->identify_data
, p
, sizeof(s
->identify_data
));
174 static void ide_atapi_identify(IDEState
*s
)
178 if (s
->identify_set
) {
179 memcpy(s
->io_buffer
, s
->identify_data
, sizeof(s
->identify_data
));
183 memset(s
->io_buffer
, 0, 512);
184 p
= (uint16_t *)s
->io_buffer
;
185 /* Removable CDROM, 50us response, 12 byte packets */
186 put_le16(p
+ 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
187 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
188 put_le16(p
+ 20, 3); /* buffer type */
189 put_le16(p
+ 21, 512); /* cache size in sectors */
190 put_le16(p
+ 22, 4); /* ecc bytes */
191 padstr((char *)(p
+ 23), s
->version
, 8); /* firmware version */
192 padstr((char *)(p
+ 27), "QEMU DVD-ROM", 40); /* model */
193 put_le16(p
+ 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
195 put_le16(p
+ 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
196 put_le16(p
+ 53, 7); /* words 64-70, 54-58, 88 valid */
197 put_le16(p
+ 62, 7); /* single word dma0-2 supported */
198 put_le16(p
+ 63, 7); /* mdma0-2 supported */
199 put_le16(p
+ 64, 0x3f); /* PIO modes supported */
201 put_le16(p
+ 49, 1 << 9); /* LBA supported, no DMA */
202 put_le16(p
+ 53, 3); /* words 64-70, 54-58 valid */
203 put_le16(p
+ 63, 0x103); /* DMA modes XXX: may be incorrect */
204 put_le16(p
+ 64, 1); /* PIO modes */
206 put_le16(p
+ 65, 0xb4); /* minimum DMA multiword tx cycle time */
207 put_le16(p
+ 66, 0xb4); /* recommended DMA multiword tx cycle time */
208 put_le16(p
+ 67, 0x12c); /* minimum PIO cycle time without flow control */
209 put_le16(p
+ 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
211 put_le16(p
+ 71, 30); /* in ns */
212 put_le16(p
+ 72, 30); /* in ns */
214 put_le16(p
+ 80, 0x1e); /* support up to ATA/ATAPI-4 */
216 put_le16(p
+ 88, 0x3f | (1 << 13)); /* udma5 set and supported */
218 memcpy(s
->identify_data
, p
, sizeof(s
->identify_data
));
222 static void ide_cfata_identify(IDEState
*s
)
227 p
= (uint16_t *) s
->identify_data
;
231 memset(p
, 0, sizeof(s
->identify_data
));
233 cur_sec
= s
->cylinders
* s
->heads
* s
->sectors
;
235 put_le16(p
+ 0, 0x848a); /* CF Storage Card signature */
236 put_le16(p
+ 1, s
->cylinders
); /* Default cylinders */
237 put_le16(p
+ 3, s
->heads
); /* Default heads */
238 put_le16(p
+ 6, s
->sectors
); /* Default sectors per track */
239 put_le16(p
+ 7, s
->nb_sectors
>> 16); /* Sectors per card */
240 put_le16(p
+ 8, s
->nb_sectors
); /* Sectors per card */
241 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
242 put_le16(p
+ 22, 0x0004); /* ECC bytes */
243 padstr((char *) (p
+ 23), s
->version
, 8); /* Firmware Revision */
244 padstr((char *) (p
+ 27), "QEMU MICRODRIVE", 40);/* Model number */
245 #if MAX_MULT_SECTORS > 1
246 put_le16(p
+ 47, 0x8000 | MAX_MULT_SECTORS
);
248 put_le16(p
+ 47, 0x0000);
250 put_le16(p
+ 49, 0x0f00); /* Capabilities */
251 put_le16(p
+ 51, 0x0002); /* PIO cycle timing mode */
252 put_le16(p
+ 52, 0x0001); /* DMA cycle timing mode */
253 put_le16(p
+ 53, 0x0003); /* Translation params valid */
254 put_le16(p
+ 54, s
->cylinders
); /* Current cylinders */
255 put_le16(p
+ 55, s
->heads
); /* Current heads */
256 put_le16(p
+ 56, s
->sectors
); /* Current sectors */
257 put_le16(p
+ 57, cur_sec
); /* Current capacity */
258 put_le16(p
+ 58, cur_sec
>> 16); /* Current capacity */
259 if (s
->mult_sectors
) /* Multiple sector setting */
260 put_le16(p
+ 59, 0x100 | s
->mult_sectors
);
261 put_le16(p
+ 60, s
->nb_sectors
); /* Total LBA sectors */
262 put_le16(p
+ 61, s
->nb_sectors
>> 16); /* Total LBA sectors */
263 put_le16(p
+ 63, 0x0203); /* Multiword DMA capability */
264 put_le16(p
+ 64, 0x0001); /* Flow Control PIO support */
265 put_le16(p
+ 65, 0x0096); /* Min. Multiword DMA cycle */
266 put_le16(p
+ 66, 0x0096); /* Rec. Multiword DMA cycle */
267 put_le16(p
+ 68, 0x00b4); /* Min. PIO cycle time */
268 put_le16(p
+ 82, 0x400c); /* Command Set supported */
269 put_le16(p
+ 83, 0x7068); /* Command Set supported */
270 put_le16(p
+ 84, 0x4000); /* Features supported */
271 put_le16(p
+ 85, 0x000c); /* Command Set enabled */
272 put_le16(p
+ 86, 0x7044); /* Command Set enabled */
273 put_le16(p
+ 87, 0x4000); /* Features enabled */
274 put_le16(p
+ 91, 0x4060); /* Current APM level */
275 put_le16(p
+ 129, 0x0002); /* Current features option */
276 put_le16(p
+ 130, 0x0005); /* Reassigned sectors */
277 put_le16(p
+ 131, 0x0001); /* Initial power mode */
278 put_le16(p
+ 132, 0x0000); /* User signature */
279 put_le16(p
+ 160, 0x8100); /* Power requirement */
280 put_le16(p
+ 161, 0x8001); /* CF command set */
285 memcpy(s
->io_buffer
, p
, sizeof(s
->identify_data
));
288 static void ide_set_signature(IDEState
*s
)
290 s
->select
&= 0xf0; /* clear head */
306 static inline void ide_abort_command(IDEState
*s
)
308 s
->status
= READY_STAT
| ERR_STAT
;
312 static inline void ide_dma_submit_check(IDEState
*s
,
313 BlockDriverCompletionFunc
*dma_cb
, BMDMAState
*bm
)
320 /* prepare data transfer and tell what to do after */
321 static void ide_transfer_start(IDEState
*s
, uint8_t *buf
, int size
,
322 EndTransferFunc
*end_transfer_func
)
324 s
->end_transfer_func
= end_transfer_func
;
326 s
->data_end
= buf
+ size
;
327 if (!(s
->status
& ERR_STAT
))
328 s
->status
|= DRQ_STAT
;
331 static void ide_transfer_stop(IDEState
*s
)
333 s
->end_transfer_func
= ide_transfer_stop
;
334 s
->data_ptr
= s
->io_buffer
;
335 s
->data_end
= s
->io_buffer
;
336 s
->status
&= ~DRQ_STAT
;
339 int64_t ide_get_sector(IDEState
*s
)
342 if (s
->select
& 0x40) {
345 sector_num
= ((s
->select
& 0x0f) << 24) | (s
->hcyl
<< 16) |
346 (s
->lcyl
<< 8) | s
->sector
;
348 sector_num
= ((int64_t)s
->hob_hcyl
<< 40) |
349 ((int64_t) s
->hob_lcyl
<< 32) |
350 ((int64_t) s
->hob_sector
<< 24) |
351 ((int64_t) s
->hcyl
<< 16) |
352 ((int64_t) s
->lcyl
<< 8) | s
->sector
;
355 sector_num
= ((s
->hcyl
<< 8) | s
->lcyl
) * s
->heads
* s
->sectors
+
356 (s
->select
& 0x0f) * s
->sectors
+ (s
->sector
- 1);
361 void ide_set_sector(IDEState
*s
, int64_t sector_num
)
364 if (s
->select
& 0x40) {
366 s
->select
= (s
->select
& 0xf0) | (sector_num
>> 24);
367 s
->hcyl
= (sector_num
>> 16);
368 s
->lcyl
= (sector_num
>> 8);
369 s
->sector
= (sector_num
);
371 s
->sector
= sector_num
;
372 s
->lcyl
= sector_num
>> 8;
373 s
->hcyl
= sector_num
>> 16;
374 s
->hob_sector
= sector_num
>> 24;
375 s
->hob_lcyl
= sector_num
>> 32;
376 s
->hob_hcyl
= sector_num
>> 40;
379 cyl
= sector_num
/ (s
->heads
* s
->sectors
);
380 r
= sector_num
% (s
->heads
* s
->sectors
);
383 s
->select
= (s
->select
& 0xf0) | ((r
/ s
->sectors
) & 0x0f);
384 s
->sector
= (r
% s
->sectors
) + 1;
388 static void ide_rw_error(IDEState
*s
) {
389 ide_abort_command(s
);
393 static void ide_sector_read(IDEState
*s
)
398 s
->status
= READY_STAT
| SEEK_STAT
;
399 s
->error
= 0; /* not needed by IDE spec, but needed by Windows */
400 sector_num
= ide_get_sector(s
);
403 /* no more sector to read from disk */
404 ide_transfer_stop(s
);
406 #if defined(DEBUG_IDE)
407 printf("read sector=%" PRId64
"\n", sector_num
);
409 if (n
> s
->req_nb_sectors
)
410 n
= s
->req_nb_sectors
;
411 ret
= bdrv_read(s
->bs
, sector_num
, s
->io_buffer
, n
);
413 if (ide_handle_rw_error(s
, -ret
,
414 BM_STATUS_PIO_RETRY
| BM_STATUS_RETRY_READ
))
419 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_read
);
421 ide_set_sector(s
, sector_num
+ n
);
427 /* return 0 if buffer completed */
428 static int dma_buf_prepare(BMDMAState
*bm
, int is_write
)
430 IDEState
*s
= bmdma_active_if(bm
);
437 qemu_sglist_init(&s
->sg
, s
->nsector
/ (TARGET_PAGE_SIZE
/512) + 1);
438 s
->io_buffer_size
= 0;
440 if (bm
->cur_prd_len
== 0) {
441 /* end of table (with a fail safe of one page) */
442 if (bm
->cur_prd_last
||
443 (bm
->cur_addr
- bm
->addr
) >= 4096)
444 return s
->io_buffer_size
!= 0;
445 cpu_physical_memory_read(bm
->cur_addr
, (uint8_t *)&prd
, 8);
447 prd
.addr
= le32_to_cpu(prd
.addr
);
448 prd
.size
= le32_to_cpu(prd
.size
);
449 len
= prd
.size
& 0xfffe;
452 bm
->cur_prd_len
= len
;
453 bm
->cur_prd_addr
= prd
.addr
;
454 bm
->cur_prd_last
= (prd
.size
& 0x80000000);
458 qemu_sglist_add(&s
->sg
, bm
->cur_prd_addr
, l
);
459 bm
->cur_prd_addr
+= l
;
460 bm
->cur_prd_len
-= l
;
461 s
->io_buffer_size
+= l
;
467 static void dma_buf_commit(IDEState
*s
, int is_write
)
469 qemu_sglist_destroy(&s
->sg
);
472 void ide_dma_error(IDEState
*s
)
474 ide_transfer_stop(s
);
476 s
->status
= READY_STAT
| ERR_STAT
;
480 static int ide_handle_rw_error(IDEState
*s
, int error
, int op
)
482 int is_read
= (op
& BM_STATUS_RETRY_READ
);
483 BlockInterfaceErrorAction action
= drive_get_on_error(s
->bs
, is_read
);
485 if (action
== BLOCK_ERR_IGNORE
) {
486 bdrv_mon_event(s
->bs
, BDRV_ACTION_IGNORE
, is_read
);
490 if ((error
== ENOSPC
&& action
== BLOCK_ERR_STOP_ENOSPC
)
491 || action
== BLOCK_ERR_STOP_ANY
) {
492 s
->bus
->bmdma
->unit
= s
->unit
;
493 s
->bus
->bmdma
->status
|= op
;
494 bdrv_mon_event(s
->bs
, BDRV_ACTION_STOP
, is_read
);
497 if (op
& BM_STATUS_DMA_RETRY
) {
498 dma_buf_commit(s
, 0);
503 bdrv_mon_event(s
->bs
, BDRV_ACTION_REPORT
, is_read
);
509 /* return 0 if buffer completed */
510 static int dma_buf_rw(BMDMAState
*bm
, int is_write
)
512 IDEState
*s
= bmdma_active_if(bm
);
520 l
= s
->io_buffer_size
- s
->io_buffer_index
;
523 if (bm
->cur_prd_len
== 0) {
524 /* end of table (with a fail safe of one page) */
525 if (bm
->cur_prd_last
||
526 (bm
->cur_addr
- bm
->addr
) >= 4096)
528 cpu_physical_memory_read(bm
->cur_addr
, (uint8_t *)&prd
, 8);
530 prd
.addr
= le32_to_cpu(prd
.addr
);
531 prd
.size
= le32_to_cpu(prd
.size
);
532 len
= prd
.size
& 0xfffe;
535 bm
->cur_prd_len
= len
;
536 bm
->cur_prd_addr
= prd
.addr
;
537 bm
->cur_prd_last
= (prd
.size
& 0x80000000);
539 if (l
> bm
->cur_prd_len
)
543 cpu_physical_memory_write(bm
->cur_prd_addr
,
544 s
->io_buffer
+ s
->io_buffer_index
, l
);
546 cpu_physical_memory_read(bm
->cur_prd_addr
,
547 s
->io_buffer
+ s
->io_buffer_index
, l
);
549 bm
->cur_prd_addr
+= l
;
550 bm
->cur_prd_len
-= l
;
551 s
->io_buffer_index
+= l
;
557 static void ide_read_dma_cb(void *opaque
, int ret
)
559 BMDMAState
*bm
= opaque
;
560 IDEState
*s
= bmdma_active_if(bm
);
565 if (ide_handle_rw_error(s
, -ret
,
566 BM_STATUS_DMA_RETRY
| BM_STATUS_RETRY_READ
))
572 n
= s
->io_buffer_size
>> 9;
573 sector_num
= ide_get_sector(s
);
575 dma_buf_commit(s
, 1);
577 ide_set_sector(s
, sector_num
);
581 /* end of transfer ? */
582 if (s
->nsector
== 0) {
583 s
->status
= READY_STAT
| SEEK_STAT
;
586 bm
->status
&= ~BM_STATUS_DMAING
;
587 bm
->status
|= BM_STATUS_INT
;
594 /* launch next transfer */
596 s
->io_buffer_index
= 0;
597 s
->io_buffer_size
= n
* 512;
598 if (dma_buf_prepare(bm
, 1) == 0)
601 printf("aio_read: sector_num=%" PRId64
" n=%d\n", sector_num
, n
);
603 bm
->aiocb
= dma_bdrv_read(s
->bs
, &s
->sg
, sector_num
, ide_read_dma_cb
, bm
);
604 ide_dma_submit_check(s
, ide_read_dma_cb
, bm
);
607 static void ide_sector_read_dma(IDEState
*s
)
609 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
610 s
->io_buffer_index
= 0;
611 s
->io_buffer_size
= 0;
613 ide_dma_start(s
, ide_read_dma_cb
);
616 static void ide_sector_write_timer_cb(void *opaque
)
618 IDEState
*s
= opaque
;
622 static void ide_sector_write(IDEState
*s
)
627 s
->status
= READY_STAT
| SEEK_STAT
;
628 sector_num
= ide_get_sector(s
);
629 #if defined(DEBUG_IDE)
630 printf("write sector=%" PRId64
"\n", sector_num
);
633 if (n
> s
->req_nb_sectors
)
634 n
= s
->req_nb_sectors
;
635 ret
= bdrv_write(s
->bs
, sector_num
, s
->io_buffer
, n
);
638 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_PIO_RETRY
))
643 if (s
->nsector
== 0) {
644 /* no more sectors to write */
645 ide_transfer_stop(s
);
648 if (n1
> s
->req_nb_sectors
)
649 n1
= s
->req_nb_sectors
;
650 ide_transfer_start(s
, s
->io_buffer
, 512 * n1
, ide_sector_write
);
652 ide_set_sector(s
, sector_num
+ n
);
655 if (win2k_install_hack
&& ((++s
->irq_count
% 16) == 0)) {
656 /* It seems there is a bug in the Windows 2000 installer HDD
657 IDE driver which fills the disk with empty logs when the
658 IDE write IRQ comes too early. This hack tries to correct
659 that at the expense of slower write performances. Use this
660 option _only_ to install Windows 2000. You must disable it
662 qemu_mod_timer(s
->sector_write_timer
,
663 qemu_get_clock(vm_clock
) + (get_ticks_per_sec() / 1000));
671 static void ide_dma_restart_bh(void *opaque
)
673 BMDMAState
*bm
= opaque
;
676 qemu_bh_delete(bm
->bh
);
679 is_read
= !!(bm
->status
& BM_STATUS_RETRY_READ
);
681 if (bm
->status
& BM_STATUS_DMA_RETRY
) {
682 bm
->status
&= ~(BM_STATUS_DMA_RETRY
| BM_STATUS_RETRY_READ
);
683 ide_dma_restart(bmdma_active_if(bm
), is_read
);
684 } else if (bm
->status
& BM_STATUS_PIO_RETRY
) {
685 bm
->status
&= ~(BM_STATUS_PIO_RETRY
| BM_STATUS_RETRY_READ
);
687 ide_sector_read(bmdma_active_if(bm
));
689 ide_sector_write(bmdma_active_if(bm
));
694 void ide_dma_restart_cb(void *opaque
, int running
, int reason
)
696 BMDMAState
*bm
= opaque
;
702 bm
->bh
= qemu_bh_new(ide_dma_restart_bh
, bm
);
703 qemu_bh_schedule(bm
->bh
);
707 static void ide_write_dma_cb(void *opaque
, int ret
)
709 BMDMAState
*bm
= opaque
;
710 IDEState
*s
= bmdma_active_if(bm
);
715 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_DMA_RETRY
))
719 n
= s
->io_buffer_size
>> 9;
720 sector_num
= ide_get_sector(s
);
722 dma_buf_commit(s
, 0);
724 ide_set_sector(s
, sector_num
);
728 /* end of transfer ? */
729 if (s
->nsector
== 0) {
730 s
->status
= READY_STAT
| SEEK_STAT
;
733 bm
->status
&= ~BM_STATUS_DMAING
;
734 bm
->status
|= BM_STATUS_INT
;
742 s
->io_buffer_size
= n
* 512;
743 /* launch next transfer */
744 if (dma_buf_prepare(bm
, 0) == 0)
747 printf("aio_write: sector_num=%" PRId64
" n=%d\n", sector_num
, n
);
749 bm
->aiocb
= dma_bdrv_write(s
->bs
, &s
->sg
, sector_num
, ide_write_dma_cb
, bm
);
750 ide_dma_submit_check(s
, ide_write_dma_cb
, bm
);
753 static void ide_sector_write_dma(IDEState
*s
)
755 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
756 s
->io_buffer_index
= 0;
757 s
->io_buffer_size
= 0;
759 ide_dma_start(s
, ide_write_dma_cb
);
762 void ide_atapi_cmd_ok(IDEState
*s
)
765 s
->status
= READY_STAT
| SEEK_STAT
;
766 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
770 void ide_atapi_cmd_error(IDEState
*s
, int sense_key
, int asc
)
772 #ifdef DEBUG_IDE_ATAPI
773 printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key
, asc
);
775 s
->error
= sense_key
<< 4;
776 s
->status
= READY_STAT
| ERR_STAT
;
777 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
778 s
->sense_key
= sense_key
;
783 static void ide_atapi_cmd_check_status(IDEState
*s
)
785 #ifdef DEBUG_IDE_ATAPI
786 printf("atapi_cmd_check_status\n");
788 s
->error
= MC_ERR
| (SENSE_UNIT_ATTENTION
<< 4);
789 s
->status
= ERR_STAT
;
794 static void ide_flush_cb(void *opaque
, int ret
)
796 IDEState
*s
= opaque
;
798 /* XXX: how do we signal I/O errors here? */
800 s
->status
= READY_STAT
| SEEK_STAT
;
804 static inline void cpu_to_ube16(uint8_t *buf
, int val
)
810 static inline void cpu_to_ube32(uint8_t *buf
, unsigned int val
)
818 static inline int ube16_to_cpu(const uint8_t *buf
)
820 return (buf
[0] << 8) | buf
[1];
823 static inline int ube32_to_cpu(const uint8_t *buf
)
825 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
828 static void lba_to_msf(uint8_t *buf
, int lba
)
831 buf
[0] = (lba
/ 75) / 60;
832 buf
[1] = (lba
/ 75) % 60;
836 static void cd_data_to_raw(uint8_t *buf
, int lba
)
840 memset(buf
+ 1, 0xff, 10);
844 lba_to_msf(buf
, lba
);
845 buf
[3] = 0x01; /* mode 1 data */
849 /* XXX: ECC not computed */
853 static int cd_read_sector(BlockDriverState
*bs
, int lba
, uint8_t *buf
,
858 switch(sector_size
) {
860 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
, 4);
863 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
+ 16, 4);
866 cd_data_to_raw(buf
, lba
);
875 void ide_atapi_io_error(IDEState
*s
, int ret
)
877 /* XXX: handle more errors */
878 if (ret
== -ENOMEDIUM
) {
879 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
880 ASC_MEDIUM_NOT_PRESENT
);
882 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
883 ASC_LOGICAL_BLOCK_OOR
);
887 /* The whole ATAPI transfer logic is handled in this function */
888 static void ide_atapi_cmd_reply_end(IDEState
*s
)
890 int byte_count_limit
, size
, ret
;
891 #ifdef DEBUG_IDE_ATAPI
892 printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
893 s
->packet_transfer_size
,
894 s
->elementary_transfer_size
,
897 if (s
->packet_transfer_size
<= 0) {
898 /* end of transfer */
899 ide_transfer_stop(s
);
900 s
->status
= READY_STAT
| SEEK_STAT
;
901 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
903 #ifdef DEBUG_IDE_ATAPI
904 printf("status=0x%x\n", s
->status
);
907 /* see if a new sector must be read */
908 if (s
->lba
!= -1 && s
->io_buffer_index
>= s
->cd_sector_size
) {
909 ret
= cd_read_sector(s
->bs
, s
->lba
, s
->io_buffer
, s
->cd_sector_size
);
911 ide_transfer_stop(s
);
912 ide_atapi_io_error(s
, ret
);
916 s
->io_buffer_index
= 0;
918 if (s
->elementary_transfer_size
> 0) {
919 /* there are some data left to transmit in this elementary
921 size
= s
->cd_sector_size
- s
->io_buffer_index
;
922 if (size
> s
->elementary_transfer_size
)
923 size
= s
->elementary_transfer_size
;
924 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
,
925 size
, ide_atapi_cmd_reply_end
);
926 s
->packet_transfer_size
-= size
;
927 s
->elementary_transfer_size
-= size
;
928 s
->io_buffer_index
+= size
;
930 /* a new transfer is needed */
931 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
;
932 byte_count_limit
= s
->lcyl
| (s
->hcyl
<< 8);
933 #ifdef DEBUG_IDE_ATAPI
934 printf("byte_count_limit=%d\n", byte_count_limit
);
936 if (byte_count_limit
== 0xffff)
938 size
= s
->packet_transfer_size
;
939 if (size
> byte_count_limit
) {
940 /* byte count limit must be even if this case */
941 if (byte_count_limit
& 1)
943 size
= byte_count_limit
;
947 s
->elementary_transfer_size
= size
;
948 /* we cannot transmit more than one sector at a time */
950 if (size
> (s
->cd_sector_size
- s
->io_buffer_index
))
951 size
= (s
->cd_sector_size
- s
->io_buffer_index
);
953 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
,
954 size
, ide_atapi_cmd_reply_end
);
955 s
->packet_transfer_size
-= size
;
956 s
->elementary_transfer_size
-= size
;
957 s
->io_buffer_index
+= size
;
959 #ifdef DEBUG_IDE_ATAPI
960 printf("status=0x%x\n", s
->status
);
966 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
967 static void ide_atapi_cmd_reply(IDEState
*s
, int size
, int max_size
)
971 s
->lba
= -1; /* no sector read */
972 s
->packet_transfer_size
= size
;
973 s
->io_buffer_size
= size
; /* dma: send the reply data as one chunk */
974 s
->elementary_transfer_size
= 0;
975 s
->io_buffer_index
= 0;
978 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
;
979 ide_dma_start(s
, ide_atapi_cmd_read_dma_cb
);
981 s
->status
= READY_STAT
| SEEK_STAT
;
982 ide_atapi_cmd_reply_end(s
);
986 /* start a CD-CDROM read command */
987 static void ide_atapi_cmd_read_pio(IDEState
*s
, int lba
, int nb_sectors
,
991 s
->packet_transfer_size
= nb_sectors
* sector_size
;
992 s
->elementary_transfer_size
= 0;
993 s
->io_buffer_index
= sector_size
;
994 s
->cd_sector_size
= sector_size
;
996 s
->status
= READY_STAT
| SEEK_STAT
;
997 ide_atapi_cmd_reply_end(s
);
1000 /* ATAPI DMA support */
1002 /* XXX: handle read errors */
1003 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
)
1005 BMDMAState
*bm
= opaque
;
1006 IDEState
*s
= bmdma_active_if(bm
);
1010 ide_atapi_io_error(s
, ret
);
1014 if (s
->io_buffer_size
> 0) {
1016 * For a cdrom read sector command (s->lba != -1),
1017 * adjust the lba for the next s->io_buffer_size chunk
1018 * and dma the current chunk.
1019 * For a command != read (s->lba == -1), just transfer
1023 if (s
->cd_sector_size
== 2352) {
1025 cd_data_to_raw(s
->io_buffer
, s
->lba
);
1027 n
= s
->io_buffer_size
>> 11;
1031 s
->packet_transfer_size
-= s
->io_buffer_size
;
1032 if (dma_buf_rw(bm
, 1) == 0)
1036 if (s
->packet_transfer_size
<= 0) {
1037 s
->status
= READY_STAT
| SEEK_STAT
;
1038 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
1039 ide_set_irq(s
->bus
);
1041 bm
->status
&= ~BM_STATUS_DMAING
;
1042 bm
->status
|= BM_STATUS_INT
;
1049 s
->io_buffer_index
= 0;
1050 if (s
->cd_sector_size
== 2352) {
1052 s
->io_buffer_size
= s
->cd_sector_size
;
1055 n
= s
->packet_transfer_size
>> 11;
1056 if (n
> (IDE_DMA_BUF_SECTORS
/ 4))
1057 n
= (IDE_DMA_BUF_SECTORS
/ 4);
1058 s
->io_buffer_size
= n
* 2048;
1062 printf("aio_read_cd: lba=%u n=%d\n", s
->lba
, n
);
1064 bm
->iov
.iov_base
= (void *)(s
->io_buffer
+ data_offset
);
1065 bm
->iov
.iov_len
= n
* 4 * 512;
1066 qemu_iovec_init_external(&bm
->qiov
, &bm
->iov
, 1);
1067 bm
->aiocb
= bdrv_aio_readv(s
->bs
, (int64_t)s
->lba
<< 2, &bm
->qiov
,
1068 n
* 4, ide_atapi_cmd_read_dma_cb
, bm
);
1070 /* Note: media not present is the most likely case */
1071 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1072 ASC_MEDIUM_NOT_PRESENT
);
1077 /* start a CD-CDROM read command with DMA */
1078 /* XXX: test if DMA is available */
1079 static void ide_atapi_cmd_read_dma(IDEState
*s
, int lba
, int nb_sectors
,
1083 s
->packet_transfer_size
= nb_sectors
* sector_size
;
1084 s
->io_buffer_index
= 0;
1085 s
->io_buffer_size
= 0;
1086 s
->cd_sector_size
= sector_size
;
1088 /* XXX: check if BUSY_STAT should be set */
1089 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
1090 ide_dma_start(s
, ide_atapi_cmd_read_dma_cb
);
1093 static void ide_atapi_cmd_read(IDEState
*s
, int lba
, int nb_sectors
,
1096 #ifdef DEBUG_IDE_ATAPI
1097 printf("read %s: LBA=%d nb_sectors=%d\n", s
->atapi_dma
? "dma" : "pio",
1101 ide_atapi_cmd_read_dma(s
, lba
, nb_sectors
, sector_size
);
1103 ide_atapi_cmd_read_pio(s
, lba
, nb_sectors
, sector_size
);
1107 static inline uint8_t ide_atapi_set_profile(uint8_t *buf
, uint8_t *index
,
1110 uint8_t *buf_profile
= buf
+ 12; /* start of profiles */
1112 buf_profile
+= ((*index
) * 4); /* start of indexed profile */
1113 cpu_to_ube16 (buf_profile
, profile
);
1114 buf_profile
[2] = ((buf_profile
[0] == buf
[6]) && (buf_profile
[1] == buf
[7]));
1116 /* each profile adds 4 bytes to the response */
1118 buf
[11] += 4; /* Additional Length */
1123 static int ide_dvd_read_structure(IDEState
*s
, int format
,
1124 const uint8_t *packet
, uint8_t *buf
)
1127 case 0x0: /* Physical format information */
1129 int layer
= packet
[6];
1130 uint64_t total_sectors
;
1133 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1135 bdrv_get_geometry(s
->bs
, &total_sectors
);
1136 total_sectors
>>= 2;
1137 if (total_sectors
== 0)
1138 return -ASC_MEDIUM_NOT_PRESENT
;
1140 buf
[4] = 1; /* DVD-ROM, part version 1 */
1141 buf
[5] = 0xf; /* 120mm disc, minimum rate unspecified */
1142 buf
[6] = 1; /* one layer, read-only (per MMC-2 spec) */
1143 buf
[7] = 0; /* default densities */
1145 /* FIXME: 0x30000 per spec? */
1146 cpu_to_ube32(buf
+ 8, 0); /* start sector */
1147 cpu_to_ube32(buf
+ 12, total_sectors
- 1); /* end sector */
1148 cpu_to_ube32(buf
+ 16, total_sectors
- 1); /* l0 end sector */
1150 /* Size of buffer, not including 2 byte size field */
1151 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
1153 /* 2k data + 4 byte header */
1157 case 0x01: /* DVD copyright information */
1158 buf
[4] = 0; /* no copyright data */
1159 buf
[5] = 0; /* no region restrictions */
1161 /* Size of buffer, not including 2 byte size field */
1162 cpu_to_be16wu((uint16_t *)buf
, 4 + 2);
1164 /* 4 byte header + 4 byte data */
1167 case 0x03: /* BCA information - invalid field for no BCA info */
1168 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1170 case 0x04: /* DVD disc manufacturing information */
1171 /* Size of buffer, not including 2 byte size field */
1172 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
1174 /* 2k data + 4 byte header */
1179 * This lists all the command capabilities above. Add new ones
1180 * in order and update the length and buffer return values.
1183 buf
[4] = 0x00; /* Physical format */
1184 buf
[5] = 0x40; /* Not writable, is readable */
1185 cpu_to_be16wu((uint16_t *)(buf
+ 6), 2048 + 4);
1187 buf
[8] = 0x01; /* Copyright info */
1188 buf
[9] = 0x40; /* Not writable, is readable */
1189 cpu_to_be16wu((uint16_t *)(buf
+ 10), 4 + 4);
1191 buf
[12] = 0x03; /* BCA info */
1192 buf
[13] = 0x40; /* Not writable, is readable */
1193 cpu_to_be16wu((uint16_t *)(buf
+ 14), 188 + 4);
1195 buf
[16] = 0x04; /* Manufacturing info */
1196 buf
[17] = 0x40; /* Not writable, is readable */
1197 cpu_to_be16wu((uint16_t *)(buf
+ 18), 2048 + 4);
1199 /* Size of buffer, not including 2 byte size field */
1200 cpu_to_be16wu((uint16_t *)buf
, 16 + 2);
1202 /* data written + 4 byte header */
1205 default: /* TODO: formats beyond DVD-ROM requires */
1206 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1210 static void ide_atapi_cmd(IDEState
*s
)
1212 const uint8_t *packet
;
1216 packet
= s
->io_buffer
;
1218 #ifdef DEBUG_IDE_ATAPI
1221 printf("ATAPI limit=0x%x packet:", s
->lcyl
| (s
->hcyl
<< 8));
1222 for(i
= 0; i
< ATAPI_PACKET_SIZE
; i
++) {
1223 printf(" %02x", packet
[i
]);
1228 /* If there's a UNIT_ATTENTION condition pending, only
1229 REQUEST_SENSE and INQUIRY commands are allowed to complete. */
1230 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
1231 s
->io_buffer
[0] != GPCMD_REQUEST_SENSE
&&
1232 s
->io_buffer
[0] != GPCMD_INQUIRY
) {
1233 ide_atapi_cmd_check_status(s
);
1236 switch(s
->io_buffer
[0]) {
1237 case GPCMD_TEST_UNIT_READY
:
1238 if (bdrv_is_inserted(s
->bs
) && !s
->cdrom_changed
) {
1239 ide_atapi_cmd_ok(s
);
1241 s
->cdrom_changed
= 0;
1242 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1243 ASC_MEDIUM_NOT_PRESENT
);
1246 case GPCMD_MODE_SENSE_6
:
1247 case GPCMD_MODE_SENSE_10
:
1250 if (packet
[0] == GPCMD_MODE_SENSE_10
)
1251 max_len
= ube16_to_cpu(packet
+ 7);
1253 max_len
= packet
[4];
1254 action
= packet
[2] >> 6;
1255 code
= packet
[2] & 0x3f;
1257 case 0: /* current values */
1259 case GPMODE_R_W_ERROR_PAGE
: /* error recovery */
1260 cpu_to_ube16(&buf
[0], 16 + 6);
1276 ide_atapi_cmd_reply(s
, 16, max_len
);
1278 case GPMODE_AUDIO_CTL_PAGE
:
1279 cpu_to_ube16(&buf
[0], 24 + 6);
1287 /* Fill with CDROM audio volume */
1293 ide_atapi_cmd_reply(s
, 24, max_len
);
1295 case GPMODE_CAPABILITIES_PAGE
:
1296 cpu_to_ube16(&buf
[0], 28 + 6);
1309 /* Claim PLAY_AUDIO capability (0x01) since some Linux
1310 code checks for this to automount media. */
1313 buf
[14] = (1 << 0) | (1 << 3) | (1 << 5);
1314 if (bdrv_is_locked(s
->bs
))
1317 cpu_to_ube16(&buf
[16], 706);
1320 cpu_to_ube16(&buf
[20], 512);
1321 cpu_to_ube16(&buf
[22], 706);
1326 ide_atapi_cmd_reply(s
, 28, max_len
);
1332 case 1: /* changeable values */
1334 case 2: /* default values */
1337 case 3: /* saved values */
1338 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1339 ASC_SAVING_PARAMETERS_NOT_SUPPORTED
);
1344 case GPCMD_REQUEST_SENSE
:
1345 max_len
= packet
[4];
1347 buf
[0] = 0x70 | (1 << 7);
1348 buf
[2] = s
->sense_key
;
1351 if (s
->sense_key
== SENSE_UNIT_ATTENTION
)
1352 s
->sense_key
= SENSE_NONE
;
1353 ide_atapi_cmd_reply(s
, 18, max_len
);
1355 case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
:
1356 if (bdrv_is_inserted(s
->bs
)) {
1357 bdrv_set_locked(s
->bs
, packet
[4] & 1);
1358 ide_atapi_cmd_ok(s
);
1360 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1361 ASC_MEDIUM_NOT_PRESENT
);
1367 int nb_sectors
, lba
;
1369 if (packet
[0] == GPCMD_READ_10
)
1370 nb_sectors
= ube16_to_cpu(packet
+ 7);
1372 nb_sectors
= ube32_to_cpu(packet
+ 6);
1373 lba
= ube32_to_cpu(packet
+ 2);
1374 if (nb_sectors
== 0) {
1375 ide_atapi_cmd_ok(s
);
1378 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
1383 int nb_sectors
, lba
, transfer_request
;
1385 nb_sectors
= (packet
[6] << 16) | (packet
[7] << 8) | packet
[8];
1386 lba
= ube32_to_cpu(packet
+ 2);
1387 if (nb_sectors
== 0) {
1388 ide_atapi_cmd_ok(s
);
1391 transfer_request
= packet
[9];
1392 switch(transfer_request
& 0xf8) {
1395 ide_atapi_cmd_ok(s
);
1399 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
1403 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2352);
1406 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1407 ASC_INV_FIELD_IN_CMD_PACKET
);
1415 uint64_t total_sectors
;
1417 bdrv_get_geometry(s
->bs
, &total_sectors
);
1418 total_sectors
>>= 2;
1419 if (total_sectors
== 0) {
1420 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1421 ASC_MEDIUM_NOT_PRESENT
);
1424 lba
= ube32_to_cpu(packet
+ 2);
1425 if (lba
>= total_sectors
) {
1426 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1427 ASC_LOGICAL_BLOCK_OOR
);
1430 ide_atapi_cmd_ok(s
);
1433 case GPCMD_START_STOP_UNIT
:
1435 int start
, eject
, err
= 0;
1436 start
= packet
[4] & 1;
1437 eject
= (packet
[4] >> 1) & 1;
1440 err
= bdrv_eject(s
->bs
, !start
);
1445 ide_atapi_cmd_ok(s
);
1448 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1449 ASC_MEDIA_REMOVAL_PREVENTED
);
1452 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1453 ASC_MEDIUM_NOT_PRESENT
);
1458 case GPCMD_MECHANISM_STATUS
:
1460 max_len
= ube16_to_cpu(packet
+ 8);
1461 cpu_to_ube16(buf
, 0);
1462 /* no current LBA */
1467 cpu_to_ube16(buf
+ 6, 0);
1468 ide_atapi_cmd_reply(s
, 8, max_len
);
1471 case GPCMD_READ_TOC_PMA_ATIP
:
1473 int format
, msf
, start_track
, len
;
1474 uint64_t total_sectors
;
1476 bdrv_get_geometry(s
->bs
, &total_sectors
);
1477 total_sectors
>>= 2;
1478 if (total_sectors
== 0) {
1479 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1480 ASC_MEDIUM_NOT_PRESENT
);
1483 max_len
= ube16_to_cpu(packet
+ 7);
1484 format
= packet
[9] >> 6;
1485 msf
= (packet
[1] >> 1) & 1;
1486 start_track
= packet
[6];
1489 len
= cdrom_read_toc(total_sectors
, buf
, msf
, start_track
);
1492 ide_atapi_cmd_reply(s
, len
, max_len
);
1495 /* multi session : only a single session defined */
1500 ide_atapi_cmd_reply(s
, 12, max_len
);
1503 len
= cdrom_read_toc_raw(total_sectors
, buf
, msf
, start_track
);
1506 ide_atapi_cmd_reply(s
, len
, max_len
);
1510 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1511 ASC_INV_FIELD_IN_CMD_PACKET
);
1516 case GPCMD_READ_CDVD_CAPACITY
:
1518 uint64_t total_sectors
;
1520 bdrv_get_geometry(s
->bs
, &total_sectors
);
1521 total_sectors
>>= 2;
1522 if (total_sectors
== 0) {
1523 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1524 ASC_MEDIUM_NOT_PRESENT
);
1527 /* NOTE: it is really the number of sectors minus 1 */
1528 cpu_to_ube32(buf
, total_sectors
- 1);
1529 cpu_to_ube32(buf
+ 4, 2048);
1530 ide_atapi_cmd_reply(s
, 8, 8);
1533 case GPCMD_READ_DVD_STRUCTURE
:
1535 int media
= packet
[1];
1536 int format
= packet
[7];
1539 max_len
= ube16_to_cpu(packet
+ 8);
1541 if (format
< 0xff) {
1542 if (media_is_cd(s
)) {
1543 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1544 ASC_INCOMPATIBLE_FORMAT
);
1546 } else if (!media_present(s
)) {
1547 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1548 ASC_INV_FIELD_IN_CMD_PACKET
);
1553 memset(buf
, 0, max_len
> IDE_DMA_BUF_SECTORS
* 512 + 4 ?
1554 IDE_DMA_BUF_SECTORS
* 512 + 4 : max_len
);
1560 ret
= ide_dvd_read_structure(s
, format
, packet
, buf
);
1563 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
, -ret
);
1565 ide_atapi_cmd_reply(s
, ret
, max_len
);
1569 /* TODO: BD support, fall through for now */
1571 /* Generic disk structures */
1572 case 0x80: /* TODO: AACS volume identifier */
1573 case 0x81: /* TODO: AACS media serial number */
1574 case 0x82: /* TODO: AACS media identifier */
1575 case 0x83: /* TODO: AACS media key block */
1576 case 0x90: /* TODO: List of recognized format layers */
1577 case 0xc0: /* TODO: Write protection status */
1579 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1580 ASC_INV_FIELD_IN_CMD_PACKET
);
1585 case GPCMD_SET_SPEED
:
1586 ide_atapi_cmd_ok(s
);
1589 max_len
= packet
[4];
1590 buf
[0] = 0x05; /* CD-ROM */
1591 buf
[1] = 0x80; /* removable */
1592 buf
[2] = 0x00; /* ISO */
1593 buf
[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1594 buf
[4] = 31; /* additional length */
1595 buf
[5] = 0; /* reserved */
1596 buf
[6] = 0; /* reserved */
1597 buf
[7] = 0; /* reserved */
1598 padstr8(buf
+ 8, 8, "QEMU");
1599 padstr8(buf
+ 16, 16, "QEMU DVD-ROM");
1600 padstr8(buf
+ 32, 4, s
->version
);
1601 ide_atapi_cmd_reply(s
, 36, max_len
);
1603 case GPCMD_GET_CONFIGURATION
:
1608 /* only feature 0 is supported */
1609 if (packet
[2] != 0 || packet
[3] != 0) {
1610 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1611 ASC_INV_FIELD_IN_CMD_PACKET
);
1615 /* XXX: could result in alignment problems in some architectures */
1616 max_len
= ube16_to_cpu(packet
+ 7);
1619 * XXX: avoid overflow for io_buffer if max_len is bigger than
1620 * the size of that buffer (dimensioned to max number of
1621 * sectors to transfer at once)
1623 * Only a problem if the feature/profiles grow.
1625 if (max_len
> 512) /* XXX: assume 1 sector */
1628 memset(buf
, 0, max_len
);
1630 * the number of sectors from the media tells us which profile
1631 * to use as current. 0 means there is no media
1633 if (media_is_dvd(s
))
1634 cpu_to_ube16(buf
+ 6, MMC_PROFILE_DVD_ROM
);
1635 else if (media_is_cd(s
))
1636 cpu_to_ube16(buf
+ 6, MMC_PROFILE_CD_ROM
);
1638 buf
[10] = 0x02 | 0x01; /* persistent and current */
1639 len
= 12; /* headers: 8 + 4 */
1640 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_DVD_ROM
);
1641 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_CD_ROM
);
1642 cpu_to_ube32(buf
, len
- 4); /* data length */
1644 ide_atapi_cmd_reply(s
, len
, max_len
);
1648 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1649 ASC_ILLEGAL_OPCODE
);
1654 static void ide_cfata_metadata_inquiry(IDEState
*s
)
1659 p
= (uint16_t *) s
->io_buffer
;
1660 memset(p
, 0, 0x200);
1661 spd
= ((s
->mdata_size
- 1) >> 9) + 1;
1663 put_le16(p
+ 0, 0x0001); /* Data format revision */
1664 put_le16(p
+ 1, 0x0000); /* Media property: silicon */
1665 put_le16(p
+ 2, s
->media_changed
); /* Media status */
1666 put_le16(p
+ 3, s
->mdata_size
& 0xffff); /* Capacity in bytes (low) */
1667 put_le16(p
+ 4, s
->mdata_size
>> 16); /* Capacity in bytes (high) */
1668 put_le16(p
+ 5, spd
& 0xffff); /* Sectors per device (low) */
1669 put_le16(p
+ 6, spd
>> 16); /* Sectors per device (high) */
1672 static void ide_cfata_metadata_read(IDEState
*s
)
1676 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
1677 s
->status
= ERR_STAT
;
1678 s
->error
= ABRT_ERR
;
1682 p
= (uint16_t *) s
->io_buffer
;
1683 memset(p
, 0, 0x200);
1685 put_le16(p
+ 0, s
->media_changed
); /* Media status */
1686 memcpy(p
+ 1, s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1687 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1688 s
->nsector
<< 9), 0x200 - 2));
1691 static void ide_cfata_metadata_write(IDEState
*s
)
1693 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
1694 s
->status
= ERR_STAT
;
1695 s
->error
= ABRT_ERR
;
1699 s
->media_changed
= 0;
1701 memcpy(s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1703 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1704 s
->nsector
<< 9), 0x200 - 2));
1707 /* called when the inserted state of the media has changed */
1708 static void cdrom_change_cb(void *opaque
)
1710 IDEState
*s
= opaque
;
1711 uint64_t nb_sectors
;
1713 bdrv_get_geometry(s
->bs
, &nb_sectors
);
1714 s
->nb_sectors
= nb_sectors
;
1716 s
->sense_key
= SENSE_UNIT_ATTENTION
;
1717 s
->asc
= ASC_MEDIUM_MAY_HAVE_CHANGED
;
1718 s
->cdrom_changed
= 1;
1719 ide_set_irq(s
->bus
);
1722 static void ide_cmd_lba48_transform(IDEState
*s
, int lba48
)
1726 /* handle the 'magic' 0 nsector count conversion here. to avoid
1727 * fiddling with the rest of the read logic, we just store the
1728 * full sector count in ->nsector and ignore ->hob_nsector from now
1734 if (!s
->nsector
&& !s
->hob_nsector
)
1737 int lo
= s
->nsector
;
1738 int hi
= s
->hob_nsector
;
1740 s
->nsector
= (hi
<< 8) | lo
;
1745 static void ide_clear_hob(IDEBus
*bus
)
1747 /* any write clears HOB high bit of device control register */
1748 bus
->ifs
[0].select
&= ~(1 << 7);
1749 bus
->ifs
[1].select
&= ~(1 << 7);
1752 void ide_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
1754 IDEBus
*bus
= opaque
;
1760 printf("IDE: write addr=0x%x val=0x%02x\n", addr
, val
);
1765 /* ignore writes to command block while busy with previous command */
1766 if (addr
!= 7 && (idebus_active_if(bus
)->status
& (BUSY_STAT
|DRQ_STAT
)))
1774 /* NOTE: data is written to the two drives */
1775 bus
->ifs
[0].hob_feature
= bus
->ifs
[0].feature
;
1776 bus
->ifs
[1].hob_feature
= bus
->ifs
[1].feature
;
1777 bus
->ifs
[0].feature
= val
;
1778 bus
->ifs
[1].feature
= val
;
1782 bus
->ifs
[0].hob_nsector
= bus
->ifs
[0].nsector
;
1783 bus
->ifs
[1].hob_nsector
= bus
->ifs
[1].nsector
;
1784 bus
->ifs
[0].nsector
= val
;
1785 bus
->ifs
[1].nsector
= val
;
1789 bus
->ifs
[0].hob_sector
= bus
->ifs
[0].sector
;
1790 bus
->ifs
[1].hob_sector
= bus
->ifs
[1].sector
;
1791 bus
->ifs
[0].sector
= val
;
1792 bus
->ifs
[1].sector
= val
;
1796 bus
->ifs
[0].hob_lcyl
= bus
->ifs
[0].lcyl
;
1797 bus
->ifs
[1].hob_lcyl
= bus
->ifs
[1].lcyl
;
1798 bus
->ifs
[0].lcyl
= val
;
1799 bus
->ifs
[1].lcyl
= val
;
1803 bus
->ifs
[0].hob_hcyl
= bus
->ifs
[0].hcyl
;
1804 bus
->ifs
[1].hob_hcyl
= bus
->ifs
[1].hcyl
;
1805 bus
->ifs
[0].hcyl
= val
;
1806 bus
->ifs
[1].hcyl
= val
;
1809 /* FIXME: HOB readback uses bit 7 */
1810 bus
->ifs
[0].select
= (val
& ~0x10) | 0xa0;
1811 bus
->ifs
[1].select
= (val
| 0x10) | 0xa0;
1813 bus
->unit
= (val
>> 4) & 1;
1818 #if defined(DEBUG_IDE)
1819 printf("ide: CMD=%02x\n", val
);
1821 s
= idebus_active_if(bus
);
1822 /* ignore commands to non existant slave */
1823 if (s
!= bus
->ifs
&& !s
->bs
)
1826 /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
1827 if ((s
->status
& (BUSY_STAT
|DRQ_STAT
)) && val
!= WIN_DEVICE_RESET
)
1832 if (s
->bs
&& !s
->is_cdrom
) {
1836 ide_cfata_identify(s
);
1837 s
->status
= READY_STAT
| SEEK_STAT
;
1838 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
1841 ide_set_signature(s
);
1843 ide_abort_command(s
);
1845 ide_set_irq(s
->bus
);
1850 s
->status
= READY_STAT
| SEEK_STAT
;
1851 ide_set_irq(s
->bus
);
1854 if (s
->is_cf
&& s
->nsector
== 0) {
1855 /* Disable Read and Write Multiple */
1856 s
->mult_sectors
= 0;
1857 s
->status
= READY_STAT
| SEEK_STAT
;
1858 } else if ((s
->nsector
& 0xff) != 0 &&
1859 ((s
->nsector
& 0xff) > MAX_MULT_SECTORS
||
1860 (s
->nsector
& (s
->nsector
- 1)) != 0)) {
1861 ide_abort_command(s
);
1863 s
->mult_sectors
= s
->nsector
& 0xff;
1864 s
->status
= READY_STAT
| SEEK_STAT
;
1866 ide_set_irq(s
->bus
);
1868 case WIN_VERIFY_EXT
:
1871 case WIN_VERIFY_ONCE
:
1872 /* do sector number check ? */
1873 ide_cmd_lba48_transform(s
, lba48
);
1874 s
->status
= READY_STAT
| SEEK_STAT
;
1875 ide_set_irq(s
->bus
);
1883 ide_cmd_lba48_transform(s
, lba48
);
1884 s
->req_nb_sectors
= 1;
1890 case WIN_WRITE_ONCE
:
1891 case CFA_WRITE_SECT_WO_ERASE
:
1892 case WIN_WRITE_VERIFY
:
1893 ide_cmd_lba48_transform(s
, lba48
);
1895 s
->status
= SEEK_STAT
| READY_STAT
;
1896 s
->req_nb_sectors
= 1;
1897 ide_transfer_start(s
, s
->io_buffer
, 512, ide_sector_write
);
1898 s
->media_changed
= 1;
1900 case WIN_MULTREAD_EXT
:
1903 if (!s
->mult_sectors
)
1905 ide_cmd_lba48_transform(s
, lba48
);
1906 s
->req_nb_sectors
= s
->mult_sectors
;
1909 case WIN_MULTWRITE_EXT
:
1912 case CFA_WRITE_MULTI_WO_ERASE
:
1913 if (!s
->mult_sectors
)
1915 ide_cmd_lba48_transform(s
, lba48
);
1917 s
->status
= SEEK_STAT
| READY_STAT
;
1918 s
->req_nb_sectors
= s
->mult_sectors
;
1920 if (n
> s
->req_nb_sectors
)
1921 n
= s
->req_nb_sectors
;
1922 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_write
);
1923 s
->media_changed
= 1;
1925 case WIN_READDMA_EXT
:
1928 case WIN_READDMA_ONCE
:
1931 ide_cmd_lba48_transform(s
, lba48
);
1932 ide_sector_read_dma(s
);
1934 case WIN_WRITEDMA_EXT
:
1937 case WIN_WRITEDMA_ONCE
:
1940 ide_cmd_lba48_transform(s
, lba48
);
1941 ide_sector_write_dma(s
);
1942 s
->media_changed
= 1;
1944 case WIN_READ_NATIVE_MAX_EXT
:
1946 case WIN_READ_NATIVE_MAX
:
1947 ide_cmd_lba48_transform(s
, lba48
);
1948 ide_set_sector(s
, s
->nb_sectors
- 1);
1949 s
->status
= READY_STAT
| SEEK_STAT
;
1950 ide_set_irq(s
->bus
);
1952 case WIN_CHECKPOWERMODE1
:
1953 case WIN_CHECKPOWERMODE2
:
1954 s
->nsector
= 0xff; /* device active or idle */
1955 s
->status
= READY_STAT
| SEEK_STAT
;
1956 ide_set_irq(s
->bus
);
1958 case WIN_SETFEATURES
:
1961 /* XXX: valid for CDROM ? */
1962 switch(s
->feature
) {
1963 case 0xcc: /* reverting to power-on defaults enable */
1964 case 0x66: /* reverting to power-on defaults disable */
1965 case 0x02: /* write cache enable */
1966 case 0x82: /* write cache disable */
1967 case 0xaa: /* read look-ahead enable */
1968 case 0x55: /* read look-ahead disable */
1969 case 0x05: /* set advanced power management mode */
1970 case 0x85: /* disable advanced power management mode */
1971 case 0x69: /* NOP */
1972 case 0x67: /* NOP */
1973 case 0x96: /* NOP */
1974 case 0x9a: /* NOP */
1975 case 0x42: /* enable Automatic Acoustic Mode */
1976 case 0xc2: /* disable Automatic Acoustic Mode */
1977 s
->status
= READY_STAT
| SEEK_STAT
;
1978 ide_set_irq(s
->bus
);
1980 case 0x03: { /* set transfer mode */
1981 uint8_t val
= s
->nsector
& 0x07;
1982 uint16_t *identify_data
= (uint16_t *)s
->identify_data
;
1984 switch (s
->nsector
>> 3) {
1985 case 0x00: /* pio default */
1986 case 0x01: /* pio mode */
1987 put_le16(identify_data
+ 62,0x07);
1988 put_le16(identify_data
+ 63,0x07);
1989 put_le16(identify_data
+ 88,0x3f);
1991 case 0x02: /* sigle word dma mode*/
1992 put_le16(identify_data
+ 62,0x07 | (1 << (val
+ 8)));
1993 put_le16(identify_data
+ 63,0x07);
1994 put_le16(identify_data
+ 88,0x3f);
1996 case 0x04: /* mdma mode */
1997 put_le16(identify_data
+ 62,0x07);
1998 put_le16(identify_data
+ 63,0x07 | (1 << (val
+ 8)));
1999 put_le16(identify_data
+ 88,0x3f);
2001 case 0x08: /* udma mode */
2002 put_le16(identify_data
+ 62,0x07);
2003 put_le16(identify_data
+ 63,0x07);
2004 put_le16(identify_data
+ 88,0x3f | (1 << (val
+ 8)));
2009 s
->status
= READY_STAT
| SEEK_STAT
;
2010 ide_set_irq(s
->bus
);
2017 case WIN_FLUSH_CACHE
:
2018 case WIN_FLUSH_CACHE_EXT
:
2020 bdrv_aio_flush(s
->bs
, ide_flush_cb
, s
);
2026 case WIN_STANDBYNOW1
:
2027 case WIN_STANDBYNOW2
:
2028 case WIN_IDLEIMMEDIATE
:
2029 case CFA_IDLEIMMEDIATE
:
2034 s
->status
= READY_STAT
;
2035 ide_set_irq(s
->bus
);
2040 /* XXX: Check that seek is within bounds */
2041 s
->status
= READY_STAT
| SEEK_STAT
;
2042 ide_set_irq(s
->bus
);
2044 /* ATAPI commands */
2047 ide_atapi_identify(s
);
2048 s
->status
= READY_STAT
| SEEK_STAT
;
2049 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
2051 ide_abort_command(s
);
2053 ide_set_irq(s
->bus
);
2056 ide_set_signature(s
);
2058 s
->status
= 0; /* ATAPI spec (v6) section 9.10 defines packet
2059 * devices to return a clear status register
2060 * with READY_STAT *not* set. */
2062 s
->status
= READY_STAT
| SEEK_STAT
;
2063 s
->error
= 0x01; /* Device 0 passed, Device 1 passed or not
2066 ide_set_irq(s
->bus
);
2071 ide_set_signature(s
);
2072 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2078 /* overlapping commands not supported */
2079 if (s
->feature
& 0x02)
2081 s
->status
= READY_STAT
| SEEK_STAT
;
2082 s
->atapi_dma
= s
->feature
& 1;
2084 ide_transfer_start(s
, s
->io_buffer
, ATAPI_PACKET_SIZE
,
2087 /* CF-ATA commands */
2088 case CFA_REQ_EXT_ERROR_CODE
:
2091 s
->error
= 0x09; /* miscellaneous error */
2092 s
->status
= READY_STAT
| SEEK_STAT
;
2093 ide_set_irq(s
->bus
);
2095 case CFA_ERASE_SECTORS
:
2096 case CFA_WEAR_LEVEL
:
2099 if (val
== CFA_WEAR_LEVEL
)
2101 if (val
== CFA_ERASE_SECTORS
)
2102 s
->media_changed
= 1;
2104 s
->status
= READY_STAT
| SEEK_STAT
;
2105 ide_set_irq(s
->bus
);
2107 case CFA_TRANSLATE_SECTOR
:
2111 s
->status
= READY_STAT
| SEEK_STAT
;
2112 memset(s
->io_buffer
, 0, 0x200);
2113 s
->io_buffer
[0x00] = s
->hcyl
; /* Cyl MSB */
2114 s
->io_buffer
[0x01] = s
->lcyl
; /* Cyl LSB */
2115 s
->io_buffer
[0x02] = s
->select
; /* Head */
2116 s
->io_buffer
[0x03] = s
->sector
; /* Sector */
2117 s
->io_buffer
[0x04] = ide_get_sector(s
) >> 16; /* LBA MSB */
2118 s
->io_buffer
[0x05] = ide_get_sector(s
) >> 8; /* LBA */
2119 s
->io_buffer
[0x06] = ide_get_sector(s
) >> 0; /* LBA LSB */
2120 s
->io_buffer
[0x13] = 0x00; /* Erase flag */
2121 s
->io_buffer
[0x18] = 0x00; /* Hot count */
2122 s
->io_buffer
[0x19] = 0x00; /* Hot count */
2123 s
->io_buffer
[0x1a] = 0x01; /* Hot count */
2124 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2125 ide_set_irq(s
->bus
);
2127 case CFA_ACCESS_METADATA_STORAGE
:
2130 switch (s
->feature
) {
2131 case 0x02: /* Inquiry Metadata Storage */
2132 ide_cfata_metadata_inquiry(s
);
2134 case 0x03: /* Read Metadata Storage */
2135 ide_cfata_metadata_read(s
);
2137 case 0x04: /* Write Metadata Storage */
2138 ide_cfata_metadata_write(s
);
2143 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2144 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2145 ide_set_irq(s
->bus
);
2147 case IBM_SENSE_CONDITION
:
2150 switch (s
->feature
) {
2151 case 0x01: /* sense temperature in device */
2152 s
->nsector
= 0x50; /* +20 C */
2157 s
->status
= READY_STAT
| SEEK_STAT
;
2158 ide_set_irq(s
->bus
);
2164 if (s
->hcyl
!= 0xc2 || s
->lcyl
!= 0x4f)
2166 if (!s
->smart_enabled
&& s
->feature
!= SMART_ENABLE
)
2168 switch (s
->feature
) {
2170 s
->smart_enabled
= 0;
2171 s
->status
= READY_STAT
| SEEK_STAT
;
2172 ide_set_irq(s
->bus
);
2175 s
->smart_enabled
= 1;
2176 s
->status
= READY_STAT
| SEEK_STAT
;
2177 ide_set_irq(s
->bus
);
2179 case SMART_ATTR_AUTOSAVE
:
2180 switch (s
->sector
) {
2182 s
->smart_autosave
= 0;
2185 s
->smart_autosave
= 1;
2190 s
->status
= READY_STAT
| SEEK_STAT
;
2191 ide_set_irq(s
->bus
);
2194 if (!s
->smart_errors
) {
2201 s
->status
= READY_STAT
| SEEK_STAT
;
2202 ide_set_irq(s
->bus
);
2204 case SMART_READ_THRESH
:
2205 memset(s
->io_buffer
, 0, 0x200);
2206 s
->io_buffer
[0] = 0x01; /* smart struct version */
2207 for (n
=0; n
<30; n
++) {
2208 if (smart_attributes
[n
][0] == 0)
2210 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
2211 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][4];
2213 for (n
=0; n
<511; n
++) /* checksum */
2214 s
->io_buffer
[511] += s
->io_buffer
[n
];
2215 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2216 s
->status
= READY_STAT
| SEEK_STAT
;
2217 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2218 ide_set_irq(s
->bus
);
2220 case SMART_READ_DATA
:
2221 memset(s
->io_buffer
, 0, 0x200);
2222 s
->io_buffer
[0] = 0x01; /* smart struct version */
2223 for (n
=0; n
<30; n
++) {
2224 if (smart_attributes
[n
][0] == 0)
2226 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
2227 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][1];
2228 s
->io_buffer
[2+3+(n
*12)] = smart_attributes
[n
][2];
2229 s
->io_buffer
[2+4+(n
*12)] = smart_attributes
[n
][3];
2231 s
->io_buffer
[362] = 0x02 | (s
->smart_autosave
?0x80:0x00);
2232 if (s
->smart_selftest_count
== 0) {
2233 s
->io_buffer
[363] = 0;
2236 s
->smart_selftest_data
[3 +
2237 (s
->smart_selftest_count
- 1) *
2240 s
->io_buffer
[364] = 0x20;
2241 s
->io_buffer
[365] = 0x01;
2242 /* offline data collection capacity: execute + self-test*/
2243 s
->io_buffer
[367] = (1<<4 | 1<<3 | 1);
2244 s
->io_buffer
[368] = 0x03; /* smart capability (1) */
2245 s
->io_buffer
[369] = 0x00; /* smart capability (2) */
2246 s
->io_buffer
[370] = 0x01; /* error logging supported */
2247 s
->io_buffer
[372] = 0x02; /* minutes for poll short test */
2248 s
->io_buffer
[373] = 0x36; /* minutes for poll ext test */
2249 s
->io_buffer
[374] = 0x01; /* minutes for poll conveyance */
2251 for (n
=0; n
<511; n
++)
2252 s
->io_buffer
[511] += s
->io_buffer
[n
];
2253 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2254 s
->status
= READY_STAT
| SEEK_STAT
;
2255 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2256 ide_set_irq(s
->bus
);
2258 case SMART_READ_LOG
:
2259 switch (s
->sector
) {
2260 case 0x01: /* summary smart error log */
2261 memset(s
->io_buffer
, 0, 0x200);
2262 s
->io_buffer
[0] = 0x01;
2263 s
->io_buffer
[1] = 0x00; /* no error entries */
2264 s
->io_buffer
[452] = s
->smart_errors
& 0xff;
2265 s
->io_buffer
[453] = (s
->smart_errors
& 0xff00) >> 8;
2267 for (n
=0; n
<511; n
++)
2268 s
->io_buffer
[511] += s
->io_buffer
[n
];
2269 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2271 case 0x06: /* smart self test log */
2272 memset(s
->io_buffer
, 0, 0x200);
2273 s
->io_buffer
[0] = 0x01;
2274 if (s
->smart_selftest_count
== 0) {
2275 s
->io_buffer
[508] = 0;
2277 s
->io_buffer
[508] = s
->smart_selftest_count
;
2278 for (n
=2; n
<506; n
++)
2279 s
->io_buffer
[n
] = s
->smart_selftest_data
[n
];
2281 for (n
=0; n
<511; n
++)
2282 s
->io_buffer
[511] += s
->io_buffer
[n
];
2283 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2288 s
->status
= READY_STAT
| SEEK_STAT
;
2289 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2290 ide_set_irq(s
->bus
);
2292 case SMART_EXECUTE_OFFLINE
:
2293 switch (s
->sector
) {
2294 case 0: /* off-line routine */
2295 case 1: /* short self test */
2296 case 2: /* extended self test */
2297 s
->smart_selftest_count
++;
2298 if(s
->smart_selftest_count
> 21)
2299 s
->smart_selftest_count
= 0;
2300 n
= 2 + (s
->smart_selftest_count
- 1) * 24;
2301 s
->smart_selftest_data
[n
] = s
->sector
;
2302 s
->smart_selftest_data
[n
+1] = 0x00; /* OK and finished */
2303 s
->smart_selftest_data
[n
+2] = 0x34; /* hour count lsb */
2304 s
->smart_selftest_data
[n
+3] = 0x12; /* hour count msb */
2305 s
->status
= READY_STAT
| SEEK_STAT
;
2306 ide_set_irq(s
->bus
);
2318 ide_abort_command(s
);
2319 ide_set_irq(s
->bus
);
2325 uint32_t ide_ioport_read(void *opaque
, uint32_t addr1
)
2327 IDEBus
*bus
= opaque
;
2328 IDEState
*s
= idebus_active_if(bus
);
2333 /* FIXME: HOB readback uses bit 7, but it's always set right now */
2334 //hob = s->select & (1 << 7);
2341 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2342 (s
!= bus
->ifs
&& !s
->bs
))
2347 ret
= s
->hob_feature
;
2350 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2353 ret
= s
->nsector
& 0xff;
2355 ret
= s
->hob_nsector
;
2358 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2363 ret
= s
->hob_sector
;
2366 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2374 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2382 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2389 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2390 (s
!= bus
->ifs
&& !s
->bs
))
2394 qemu_irq_lower(bus
->irq
);
2398 printf("ide: read addr=0x%x val=%02x\n", addr1
, ret
);
2403 uint32_t ide_status_read(void *opaque
, uint32_t addr
)
2405 IDEBus
*bus
= opaque
;
2406 IDEState
*s
= idebus_active_if(bus
);
2409 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2410 (s
!= bus
->ifs
&& !s
->bs
))
2415 printf("ide: read status addr=0x%x val=%02x\n", addr
, ret
);
2420 void ide_cmd_write(void *opaque
, uint32_t addr
, uint32_t val
)
2422 IDEBus
*bus
= opaque
;
2427 printf("ide: write control addr=0x%x val=%02x\n", addr
, val
);
2429 /* common for both drives */
2430 if (!(bus
->cmd
& IDE_CMD_RESET
) &&
2431 (val
& IDE_CMD_RESET
)) {
2432 /* reset low to high */
2433 for(i
= 0;i
< 2; i
++) {
2435 s
->status
= BUSY_STAT
| SEEK_STAT
;
2438 } else if ((bus
->cmd
& IDE_CMD_RESET
) &&
2439 !(val
& IDE_CMD_RESET
)) {
2441 for(i
= 0;i
< 2; i
++) {
2444 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2446 s
->status
= READY_STAT
| SEEK_STAT
;
2447 ide_set_signature(s
);
2454 void ide_data_writew(void *opaque
, uint32_t addr
, uint32_t val
)
2456 IDEBus
*bus
= opaque
;
2457 IDEState
*s
= idebus_active_if(bus
);
2460 /* PIO data access allowed only when DRQ bit is set */
2461 if (!(s
->status
& DRQ_STAT
))
2465 *(uint16_t *)p
= le16_to_cpu(val
);
2468 if (p
>= s
->data_end
)
2469 s
->end_transfer_func(s
);
2472 uint32_t ide_data_readw(void *opaque
, uint32_t addr
)
2474 IDEBus
*bus
= opaque
;
2475 IDEState
*s
= idebus_active_if(bus
);
2479 /* PIO data access allowed only when DRQ bit is set */
2480 if (!(s
->status
& DRQ_STAT
))
2484 ret
= cpu_to_le16(*(uint16_t *)p
);
2487 if (p
>= s
->data_end
)
2488 s
->end_transfer_func(s
);
2492 void ide_data_writel(void *opaque
, uint32_t addr
, uint32_t val
)
2494 IDEBus
*bus
= opaque
;
2495 IDEState
*s
= idebus_active_if(bus
);
2498 /* PIO data access allowed only when DRQ bit is set */
2499 if (!(s
->status
& DRQ_STAT
))
2503 *(uint32_t *)p
= le32_to_cpu(val
);
2506 if (p
>= s
->data_end
)
2507 s
->end_transfer_func(s
);
2510 uint32_t ide_data_readl(void *opaque
, uint32_t addr
)
2512 IDEBus
*bus
= opaque
;
2513 IDEState
*s
= idebus_active_if(bus
);
2517 /* PIO data access allowed only when DRQ bit is set */
2518 if (!(s
->status
& DRQ_STAT
))
2522 ret
= cpu_to_le32(*(uint32_t *)p
);
2525 if (p
>= s
->data_end
)
2526 s
->end_transfer_func(s
);
2530 static void ide_dummy_transfer_stop(IDEState
*s
)
2532 s
->data_ptr
= s
->io_buffer
;
2533 s
->data_end
= s
->io_buffer
;
2534 s
->io_buffer
[0] = 0xff;
2535 s
->io_buffer
[1] = 0xff;
2536 s
->io_buffer
[2] = 0xff;
2537 s
->io_buffer
[3] = 0xff;
2540 static void ide_reset(IDEState
*s
)
2543 printf("ide: reset\n");
2546 s
->mult_sectors
= 0;
2548 s
->mult_sectors
= MAX_MULT_SECTORS
;
2565 s
->status
= READY_STAT
| SEEK_STAT
;
2569 /* ATAPI specific */
2572 s
->cdrom_changed
= 0;
2573 s
->packet_transfer_size
= 0;
2574 s
->elementary_transfer_size
= 0;
2575 s
->io_buffer_index
= 0;
2576 s
->cd_sector_size
= 0;
2579 s
->io_buffer_size
= 0;
2580 s
->req_nb_sectors
= 0;
2582 ide_set_signature(s
);
2583 /* init the transfer handler so that 0xffff is returned on data
2585 s
->end_transfer_func
= ide_dummy_transfer_stop
;
2586 ide_dummy_transfer_stop(s
);
2587 s
->media_changed
= 0;
2590 void ide_bus_reset(IDEBus
*bus
)
2594 ide_reset(&bus
->ifs
[0]);
2595 ide_reset(&bus
->ifs
[1]);
2599 void ide_init_drive(IDEState
*s
, DriveInfo
*dinfo
, BlockConf
*conf
,
2600 const char *version
)
2602 int cylinders
, heads
, secs
;
2603 uint64_t nb_sectors
;
2605 if (dinfo
&& dinfo
->bdrv
) {
2606 s
->bs
= dinfo
->bdrv
;
2607 bdrv_get_geometry(s
->bs
, &nb_sectors
);
2608 bdrv_guess_geometry(s
->bs
, &cylinders
, &heads
, &secs
);
2609 s
->cylinders
= cylinders
;
2612 s
->nb_sectors
= nb_sectors
;
2613 /* The SMART values should be preserved across power cycles
2615 s
->smart_enabled
= 1;
2616 s
->smart_autosave
= 1;
2617 s
->smart_errors
= 0;
2618 s
->smart_selftest_count
= 0;
2619 if (bdrv_get_type_hint(s
->bs
) == BDRV_TYPE_CDROM
) {
2621 bdrv_set_change_cb(s
->bs
, cdrom_change_cb
, s
);
2623 strncpy(s
->drive_serial_str
, drive_get_serial(s
->bs
),
2624 sizeof(s
->drive_serial_str
));
2629 if (strlen(s
->drive_serial_str
) == 0)
2630 snprintf(s
->drive_serial_str
, sizeof(s
->drive_serial_str
),
2631 "QM%05d", s
->drive_serial
);
2633 pstrcpy(s
->version
, sizeof(s
->version
), version
);
2635 pstrcpy(s
->version
, sizeof(s
->version
), QEMU_VERSION
);
2640 void ide_init2(IDEBus
*bus
, DriveInfo
*hd0
, DriveInfo
*hd1
,
2644 static int drive_serial
= 1;
2647 for(i
= 0; i
< 2; i
++) {
2651 s
->drive_serial
= drive_serial
++;
2652 s
->io_buffer
= qemu_blockalign(s
->bs
, IDE_DMA_BUF_SECTORS
*512 + 4);
2653 s
->io_buffer_total_len
= IDE_DMA_BUF_SECTORS
*512 + 4;
2654 s
->smart_selftest_data
= qemu_blockalign(s
->bs
, 512);
2655 s
->sector_write_timer
= qemu_new_timer(vm_clock
,
2656 ide_sector_write_timer_cb
, s
);
2658 ide_init_drive(s
, hd0
, NULL
, NULL
);
2660 ide_init_drive(s
, hd1
, NULL
, NULL
);
2665 void ide_init_ioport(IDEBus
*bus
, int iobase
, int iobase2
)
2667 register_ioport_write(iobase
, 8, 1, ide_ioport_write
, bus
);
2668 register_ioport_read(iobase
, 8, 1, ide_ioport_read
, bus
);
2670 register_ioport_read(iobase2
, 1, 1, ide_status_read
, bus
);
2671 register_ioport_write(iobase2
, 1, 1, ide_cmd_write
, bus
);
2675 register_ioport_write(iobase
, 2, 2, ide_data_writew
, bus
);
2676 register_ioport_read(iobase
, 2, 2, ide_data_readw
, bus
);
2677 register_ioport_write(iobase
, 4, 4, ide_data_writel
, bus
);
2678 register_ioport_read(iobase
, 4, 4, ide_data_readl
, bus
);
2681 static bool is_identify_set(void *opaque
, int version_id
)
2683 IDEState
*s
= opaque
;
2685 return s
->identify_set
!= 0;
2688 static EndTransferFunc
* transfer_end_table
[] = {
2692 ide_atapi_cmd_reply_end
,
2696 static int transfer_end_table_idx(EndTransferFunc
*fn
)
2700 for (i
= 0; i
< ARRAY_SIZE(transfer_end_table
); i
++)
2701 if (transfer_end_table
[i
] == fn
)
2707 static int ide_drive_post_load(void *opaque
, int version_id
)
2709 IDEState
*s
= opaque
;
2711 if (version_id
< 3) {
2712 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
2713 s
->asc
== ASC_MEDIUM_MAY_HAVE_CHANGED
) {
2714 s
->cdrom_changed
= 1;
2718 if (s
->cur_io_buffer_len
) {
2719 s
->end_transfer_func
= transfer_end_table
[s
->end_transfer_fn_idx
];
2720 s
->data_ptr
= s
->io_buffer
+ s
->cur_io_buffer_offset
;
2721 s
->data_end
= s
->data_ptr
+ s
->cur_io_buffer_len
;
2727 static void ide_drive_pre_save(void *opaque
)
2729 IDEState
*s
= opaque
;
2732 s
->cur_io_buffer_len
= 0;
2734 if (!(s
->status
& DRQ_STAT
))
2737 s
->cur_io_buffer_offset
= s
->data_ptr
- s
->io_buffer
;
2738 s
->cur_io_buffer_len
= s
->data_end
- s
->data_ptr
;
2740 idx
= transfer_end_table_idx(s
->end_transfer_func
);
2742 fprintf(stderr
, "%s: invalid end_transfer_func for DRQ_STAT\n",
2744 s
->end_transfer_fn_idx
= 2;
2746 s
->end_transfer_fn_idx
= idx
;
2750 const VMStateDescription vmstate_ide_drive
= {
2751 .name
= "ide_drive",
2753 .minimum_version_id
= 0,
2754 .minimum_version_id_old
= 0,
2755 .pre_save
= ide_drive_pre_save
,
2756 .post_load
= ide_drive_post_load
,
2757 .fields
= (VMStateField
[]) {
2758 VMSTATE_INT32(mult_sectors
, IDEState
),
2759 VMSTATE_INT32(identify_set
, IDEState
),
2760 VMSTATE_BUFFER_TEST(identify_data
, IDEState
, is_identify_set
),
2761 VMSTATE_UINT8(feature
, IDEState
),
2762 VMSTATE_UINT8(error
, IDEState
),
2763 VMSTATE_UINT32(nsector
, IDEState
),
2764 VMSTATE_UINT8(sector
, IDEState
),
2765 VMSTATE_UINT8(lcyl
, IDEState
),
2766 VMSTATE_UINT8(hcyl
, IDEState
),
2767 VMSTATE_UINT8(hob_feature
, IDEState
),
2768 VMSTATE_UINT8(hob_sector
, IDEState
),
2769 VMSTATE_UINT8(hob_nsector
, IDEState
),
2770 VMSTATE_UINT8(hob_lcyl
, IDEState
),
2771 VMSTATE_UINT8(hob_hcyl
, IDEState
),
2772 VMSTATE_UINT8(select
, IDEState
),
2773 VMSTATE_UINT8(status
, IDEState
),
2774 VMSTATE_UINT8(lba48
, IDEState
),
2775 VMSTATE_UINT8(sense_key
, IDEState
),
2776 VMSTATE_UINT8(asc
, IDEState
),
2777 VMSTATE_UINT8_V(cdrom_changed
, IDEState
, 3),
2778 VMSTATE_INT32_V(req_nb_sectors
, IDEState
, 4),
2779 VMSTATE_VARRAY_INT32(io_buffer
, IDEState
, io_buffer_total_len
, 4,
2780 vmstate_info_uint8
, uint8_t),
2781 VMSTATE_INT32_V(cur_io_buffer_offset
, IDEState
, 4),
2782 VMSTATE_INT32_V(cur_io_buffer_len
, IDEState
, 4),
2783 VMSTATE_UINT8_V(end_transfer_fn_idx
, IDEState
, 4),
2784 VMSTATE_INT32_V(elementary_transfer_size
, IDEState
, 4),
2785 VMSTATE_INT32_V(packet_transfer_size
, IDEState
, 4),
2786 VMSTATE_END_OF_LIST()
2790 const VMStateDescription vmstate_ide_bus
= {
2793 .minimum_version_id
= 1,
2794 .minimum_version_id_old
= 1,
2795 .fields
= (VMStateField
[]) {
2796 VMSTATE_UINT8(cmd
, IDEBus
),
2797 VMSTATE_UINT8(unit
, IDEBus
),
2798 VMSTATE_END_OF_LIST()
2802 /***********************************************************/
2803 /* PCI IDE definitions */
2805 static void ide_dma_start(IDEState
*s
, BlockDriverCompletionFunc
*dma_cb
)
2807 BMDMAState
*bm
= s
->bus
->bmdma
;
2811 bm
->dma_cb
= dma_cb
;
2812 bm
->cur_prd_last
= 0;
2813 bm
->cur_prd_addr
= 0;
2814 bm
->cur_prd_len
= 0;
2815 bm
->sector_num
= ide_get_sector(s
);
2816 bm
->nsector
= s
->nsector
;
2817 if (bm
->status
& BM_STATUS_DMAING
) {
2822 static void ide_dma_restart(IDEState
*s
, int is_read
)
2824 BMDMAState
*bm
= s
->bus
->bmdma
;
2825 ide_set_sector(s
, bm
->sector_num
);
2826 s
->io_buffer_index
= 0;
2827 s
->io_buffer_size
= 0;
2828 s
->nsector
= bm
->nsector
;
2829 bm
->cur_addr
= bm
->addr
;
2832 bm
->dma_cb
= ide_read_dma_cb
;
2834 bm
->dma_cb
= ide_write_dma_cb
;
2837 ide_dma_start(s
, bm
->dma_cb
);
2840 void ide_dma_cancel(BMDMAState
*bm
)
2842 if (bm
->status
& BM_STATUS_DMAING
) {
2843 bm
->status
&= ~BM_STATUS_DMAING
;
2844 /* cancel DMA request */
2849 printf("aio_cancel\n");
2851 bdrv_aio_cancel(bm
->aiocb
);
2857 void ide_dma_reset(BMDMAState
*bm
)
2860 printf("ide: dma_reset\n");
2867 bm
->cur_prd_last
= 0;
2868 bm
->cur_prd_addr
= 0;
2869 bm
->cur_prd_len
= 0;