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-timer.h"
33 #include <hw/ide/internal.h>
35 #define IDE_PAGE_SIZE 4096
37 static const int smart_attributes
[][5] = {
38 /* id, flags, val, wrst, thrsh */
39 { 0x01, 0x03, 0x64, 0x64, 0x06}, /* raw read */
40 { 0x03, 0x03, 0x64, 0x64, 0x46}, /* spin up */
41 { 0x04, 0x02, 0x64, 0x64, 0x14}, /* start stop count */
42 { 0x05, 0x03, 0x64, 0x64, 0x36}, /* remapped sectors */
43 { 0x00, 0x00, 0x00, 0x00, 0x00}
46 /* XXX: DVDs that could fit on a CD will be reported as a CD */
47 static inline int media_present(IDEState
*s
)
49 return (s
->nb_sectors
> 0);
52 static inline int media_is_dvd(IDEState
*s
)
54 return (media_present(s
) && s
->nb_sectors
> CD_MAX_SECTORS
);
57 static inline int media_is_cd(IDEState
*s
)
59 return (media_present(s
) && s
->nb_sectors
<= CD_MAX_SECTORS
);
62 static void ide_dma_start(IDEState
*s
, BlockDriverCompletionFunc
*dma_cb
);
63 static void ide_dma_restart(IDEState
*s
, int is_read
);
64 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
);
65 static int ide_handle_rw_error(IDEState
*s
, int error
, int op
);
67 static void padstr(char *str
, const char *src
, int len
)
70 for(i
= 0; i
< len
; i
++) {
79 static void padstr8(uint8_t *buf
, int buf_size
, const char *src
)
82 for(i
= 0; i
< buf_size
; i
++) {
90 static void put_le16(uint16_t *p
, unsigned int v
)
95 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 dev
= s
->unit
? s
->bus
->slave
: s
->bus
->master
;
168 if (dev
&& dev
->conf
.physical_block_size
)
169 put_le16(p
+ 106, 0x6000 | get_physical_block_exp(&dev
->conf
));
171 memcpy(s
->identify_data
, p
, sizeof(s
->identify_data
));
175 static void ide_atapi_identify(IDEState
*s
)
179 if (s
->identify_set
) {
180 memcpy(s
->io_buffer
, s
->identify_data
, sizeof(s
->identify_data
));
184 memset(s
->io_buffer
, 0, 512);
185 p
= (uint16_t *)s
->io_buffer
;
186 /* Removable CDROM, 50us response, 12 byte packets */
187 put_le16(p
+ 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
188 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
189 put_le16(p
+ 20, 3); /* buffer type */
190 put_le16(p
+ 21, 512); /* cache size in sectors */
191 put_le16(p
+ 22, 4); /* ecc bytes */
192 padstr((char *)(p
+ 23), s
->version
, 8); /* firmware version */
193 padstr((char *)(p
+ 27), "QEMU DVD-ROM", 40); /* model */
194 put_le16(p
+ 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
196 put_le16(p
+ 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
197 put_le16(p
+ 53, 7); /* words 64-70, 54-58, 88 valid */
198 put_le16(p
+ 62, 7); /* single word dma0-2 supported */
199 put_le16(p
+ 63, 7); /* mdma0-2 supported */
200 put_le16(p
+ 64, 0x3f); /* PIO modes supported */
202 put_le16(p
+ 49, 1 << 9); /* LBA supported, no DMA */
203 put_le16(p
+ 53, 3); /* words 64-70, 54-58 valid */
204 put_le16(p
+ 63, 0x103); /* DMA modes XXX: may be incorrect */
205 put_le16(p
+ 64, 1); /* PIO modes */
207 put_le16(p
+ 65, 0xb4); /* minimum DMA multiword tx cycle time */
208 put_le16(p
+ 66, 0xb4); /* recommended DMA multiword tx cycle time */
209 put_le16(p
+ 67, 0x12c); /* minimum PIO cycle time without flow control */
210 put_le16(p
+ 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
212 put_le16(p
+ 71, 30); /* in ns */
213 put_le16(p
+ 72, 30); /* in ns */
215 put_le16(p
+ 80, 0x1e); /* support up to ATA/ATAPI-4 */
217 put_le16(p
+ 88, 0x3f | (1 << 13)); /* udma5 set and supported */
219 memcpy(s
->identify_data
, p
, sizeof(s
->identify_data
));
223 static void ide_cfata_identify(IDEState
*s
)
228 p
= (uint16_t *) s
->identify_data
;
232 memset(p
, 0, sizeof(s
->identify_data
));
234 cur_sec
= s
->cylinders
* s
->heads
* s
->sectors
;
236 put_le16(p
+ 0, 0x848a); /* CF Storage Card signature */
237 put_le16(p
+ 1, s
->cylinders
); /* Default cylinders */
238 put_le16(p
+ 3, s
->heads
); /* Default heads */
239 put_le16(p
+ 6, s
->sectors
); /* Default sectors per track */
240 put_le16(p
+ 7, s
->nb_sectors
>> 16); /* Sectors per card */
241 put_le16(p
+ 8, s
->nb_sectors
); /* Sectors per card */
242 padstr((char *)(p
+ 10), s
->drive_serial_str
, 20); /* serial number */
243 put_le16(p
+ 22, 0x0004); /* ECC bytes */
244 padstr((char *) (p
+ 23), s
->version
, 8); /* Firmware Revision */
245 padstr((char *) (p
+ 27), "QEMU MICRODRIVE", 40);/* Model number */
246 #if MAX_MULT_SECTORS > 1
247 put_le16(p
+ 47, 0x8000 | MAX_MULT_SECTORS
);
249 put_le16(p
+ 47, 0x0000);
251 put_le16(p
+ 49, 0x0f00); /* Capabilities */
252 put_le16(p
+ 51, 0x0002); /* PIO cycle timing mode */
253 put_le16(p
+ 52, 0x0001); /* DMA cycle timing mode */
254 put_le16(p
+ 53, 0x0003); /* Translation params valid */
255 put_le16(p
+ 54, s
->cylinders
); /* Current cylinders */
256 put_le16(p
+ 55, s
->heads
); /* Current heads */
257 put_le16(p
+ 56, s
->sectors
); /* Current sectors */
258 put_le16(p
+ 57, cur_sec
); /* Current capacity */
259 put_le16(p
+ 58, cur_sec
>> 16); /* Current capacity */
260 if (s
->mult_sectors
) /* Multiple sector setting */
261 put_le16(p
+ 59, 0x100 | s
->mult_sectors
);
262 put_le16(p
+ 60, s
->nb_sectors
); /* Total LBA sectors */
263 put_le16(p
+ 61, s
->nb_sectors
>> 16); /* Total LBA sectors */
264 put_le16(p
+ 63, 0x0203); /* Multiword DMA capability */
265 put_le16(p
+ 64, 0x0001); /* Flow Control PIO support */
266 put_le16(p
+ 65, 0x0096); /* Min. Multiword DMA cycle */
267 put_le16(p
+ 66, 0x0096); /* Rec. Multiword DMA cycle */
268 put_le16(p
+ 68, 0x00b4); /* Min. PIO cycle time */
269 put_le16(p
+ 82, 0x400c); /* Command Set supported */
270 put_le16(p
+ 83, 0x7068); /* Command Set supported */
271 put_le16(p
+ 84, 0x4000); /* Features supported */
272 put_le16(p
+ 85, 0x000c); /* Command Set enabled */
273 put_le16(p
+ 86, 0x7044); /* Command Set enabled */
274 put_le16(p
+ 87, 0x4000); /* Features enabled */
275 put_le16(p
+ 91, 0x4060); /* Current APM level */
276 put_le16(p
+ 129, 0x0002); /* Current features option */
277 put_le16(p
+ 130, 0x0005); /* Reassigned sectors */
278 put_le16(p
+ 131, 0x0001); /* Initial power mode */
279 put_le16(p
+ 132, 0x0000); /* User signature */
280 put_le16(p
+ 160, 0x8100); /* Power requirement */
281 put_le16(p
+ 161, 0x8001); /* CF command set */
286 memcpy(s
->io_buffer
, p
, sizeof(s
->identify_data
));
289 static void ide_set_signature(IDEState
*s
)
291 s
->select
&= 0xf0; /* clear head */
307 static inline void ide_abort_command(IDEState
*s
)
309 s
->status
= READY_STAT
| ERR_STAT
;
313 static inline void ide_dma_submit_check(IDEState
*s
,
314 BlockDriverCompletionFunc
*dma_cb
, BMDMAState
*bm
)
321 /* prepare data transfer and tell what to do after */
322 static void ide_transfer_start(IDEState
*s
, uint8_t *buf
, int size
,
323 EndTransferFunc
*end_transfer_func
)
325 s
->end_transfer_func
= end_transfer_func
;
327 s
->data_end
= buf
+ size
;
328 if (!(s
->status
& ERR_STAT
))
329 s
->status
|= DRQ_STAT
;
332 static void ide_transfer_stop(IDEState
*s
)
334 s
->end_transfer_func
= ide_transfer_stop
;
335 s
->data_ptr
= s
->io_buffer
;
336 s
->data_end
= s
->io_buffer
;
337 s
->status
&= ~DRQ_STAT
;
340 int64_t ide_get_sector(IDEState
*s
)
343 if (s
->select
& 0x40) {
346 sector_num
= ((s
->select
& 0x0f) << 24) | (s
->hcyl
<< 16) |
347 (s
->lcyl
<< 8) | s
->sector
;
349 sector_num
= ((int64_t)s
->hob_hcyl
<< 40) |
350 ((int64_t) s
->hob_lcyl
<< 32) |
351 ((int64_t) s
->hob_sector
<< 24) |
352 ((int64_t) s
->hcyl
<< 16) |
353 ((int64_t) s
->lcyl
<< 8) | s
->sector
;
356 sector_num
= ((s
->hcyl
<< 8) | s
->lcyl
) * s
->heads
* s
->sectors
+
357 (s
->select
& 0x0f) * s
->sectors
+ (s
->sector
- 1);
362 void ide_set_sector(IDEState
*s
, int64_t sector_num
)
365 if (s
->select
& 0x40) {
367 s
->select
= (s
->select
& 0xf0) | (sector_num
>> 24);
368 s
->hcyl
= (sector_num
>> 16);
369 s
->lcyl
= (sector_num
>> 8);
370 s
->sector
= (sector_num
);
372 s
->sector
= sector_num
;
373 s
->lcyl
= sector_num
>> 8;
374 s
->hcyl
= sector_num
>> 16;
375 s
->hob_sector
= sector_num
>> 24;
376 s
->hob_lcyl
= sector_num
>> 32;
377 s
->hob_hcyl
= sector_num
>> 40;
380 cyl
= sector_num
/ (s
->heads
* s
->sectors
);
381 r
= sector_num
% (s
->heads
* s
->sectors
);
384 s
->select
= (s
->select
& 0xf0) | ((r
/ s
->sectors
) & 0x0f);
385 s
->sector
= (r
% s
->sectors
) + 1;
389 static void ide_rw_error(IDEState
*s
) {
390 ide_abort_command(s
);
394 static void ide_sector_read(IDEState
*s
)
399 s
->status
= READY_STAT
| SEEK_STAT
;
400 s
->error
= 0; /* not needed by IDE spec, but needed by Windows */
401 sector_num
= ide_get_sector(s
);
404 /* no more sector to read from disk */
405 ide_transfer_stop(s
);
407 #if defined(DEBUG_IDE)
408 printf("read sector=%" PRId64
"\n", sector_num
);
410 if (n
> s
->req_nb_sectors
)
411 n
= s
->req_nb_sectors
;
412 ret
= bdrv_read(s
->bs
, sector_num
, s
->io_buffer
, n
);
414 if (ide_handle_rw_error(s
, -ret
,
415 BM_STATUS_PIO_RETRY
| BM_STATUS_RETRY_READ
))
420 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_read
);
422 ide_set_sector(s
, sector_num
+ n
);
428 /* return 0 if buffer completed */
429 static int dma_buf_prepare(BMDMAState
*bm
, int is_write
)
431 IDEState
*s
= bmdma_active_if(bm
);
438 qemu_sglist_init(&s
->sg
, s
->nsector
/ (IDE_PAGE_SIZE
/ 512) + 1);
439 s
->io_buffer_size
= 0;
441 if (bm
->cur_prd_len
== 0) {
442 /* end of table (with a fail safe of one page) */
443 if (bm
->cur_prd_last
||
444 (bm
->cur_addr
- bm
->addr
) >= IDE_PAGE_SIZE
)
445 return s
->io_buffer_size
!= 0;
446 cpu_physical_memory_read(bm
->cur_addr
, (uint8_t *)&prd
, 8);
448 prd
.addr
= le32_to_cpu(prd
.addr
);
449 prd
.size
= le32_to_cpu(prd
.size
);
450 len
= prd
.size
& 0xfffe;
453 bm
->cur_prd_len
= len
;
454 bm
->cur_prd_addr
= prd
.addr
;
455 bm
->cur_prd_last
= (prd
.size
& 0x80000000);
459 qemu_sglist_add(&s
->sg
, bm
->cur_prd_addr
, l
);
460 bm
->cur_prd_addr
+= l
;
461 bm
->cur_prd_len
-= l
;
462 s
->io_buffer_size
+= l
;
468 static void dma_buf_commit(IDEState
*s
, int is_write
)
470 qemu_sglist_destroy(&s
->sg
);
473 void ide_dma_error(IDEState
*s
)
475 ide_transfer_stop(s
);
477 s
->status
= READY_STAT
| ERR_STAT
;
481 static int ide_handle_rw_error(IDEState
*s
, int error
, int op
)
483 int is_read
= (op
& BM_STATUS_RETRY_READ
);
484 BlockErrorAction action
= bdrv_get_on_error(s
->bs
, is_read
);
486 if (action
== BLOCK_ERR_IGNORE
) {
487 bdrv_mon_event(s
->bs
, BDRV_ACTION_IGNORE
, is_read
);
491 if ((error
== ENOSPC
&& action
== BLOCK_ERR_STOP_ENOSPC
)
492 || action
== BLOCK_ERR_STOP_ANY
) {
493 s
->bus
->bmdma
->unit
= s
->unit
;
494 s
->bus
->bmdma
->status
|= op
;
495 bdrv_mon_event(s
->bs
, BDRV_ACTION_STOP
, is_read
);
498 if (op
& BM_STATUS_DMA_RETRY
) {
499 dma_buf_commit(s
, 0);
504 bdrv_mon_event(s
->bs
, BDRV_ACTION_REPORT
, is_read
);
510 /* return 0 if buffer completed */
511 static int dma_buf_rw(BMDMAState
*bm
, int is_write
)
513 IDEState
*s
= bmdma_active_if(bm
);
521 l
= s
->io_buffer_size
- s
->io_buffer_index
;
524 if (bm
->cur_prd_len
== 0) {
525 /* end of table (with a fail safe of one page) */
526 if (bm
->cur_prd_last
||
527 (bm
->cur_addr
- bm
->addr
) >= IDE_PAGE_SIZE
)
529 cpu_physical_memory_read(bm
->cur_addr
, (uint8_t *)&prd
, 8);
531 prd
.addr
= le32_to_cpu(prd
.addr
);
532 prd
.size
= le32_to_cpu(prd
.size
);
533 len
= prd
.size
& 0xfffe;
536 bm
->cur_prd_len
= len
;
537 bm
->cur_prd_addr
= prd
.addr
;
538 bm
->cur_prd_last
= (prd
.size
& 0x80000000);
540 if (l
> bm
->cur_prd_len
)
544 cpu_physical_memory_write(bm
->cur_prd_addr
,
545 s
->io_buffer
+ s
->io_buffer_index
, l
);
547 cpu_physical_memory_read(bm
->cur_prd_addr
,
548 s
->io_buffer
+ s
->io_buffer_index
, l
);
550 bm
->cur_prd_addr
+= l
;
551 bm
->cur_prd_len
-= l
;
552 s
->io_buffer_index
+= l
;
558 static void ide_read_dma_cb(void *opaque
, int ret
)
560 BMDMAState
*bm
= opaque
;
561 IDEState
*s
= bmdma_active_if(bm
);
566 if (ide_handle_rw_error(s
, -ret
,
567 BM_STATUS_DMA_RETRY
| BM_STATUS_RETRY_READ
))
573 n
= s
->io_buffer_size
>> 9;
574 sector_num
= ide_get_sector(s
);
576 dma_buf_commit(s
, 1);
578 ide_set_sector(s
, sector_num
);
582 /* end of transfer ? */
583 if (s
->nsector
== 0) {
584 s
->status
= READY_STAT
| SEEK_STAT
;
587 bm
->status
&= ~BM_STATUS_DMAING
;
588 bm
->status
|= BM_STATUS_INT
;
595 /* launch next transfer */
597 s
->io_buffer_index
= 0;
598 s
->io_buffer_size
= n
* 512;
599 if (dma_buf_prepare(bm
, 1) == 0)
602 printf("aio_read: sector_num=%" PRId64
" n=%d\n", sector_num
, n
);
604 bm
->aiocb
= dma_bdrv_read(s
->bs
, &s
->sg
, sector_num
, ide_read_dma_cb
, bm
);
605 ide_dma_submit_check(s
, ide_read_dma_cb
, bm
);
608 static void ide_sector_read_dma(IDEState
*s
)
610 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
611 s
->io_buffer_index
= 0;
612 s
->io_buffer_size
= 0;
614 ide_dma_start(s
, ide_read_dma_cb
);
617 static void ide_sector_write_timer_cb(void *opaque
)
619 IDEState
*s
= opaque
;
623 static void ide_sector_write(IDEState
*s
)
628 s
->status
= READY_STAT
| SEEK_STAT
;
629 sector_num
= ide_get_sector(s
);
630 #if defined(DEBUG_IDE)
631 printf("write sector=%" PRId64
"\n", sector_num
);
634 if (n
> s
->req_nb_sectors
)
635 n
= s
->req_nb_sectors
;
636 ret
= bdrv_write(s
->bs
, sector_num
, s
->io_buffer
, n
);
639 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_PIO_RETRY
))
644 if (s
->nsector
== 0) {
645 /* no more sectors to write */
646 ide_transfer_stop(s
);
649 if (n1
> s
->req_nb_sectors
)
650 n1
= s
->req_nb_sectors
;
651 ide_transfer_start(s
, s
->io_buffer
, 512 * n1
, ide_sector_write
);
653 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));
669 static void ide_dma_restart_bh(void *opaque
)
671 BMDMAState
*bm
= opaque
;
674 qemu_bh_delete(bm
->bh
);
677 is_read
= !!(bm
->status
& BM_STATUS_RETRY_READ
);
679 if (bm
->status
& BM_STATUS_DMA_RETRY
) {
680 bm
->status
&= ~(BM_STATUS_DMA_RETRY
| BM_STATUS_RETRY_READ
);
681 ide_dma_restart(bmdma_active_if(bm
), is_read
);
682 } else if (bm
->status
& BM_STATUS_PIO_RETRY
) {
683 bm
->status
&= ~(BM_STATUS_PIO_RETRY
| BM_STATUS_RETRY_READ
);
685 ide_sector_read(bmdma_active_if(bm
));
687 ide_sector_write(bmdma_active_if(bm
));
692 void ide_dma_restart_cb(void *opaque
, int running
, int reason
)
694 BMDMAState
*bm
= opaque
;
700 bm
->bh
= qemu_bh_new(ide_dma_restart_bh
, bm
);
701 qemu_bh_schedule(bm
->bh
);
705 static void ide_write_dma_cb(void *opaque
, int ret
)
707 BMDMAState
*bm
= opaque
;
708 IDEState
*s
= bmdma_active_if(bm
);
713 if (ide_handle_rw_error(s
, -ret
, BM_STATUS_DMA_RETRY
))
717 n
= s
->io_buffer_size
>> 9;
718 sector_num
= ide_get_sector(s
);
720 dma_buf_commit(s
, 0);
722 ide_set_sector(s
, sector_num
);
726 /* end of transfer ? */
727 if (s
->nsector
== 0) {
728 s
->status
= READY_STAT
| SEEK_STAT
;
731 bm
->status
&= ~BM_STATUS_DMAING
;
732 bm
->status
|= BM_STATUS_INT
;
740 s
->io_buffer_size
= n
* 512;
741 /* launch next transfer */
742 if (dma_buf_prepare(bm
, 0) == 0)
745 printf("aio_write: sector_num=%" PRId64
" n=%d\n", sector_num
, n
);
747 bm
->aiocb
= dma_bdrv_write(s
->bs
, &s
->sg
, sector_num
, ide_write_dma_cb
, bm
);
748 ide_dma_submit_check(s
, ide_write_dma_cb
, bm
);
751 static void ide_sector_write_dma(IDEState
*s
)
753 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
754 s
->io_buffer_index
= 0;
755 s
->io_buffer_size
= 0;
757 ide_dma_start(s
, ide_write_dma_cb
);
760 void ide_atapi_cmd_ok(IDEState
*s
)
763 s
->status
= READY_STAT
| SEEK_STAT
;
764 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
768 void ide_atapi_cmd_error(IDEState
*s
, int sense_key
, int asc
)
770 #ifdef DEBUG_IDE_ATAPI
771 printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key
, asc
);
773 s
->error
= sense_key
<< 4;
774 s
->status
= READY_STAT
| ERR_STAT
;
775 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
776 s
->sense_key
= sense_key
;
781 static void ide_atapi_cmd_check_status(IDEState
*s
)
783 #ifdef DEBUG_IDE_ATAPI
784 printf("atapi_cmd_check_status\n");
786 s
->error
= MC_ERR
| (SENSE_UNIT_ATTENTION
<< 4);
787 s
->status
= ERR_STAT
;
792 static void ide_flush_cb(void *opaque
, int ret
)
794 IDEState
*s
= opaque
;
796 /* XXX: how do we signal I/O errors here? */
798 s
->status
= READY_STAT
| SEEK_STAT
;
802 static inline void cpu_to_ube16(uint8_t *buf
, int val
)
808 static inline void cpu_to_ube32(uint8_t *buf
, unsigned int val
)
816 static inline int ube16_to_cpu(const uint8_t *buf
)
818 return (buf
[0] << 8) | buf
[1];
821 static inline int ube32_to_cpu(const uint8_t *buf
)
823 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
826 static void lba_to_msf(uint8_t *buf
, int lba
)
829 buf
[0] = (lba
/ 75) / 60;
830 buf
[1] = (lba
/ 75) % 60;
834 static void cd_data_to_raw(uint8_t *buf
, int lba
)
838 memset(buf
+ 1, 0xff, 10);
842 lba_to_msf(buf
, lba
);
843 buf
[3] = 0x01; /* mode 1 data */
847 /* XXX: ECC not computed */
851 static int cd_read_sector(BlockDriverState
*bs
, int lba
, uint8_t *buf
,
856 switch(sector_size
) {
858 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
, 4);
861 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
+ 16, 4);
864 cd_data_to_raw(buf
, lba
);
873 void ide_atapi_io_error(IDEState
*s
, int ret
)
875 /* XXX: handle more errors */
876 if (ret
== -ENOMEDIUM
) {
877 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
878 ASC_MEDIUM_NOT_PRESENT
);
880 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
881 ASC_LOGICAL_BLOCK_OOR
);
885 /* The whole ATAPI transfer logic is handled in this function */
886 static void ide_atapi_cmd_reply_end(IDEState
*s
)
888 int byte_count_limit
, size
, ret
;
889 #ifdef DEBUG_IDE_ATAPI
890 printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
891 s
->packet_transfer_size
,
892 s
->elementary_transfer_size
,
895 if (s
->packet_transfer_size
<= 0) {
896 /* end of transfer */
897 ide_transfer_stop(s
);
898 s
->status
= READY_STAT
| SEEK_STAT
;
899 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
901 #ifdef DEBUG_IDE_ATAPI
902 printf("status=0x%x\n", s
->status
);
905 /* see if a new sector must be read */
906 if (s
->lba
!= -1 && s
->io_buffer_index
>= s
->cd_sector_size
) {
907 ret
= cd_read_sector(s
->bs
, s
->lba
, s
->io_buffer
, s
->cd_sector_size
);
909 ide_transfer_stop(s
);
910 ide_atapi_io_error(s
, ret
);
914 s
->io_buffer_index
= 0;
916 if (s
->elementary_transfer_size
> 0) {
917 /* there are some data left to transmit in this elementary
919 size
= s
->cd_sector_size
- s
->io_buffer_index
;
920 if (size
> s
->elementary_transfer_size
)
921 size
= s
->elementary_transfer_size
;
922 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
,
923 size
, ide_atapi_cmd_reply_end
);
924 s
->packet_transfer_size
-= size
;
925 s
->elementary_transfer_size
-= size
;
926 s
->io_buffer_index
+= size
;
928 /* a new transfer is needed */
929 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
;
930 byte_count_limit
= s
->lcyl
| (s
->hcyl
<< 8);
931 #ifdef DEBUG_IDE_ATAPI
932 printf("byte_count_limit=%d\n", byte_count_limit
);
934 if (byte_count_limit
== 0xffff)
936 size
= s
->packet_transfer_size
;
937 if (size
> byte_count_limit
) {
938 /* byte count limit must be even if this case */
939 if (byte_count_limit
& 1)
941 size
= byte_count_limit
;
945 s
->elementary_transfer_size
= size
;
946 /* we cannot transmit more than one sector at a time */
948 if (size
> (s
->cd_sector_size
- s
->io_buffer_index
))
949 size
= (s
->cd_sector_size
- s
->io_buffer_index
);
951 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
,
952 size
, ide_atapi_cmd_reply_end
);
953 s
->packet_transfer_size
-= size
;
954 s
->elementary_transfer_size
-= size
;
955 s
->io_buffer_index
+= size
;
957 #ifdef DEBUG_IDE_ATAPI
958 printf("status=0x%x\n", s
->status
);
964 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
965 static void ide_atapi_cmd_reply(IDEState
*s
, int size
, int max_size
)
969 s
->lba
= -1; /* no sector read */
970 s
->packet_transfer_size
= size
;
971 s
->io_buffer_size
= size
; /* dma: send the reply data as one chunk */
972 s
->elementary_transfer_size
= 0;
973 s
->io_buffer_index
= 0;
976 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
;
977 ide_dma_start(s
, ide_atapi_cmd_read_dma_cb
);
979 s
->status
= READY_STAT
| SEEK_STAT
;
980 ide_atapi_cmd_reply_end(s
);
984 /* start a CD-CDROM read command */
985 static void ide_atapi_cmd_read_pio(IDEState
*s
, int lba
, int nb_sectors
,
989 s
->packet_transfer_size
= nb_sectors
* sector_size
;
990 s
->elementary_transfer_size
= 0;
991 s
->io_buffer_index
= sector_size
;
992 s
->cd_sector_size
= sector_size
;
994 s
->status
= READY_STAT
| SEEK_STAT
;
995 ide_atapi_cmd_reply_end(s
);
998 /* ATAPI DMA support */
1000 /* XXX: handle read errors */
1001 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
)
1003 BMDMAState
*bm
= opaque
;
1004 IDEState
*s
= bmdma_active_if(bm
);
1008 ide_atapi_io_error(s
, ret
);
1012 if (s
->io_buffer_size
> 0) {
1014 * For a cdrom read sector command (s->lba != -1),
1015 * adjust the lba for the next s->io_buffer_size chunk
1016 * and dma the current chunk.
1017 * For a command != read (s->lba == -1), just transfer
1021 if (s
->cd_sector_size
== 2352) {
1023 cd_data_to_raw(s
->io_buffer
, s
->lba
);
1025 n
= s
->io_buffer_size
>> 11;
1029 s
->packet_transfer_size
-= s
->io_buffer_size
;
1030 if (dma_buf_rw(bm
, 1) == 0)
1034 if (s
->packet_transfer_size
<= 0) {
1035 s
->status
= READY_STAT
| SEEK_STAT
;
1036 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
1037 ide_set_irq(s
->bus
);
1039 bm
->status
&= ~BM_STATUS_DMAING
;
1040 bm
->status
|= BM_STATUS_INT
;
1047 s
->io_buffer_index
= 0;
1048 if (s
->cd_sector_size
== 2352) {
1050 s
->io_buffer_size
= s
->cd_sector_size
;
1053 n
= s
->packet_transfer_size
>> 11;
1054 if (n
> (IDE_DMA_BUF_SECTORS
/ 4))
1055 n
= (IDE_DMA_BUF_SECTORS
/ 4);
1056 s
->io_buffer_size
= n
* 2048;
1060 printf("aio_read_cd: lba=%u n=%d\n", s
->lba
, n
);
1062 bm
->iov
.iov_base
= (void *)(s
->io_buffer
+ data_offset
);
1063 bm
->iov
.iov_len
= n
* 4 * 512;
1064 qemu_iovec_init_external(&bm
->qiov
, &bm
->iov
, 1);
1065 bm
->aiocb
= bdrv_aio_readv(s
->bs
, (int64_t)s
->lba
<< 2, &bm
->qiov
,
1066 n
* 4, ide_atapi_cmd_read_dma_cb
, bm
);
1068 /* Note: media not present is the most likely case */
1069 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1070 ASC_MEDIUM_NOT_PRESENT
);
1075 /* start a CD-CDROM read command with DMA */
1076 /* XXX: test if DMA is available */
1077 static void ide_atapi_cmd_read_dma(IDEState
*s
, int lba
, int nb_sectors
,
1081 s
->packet_transfer_size
= nb_sectors
* sector_size
;
1082 s
->io_buffer_index
= 0;
1083 s
->io_buffer_size
= 0;
1084 s
->cd_sector_size
= sector_size
;
1086 /* XXX: check if BUSY_STAT should be set */
1087 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
1088 ide_dma_start(s
, ide_atapi_cmd_read_dma_cb
);
1091 static void ide_atapi_cmd_read(IDEState
*s
, int lba
, int nb_sectors
,
1094 #ifdef DEBUG_IDE_ATAPI
1095 printf("read %s: LBA=%d nb_sectors=%d\n", s
->atapi_dma
? "dma" : "pio",
1099 ide_atapi_cmd_read_dma(s
, lba
, nb_sectors
, sector_size
);
1101 ide_atapi_cmd_read_pio(s
, lba
, nb_sectors
, sector_size
);
1105 static inline uint8_t ide_atapi_set_profile(uint8_t *buf
, uint8_t *index
,
1108 uint8_t *buf_profile
= buf
+ 12; /* start of profiles */
1110 buf_profile
+= ((*index
) * 4); /* start of indexed profile */
1111 cpu_to_ube16 (buf_profile
, profile
);
1112 buf_profile
[2] = ((buf_profile
[0] == buf
[6]) && (buf_profile
[1] == buf
[7]));
1114 /* each profile adds 4 bytes to the response */
1116 buf
[11] += 4; /* Additional Length */
1121 static int ide_dvd_read_structure(IDEState
*s
, int format
,
1122 const uint8_t *packet
, uint8_t *buf
)
1125 case 0x0: /* Physical format information */
1127 int layer
= packet
[6];
1128 uint64_t total_sectors
;
1131 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1133 bdrv_get_geometry(s
->bs
, &total_sectors
);
1134 total_sectors
>>= 2;
1135 if (total_sectors
== 0)
1136 return -ASC_MEDIUM_NOT_PRESENT
;
1138 buf
[4] = 1; /* DVD-ROM, part version 1 */
1139 buf
[5] = 0xf; /* 120mm disc, minimum rate unspecified */
1140 buf
[6] = 1; /* one layer, read-only (per MMC-2 spec) */
1141 buf
[7] = 0; /* default densities */
1143 /* FIXME: 0x30000 per spec? */
1144 cpu_to_ube32(buf
+ 8, 0); /* start sector */
1145 cpu_to_ube32(buf
+ 12, total_sectors
- 1); /* end sector */
1146 cpu_to_ube32(buf
+ 16, total_sectors
- 1); /* l0 end sector */
1148 /* Size of buffer, not including 2 byte size field */
1149 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
1151 /* 2k data + 4 byte header */
1155 case 0x01: /* DVD copyright information */
1156 buf
[4] = 0; /* no copyright data */
1157 buf
[5] = 0; /* no region restrictions */
1159 /* Size of buffer, not including 2 byte size field */
1160 cpu_to_be16wu((uint16_t *)buf
, 4 + 2);
1162 /* 4 byte header + 4 byte data */
1165 case 0x03: /* BCA information - invalid field for no BCA info */
1166 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1168 case 0x04: /* DVD disc manufacturing information */
1169 /* Size of buffer, not including 2 byte size field */
1170 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
1172 /* 2k data + 4 byte header */
1177 * This lists all the command capabilities above. Add new ones
1178 * in order and update the length and buffer return values.
1181 buf
[4] = 0x00; /* Physical format */
1182 buf
[5] = 0x40; /* Not writable, is readable */
1183 cpu_to_be16wu((uint16_t *)(buf
+ 6), 2048 + 4);
1185 buf
[8] = 0x01; /* Copyright info */
1186 buf
[9] = 0x40; /* Not writable, is readable */
1187 cpu_to_be16wu((uint16_t *)(buf
+ 10), 4 + 4);
1189 buf
[12] = 0x03; /* BCA info */
1190 buf
[13] = 0x40; /* Not writable, is readable */
1191 cpu_to_be16wu((uint16_t *)(buf
+ 14), 188 + 4);
1193 buf
[16] = 0x04; /* Manufacturing info */
1194 buf
[17] = 0x40; /* Not writable, is readable */
1195 cpu_to_be16wu((uint16_t *)(buf
+ 18), 2048 + 4);
1197 /* Size of buffer, not including 2 byte size field */
1198 cpu_to_be16wu((uint16_t *)buf
, 16 + 2);
1200 /* data written + 4 byte header */
1203 default: /* TODO: formats beyond DVD-ROM requires */
1204 return -ASC_INV_FIELD_IN_CMD_PACKET
;
1208 static void ide_atapi_cmd(IDEState
*s
)
1210 const uint8_t *packet
;
1214 packet
= s
->io_buffer
;
1216 #ifdef DEBUG_IDE_ATAPI
1219 printf("ATAPI limit=0x%x packet:", s
->lcyl
| (s
->hcyl
<< 8));
1220 for(i
= 0; i
< ATAPI_PACKET_SIZE
; i
++) {
1221 printf(" %02x", packet
[i
]);
1226 /* If there's a UNIT_ATTENTION condition pending, only
1227 REQUEST_SENSE and INQUIRY commands are allowed to complete. */
1228 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
1229 s
->io_buffer
[0] != GPCMD_REQUEST_SENSE
&&
1230 s
->io_buffer
[0] != GPCMD_INQUIRY
) {
1231 ide_atapi_cmd_check_status(s
);
1234 switch(s
->io_buffer
[0]) {
1235 case GPCMD_TEST_UNIT_READY
:
1236 if (bdrv_is_inserted(s
->bs
) && !s
->cdrom_changed
) {
1237 ide_atapi_cmd_ok(s
);
1239 s
->cdrom_changed
= 0;
1240 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1241 ASC_MEDIUM_NOT_PRESENT
);
1244 case GPCMD_MODE_SENSE_6
:
1245 case GPCMD_MODE_SENSE_10
:
1248 if (packet
[0] == GPCMD_MODE_SENSE_10
)
1249 max_len
= ube16_to_cpu(packet
+ 7);
1251 max_len
= packet
[4];
1252 action
= packet
[2] >> 6;
1253 code
= packet
[2] & 0x3f;
1255 case 0: /* current values */
1257 case GPMODE_R_W_ERROR_PAGE
: /* error recovery */
1258 cpu_to_ube16(&buf
[0], 16 + 6);
1274 ide_atapi_cmd_reply(s
, 16, max_len
);
1276 case GPMODE_AUDIO_CTL_PAGE
:
1277 cpu_to_ube16(&buf
[0], 24 + 6);
1285 /* Fill with CDROM audio volume */
1291 ide_atapi_cmd_reply(s
, 24, max_len
);
1293 case GPMODE_CAPABILITIES_PAGE
:
1294 cpu_to_ube16(&buf
[0], 28 + 6);
1307 /* Claim PLAY_AUDIO capability (0x01) since some Linux
1308 code checks for this to automount media. */
1311 buf
[14] = (1 << 0) | (1 << 3) | (1 << 5);
1312 if (bdrv_is_locked(s
->bs
))
1315 cpu_to_ube16(&buf
[16], 706);
1318 cpu_to_ube16(&buf
[20], 512);
1319 cpu_to_ube16(&buf
[22], 706);
1324 ide_atapi_cmd_reply(s
, 28, max_len
);
1330 case 1: /* changeable values */
1332 case 2: /* default values */
1335 case 3: /* saved values */
1336 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1337 ASC_SAVING_PARAMETERS_NOT_SUPPORTED
);
1342 case GPCMD_REQUEST_SENSE
:
1343 max_len
= packet
[4];
1345 buf
[0] = 0x70 | (1 << 7);
1346 buf
[2] = s
->sense_key
;
1349 if (s
->sense_key
== SENSE_UNIT_ATTENTION
)
1350 s
->sense_key
= SENSE_NONE
;
1351 ide_atapi_cmd_reply(s
, 18, max_len
);
1353 case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
:
1354 if (bdrv_is_inserted(s
->bs
)) {
1355 bdrv_set_locked(s
->bs
, packet
[4] & 1);
1356 ide_atapi_cmd_ok(s
);
1358 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1359 ASC_MEDIUM_NOT_PRESENT
);
1365 int nb_sectors
, lba
;
1367 if (packet
[0] == GPCMD_READ_10
)
1368 nb_sectors
= ube16_to_cpu(packet
+ 7);
1370 nb_sectors
= ube32_to_cpu(packet
+ 6);
1371 lba
= ube32_to_cpu(packet
+ 2);
1372 if (nb_sectors
== 0) {
1373 ide_atapi_cmd_ok(s
);
1376 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
1381 int nb_sectors
, lba
, transfer_request
;
1383 nb_sectors
= (packet
[6] << 16) | (packet
[7] << 8) | packet
[8];
1384 lba
= ube32_to_cpu(packet
+ 2);
1385 if (nb_sectors
== 0) {
1386 ide_atapi_cmd_ok(s
);
1389 transfer_request
= packet
[9];
1390 switch(transfer_request
& 0xf8) {
1393 ide_atapi_cmd_ok(s
);
1397 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
1401 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2352);
1404 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1405 ASC_INV_FIELD_IN_CMD_PACKET
);
1413 uint64_t total_sectors
;
1415 bdrv_get_geometry(s
->bs
, &total_sectors
);
1416 total_sectors
>>= 2;
1417 if (total_sectors
== 0) {
1418 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1419 ASC_MEDIUM_NOT_PRESENT
);
1422 lba
= ube32_to_cpu(packet
+ 2);
1423 if (lba
>= total_sectors
) {
1424 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1425 ASC_LOGICAL_BLOCK_OOR
);
1428 ide_atapi_cmd_ok(s
);
1431 case GPCMD_START_STOP_UNIT
:
1433 int start
, eject
, err
= 0;
1434 start
= packet
[4] & 1;
1435 eject
= (packet
[4] >> 1) & 1;
1438 err
= bdrv_eject(s
->bs
, !start
);
1443 ide_atapi_cmd_ok(s
);
1446 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1447 ASC_MEDIA_REMOVAL_PREVENTED
);
1450 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1451 ASC_MEDIUM_NOT_PRESENT
);
1456 case GPCMD_MECHANISM_STATUS
:
1458 max_len
= ube16_to_cpu(packet
+ 8);
1459 cpu_to_ube16(buf
, 0);
1460 /* no current LBA */
1465 cpu_to_ube16(buf
+ 6, 0);
1466 ide_atapi_cmd_reply(s
, 8, max_len
);
1469 case GPCMD_READ_TOC_PMA_ATIP
:
1471 int format
, msf
, start_track
, len
;
1472 uint64_t total_sectors
;
1474 bdrv_get_geometry(s
->bs
, &total_sectors
);
1475 total_sectors
>>= 2;
1476 if (total_sectors
== 0) {
1477 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1478 ASC_MEDIUM_NOT_PRESENT
);
1481 max_len
= ube16_to_cpu(packet
+ 7);
1482 format
= packet
[9] >> 6;
1483 msf
= (packet
[1] >> 1) & 1;
1484 start_track
= packet
[6];
1487 len
= cdrom_read_toc(total_sectors
, buf
, msf
, start_track
);
1490 ide_atapi_cmd_reply(s
, len
, max_len
);
1493 /* multi session : only a single session defined */
1498 ide_atapi_cmd_reply(s
, 12, max_len
);
1501 len
= cdrom_read_toc_raw(total_sectors
, buf
, msf
, start_track
);
1504 ide_atapi_cmd_reply(s
, len
, max_len
);
1508 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1509 ASC_INV_FIELD_IN_CMD_PACKET
);
1514 case GPCMD_READ_CDVD_CAPACITY
:
1516 uint64_t total_sectors
;
1518 bdrv_get_geometry(s
->bs
, &total_sectors
);
1519 total_sectors
>>= 2;
1520 if (total_sectors
== 0) {
1521 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
1522 ASC_MEDIUM_NOT_PRESENT
);
1525 /* NOTE: it is really the number of sectors minus 1 */
1526 cpu_to_ube32(buf
, total_sectors
- 1);
1527 cpu_to_ube32(buf
+ 4, 2048);
1528 ide_atapi_cmd_reply(s
, 8, 8);
1531 case GPCMD_READ_DVD_STRUCTURE
:
1533 int media
= packet
[1];
1534 int format
= packet
[7];
1537 max_len
= ube16_to_cpu(packet
+ 8);
1539 if (format
< 0xff) {
1540 if (media_is_cd(s
)) {
1541 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1542 ASC_INCOMPATIBLE_FORMAT
);
1544 } else if (!media_present(s
)) {
1545 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1546 ASC_INV_FIELD_IN_CMD_PACKET
);
1551 memset(buf
, 0, max_len
> IDE_DMA_BUF_SECTORS
* 512 + 4 ?
1552 IDE_DMA_BUF_SECTORS
* 512 + 4 : max_len
);
1558 ret
= ide_dvd_read_structure(s
, format
, packet
, buf
);
1561 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
, -ret
);
1563 ide_atapi_cmd_reply(s
, ret
, max_len
);
1567 /* TODO: BD support, fall through for now */
1569 /* Generic disk structures */
1570 case 0x80: /* TODO: AACS volume identifier */
1571 case 0x81: /* TODO: AACS media serial number */
1572 case 0x82: /* TODO: AACS media identifier */
1573 case 0x83: /* TODO: AACS media key block */
1574 case 0x90: /* TODO: List of recognized format layers */
1575 case 0xc0: /* TODO: Write protection status */
1577 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1578 ASC_INV_FIELD_IN_CMD_PACKET
);
1583 case GPCMD_SET_SPEED
:
1584 ide_atapi_cmd_ok(s
);
1587 max_len
= packet
[4];
1588 buf
[0] = 0x05; /* CD-ROM */
1589 buf
[1] = 0x80; /* removable */
1590 buf
[2] = 0x00; /* ISO */
1591 buf
[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1592 buf
[4] = 31; /* additional length */
1593 buf
[5] = 0; /* reserved */
1594 buf
[6] = 0; /* reserved */
1595 buf
[7] = 0; /* reserved */
1596 padstr8(buf
+ 8, 8, "QEMU");
1597 padstr8(buf
+ 16, 16, "QEMU DVD-ROM");
1598 padstr8(buf
+ 32, 4, s
->version
);
1599 ide_atapi_cmd_reply(s
, 36, max_len
);
1601 case GPCMD_GET_CONFIGURATION
:
1606 /* only feature 0 is supported */
1607 if (packet
[2] != 0 || packet
[3] != 0) {
1608 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1609 ASC_INV_FIELD_IN_CMD_PACKET
);
1613 /* XXX: could result in alignment problems in some architectures */
1614 max_len
= ube16_to_cpu(packet
+ 7);
1617 * XXX: avoid overflow for io_buffer if max_len is bigger than
1618 * the size of that buffer (dimensioned to max number of
1619 * sectors to transfer at once)
1621 * Only a problem if the feature/profiles grow.
1623 if (max_len
> 512) /* XXX: assume 1 sector */
1626 memset(buf
, 0, max_len
);
1628 * the number of sectors from the media tells us which profile
1629 * to use as current. 0 means there is no media
1631 if (media_is_dvd(s
))
1632 cpu_to_ube16(buf
+ 6, MMC_PROFILE_DVD_ROM
);
1633 else if (media_is_cd(s
))
1634 cpu_to_ube16(buf
+ 6, MMC_PROFILE_CD_ROM
);
1636 buf
[10] = 0x02 | 0x01; /* persistent and current */
1637 len
= 12; /* headers: 8 + 4 */
1638 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_DVD_ROM
);
1639 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_CD_ROM
);
1640 cpu_to_ube32(buf
, len
- 4); /* data length */
1642 ide_atapi_cmd_reply(s
, len
, max_len
);
1646 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1647 ASC_ILLEGAL_OPCODE
);
1652 static void ide_cfata_metadata_inquiry(IDEState
*s
)
1657 p
= (uint16_t *) s
->io_buffer
;
1658 memset(p
, 0, 0x200);
1659 spd
= ((s
->mdata_size
- 1) >> 9) + 1;
1661 put_le16(p
+ 0, 0x0001); /* Data format revision */
1662 put_le16(p
+ 1, 0x0000); /* Media property: silicon */
1663 put_le16(p
+ 2, s
->media_changed
); /* Media status */
1664 put_le16(p
+ 3, s
->mdata_size
& 0xffff); /* Capacity in bytes (low) */
1665 put_le16(p
+ 4, s
->mdata_size
>> 16); /* Capacity in bytes (high) */
1666 put_le16(p
+ 5, spd
& 0xffff); /* Sectors per device (low) */
1667 put_le16(p
+ 6, spd
>> 16); /* Sectors per device (high) */
1670 static void ide_cfata_metadata_read(IDEState
*s
)
1674 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
1675 s
->status
= ERR_STAT
;
1676 s
->error
= ABRT_ERR
;
1680 p
= (uint16_t *) s
->io_buffer
;
1681 memset(p
, 0, 0x200);
1683 put_le16(p
+ 0, s
->media_changed
); /* Media status */
1684 memcpy(p
+ 1, s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1685 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1686 s
->nsector
<< 9), 0x200 - 2));
1689 static void ide_cfata_metadata_write(IDEState
*s
)
1691 if (((s
->hcyl
<< 16) | s
->lcyl
) << 9 > s
->mdata_size
+ 2) {
1692 s
->status
= ERR_STAT
;
1693 s
->error
= ABRT_ERR
;
1697 s
->media_changed
= 0;
1699 memcpy(s
->mdata_storage
+ (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1701 MIN(MIN(s
->mdata_size
- (((s
->hcyl
<< 16) | s
->lcyl
) << 9),
1702 s
->nsector
<< 9), 0x200 - 2));
1705 /* called when the inserted state of the media has changed */
1706 static void cdrom_change_cb(void *opaque
)
1708 IDEState
*s
= opaque
;
1709 uint64_t nb_sectors
;
1711 bdrv_get_geometry(s
->bs
, &nb_sectors
);
1712 s
->nb_sectors
= nb_sectors
;
1714 s
->sense_key
= SENSE_UNIT_ATTENTION
;
1715 s
->asc
= ASC_MEDIUM_MAY_HAVE_CHANGED
;
1716 s
->cdrom_changed
= 1;
1717 ide_set_irq(s
->bus
);
1720 static void ide_cmd_lba48_transform(IDEState
*s
, int lba48
)
1724 /* handle the 'magic' 0 nsector count conversion here. to avoid
1725 * fiddling with the rest of the read logic, we just store the
1726 * full sector count in ->nsector and ignore ->hob_nsector from now
1732 if (!s
->nsector
&& !s
->hob_nsector
)
1735 int lo
= s
->nsector
;
1736 int hi
= s
->hob_nsector
;
1738 s
->nsector
= (hi
<< 8) | lo
;
1743 static void ide_clear_hob(IDEBus
*bus
)
1745 /* any write clears HOB high bit of device control register */
1746 bus
->ifs
[0].select
&= ~(1 << 7);
1747 bus
->ifs
[1].select
&= ~(1 << 7);
1750 void ide_ioport_write(void *opaque
, uint32_t addr
, uint32_t val
)
1752 IDEBus
*bus
= opaque
;
1758 printf("IDE: write addr=0x%x val=0x%02x\n", addr
, val
);
1763 /* ignore writes to command block while busy with previous command */
1764 if (addr
!= 7 && (idebus_active_if(bus
)->status
& (BUSY_STAT
|DRQ_STAT
)))
1772 /* NOTE: data is written to the two drives */
1773 bus
->ifs
[0].hob_feature
= bus
->ifs
[0].feature
;
1774 bus
->ifs
[1].hob_feature
= bus
->ifs
[1].feature
;
1775 bus
->ifs
[0].feature
= val
;
1776 bus
->ifs
[1].feature
= val
;
1780 bus
->ifs
[0].hob_nsector
= bus
->ifs
[0].nsector
;
1781 bus
->ifs
[1].hob_nsector
= bus
->ifs
[1].nsector
;
1782 bus
->ifs
[0].nsector
= val
;
1783 bus
->ifs
[1].nsector
= val
;
1787 bus
->ifs
[0].hob_sector
= bus
->ifs
[0].sector
;
1788 bus
->ifs
[1].hob_sector
= bus
->ifs
[1].sector
;
1789 bus
->ifs
[0].sector
= val
;
1790 bus
->ifs
[1].sector
= val
;
1794 bus
->ifs
[0].hob_lcyl
= bus
->ifs
[0].lcyl
;
1795 bus
->ifs
[1].hob_lcyl
= bus
->ifs
[1].lcyl
;
1796 bus
->ifs
[0].lcyl
= val
;
1797 bus
->ifs
[1].lcyl
= val
;
1801 bus
->ifs
[0].hob_hcyl
= bus
->ifs
[0].hcyl
;
1802 bus
->ifs
[1].hob_hcyl
= bus
->ifs
[1].hcyl
;
1803 bus
->ifs
[0].hcyl
= val
;
1804 bus
->ifs
[1].hcyl
= val
;
1807 /* FIXME: HOB readback uses bit 7 */
1808 bus
->ifs
[0].select
= (val
& ~0x10) | 0xa0;
1809 bus
->ifs
[1].select
= (val
| 0x10) | 0xa0;
1811 bus
->unit
= (val
>> 4) & 1;
1816 #if defined(DEBUG_IDE)
1817 printf("ide: CMD=%02x\n", val
);
1819 s
= idebus_active_if(bus
);
1820 /* ignore commands to non existant slave */
1821 if (s
!= bus
->ifs
&& !s
->bs
)
1824 /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
1825 if ((s
->status
& (BUSY_STAT
|DRQ_STAT
)) && val
!= WIN_DEVICE_RESET
)
1830 if (s
->bs
&& !s
->is_cdrom
) {
1834 ide_cfata_identify(s
);
1835 s
->status
= READY_STAT
| SEEK_STAT
;
1836 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
1839 ide_set_signature(s
);
1841 ide_abort_command(s
);
1843 ide_set_irq(s
->bus
);
1848 s
->status
= READY_STAT
| SEEK_STAT
;
1849 ide_set_irq(s
->bus
);
1852 if (s
->is_cf
&& s
->nsector
== 0) {
1853 /* Disable Read and Write Multiple */
1854 s
->mult_sectors
= 0;
1855 s
->status
= READY_STAT
| SEEK_STAT
;
1856 } else if ((s
->nsector
& 0xff) != 0 &&
1857 ((s
->nsector
& 0xff) > MAX_MULT_SECTORS
||
1858 (s
->nsector
& (s
->nsector
- 1)) != 0)) {
1859 ide_abort_command(s
);
1861 s
->mult_sectors
= s
->nsector
& 0xff;
1862 s
->status
= READY_STAT
| SEEK_STAT
;
1864 ide_set_irq(s
->bus
);
1866 case WIN_VERIFY_EXT
:
1869 case WIN_VERIFY_ONCE
:
1870 /* do sector number check ? */
1871 ide_cmd_lba48_transform(s
, lba48
);
1872 s
->status
= READY_STAT
| SEEK_STAT
;
1873 ide_set_irq(s
->bus
);
1881 ide_cmd_lba48_transform(s
, lba48
);
1882 s
->req_nb_sectors
= 1;
1888 case WIN_WRITE_ONCE
:
1889 case CFA_WRITE_SECT_WO_ERASE
:
1890 case WIN_WRITE_VERIFY
:
1891 ide_cmd_lba48_transform(s
, lba48
);
1893 s
->status
= SEEK_STAT
| READY_STAT
;
1894 s
->req_nb_sectors
= 1;
1895 ide_transfer_start(s
, s
->io_buffer
, 512, ide_sector_write
);
1896 s
->media_changed
= 1;
1898 case WIN_MULTREAD_EXT
:
1901 if (!s
->mult_sectors
)
1903 ide_cmd_lba48_transform(s
, lba48
);
1904 s
->req_nb_sectors
= s
->mult_sectors
;
1907 case WIN_MULTWRITE_EXT
:
1910 case CFA_WRITE_MULTI_WO_ERASE
:
1911 if (!s
->mult_sectors
)
1913 ide_cmd_lba48_transform(s
, lba48
);
1915 s
->status
= SEEK_STAT
| READY_STAT
;
1916 s
->req_nb_sectors
= s
->mult_sectors
;
1918 if (n
> s
->req_nb_sectors
)
1919 n
= s
->req_nb_sectors
;
1920 ide_transfer_start(s
, s
->io_buffer
, 512 * n
, ide_sector_write
);
1921 s
->media_changed
= 1;
1923 case WIN_READDMA_EXT
:
1926 case WIN_READDMA_ONCE
:
1929 ide_cmd_lba48_transform(s
, lba48
);
1930 ide_sector_read_dma(s
);
1932 case WIN_WRITEDMA_EXT
:
1935 case WIN_WRITEDMA_ONCE
:
1938 ide_cmd_lba48_transform(s
, lba48
);
1939 ide_sector_write_dma(s
);
1940 s
->media_changed
= 1;
1942 case WIN_READ_NATIVE_MAX_EXT
:
1944 case WIN_READ_NATIVE_MAX
:
1945 ide_cmd_lba48_transform(s
, lba48
);
1946 ide_set_sector(s
, s
->nb_sectors
- 1);
1947 s
->status
= READY_STAT
| SEEK_STAT
;
1948 ide_set_irq(s
->bus
);
1950 case WIN_CHECKPOWERMODE1
:
1951 case WIN_CHECKPOWERMODE2
:
1952 s
->nsector
= 0xff; /* device active or idle */
1953 s
->status
= READY_STAT
| SEEK_STAT
;
1954 ide_set_irq(s
->bus
);
1956 case WIN_SETFEATURES
:
1959 /* XXX: valid for CDROM ? */
1960 switch(s
->feature
) {
1961 case 0xcc: /* reverting to power-on defaults enable */
1962 case 0x66: /* reverting to power-on defaults disable */
1963 case 0x02: /* write cache enable */
1964 case 0x82: /* write cache disable */
1965 case 0xaa: /* read look-ahead enable */
1966 case 0x55: /* read look-ahead disable */
1967 case 0x05: /* set advanced power management mode */
1968 case 0x85: /* disable advanced power management mode */
1969 case 0x69: /* NOP */
1970 case 0x67: /* NOP */
1971 case 0x96: /* NOP */
1972 case 0x9a: /* NOP */
1973 case 0x42: /* enable Automatic Acoustic Mode */
1974 case 0xc2: /* disable Automatic Acoustic Mode */
1975 s
->status
= READY_STAT
| SEEK_STAT
;
1976 ide_set_irq(s
->bus
);
1978 case 0x03: { /* set transfer mode */
1979 uint8_t val
= s
->nsector
& 0x07;
1980 uint16_t *identify_data
= (uint16_t *)s
->identify_data
;
1982 switch (s
->nsector
>> 3) {
1983 case 0x00: /* pio default */
1984 case 0x01: /* pio mode */
1985 put_le16(identify_data
+ 62,0x07);
1986 put_le16(identify_data
+ 63,0x07);
1987 put_le16(identify_data
+ 88,0x3f);
1989 case 0x02: /* sigle word dma mode*/
1990 put_le16(identify_data
+ 62,0x07 | (1 << (val
+ 8)));
1991 put_le16(identify_data
+ 63,0x07);
1992 put_le16(identify_data
+ 88,0x3f);
1994 case 0x04: /* mdma mode */
1995 put_le16(identify_data
+ 62,0x07);
1996 put_le16(identify_data
+ 63,0x07 | (1 << (val
+ 8)));
1997 put_le16(identify_data
+ 88,0x3f);
1999 case 0x08: /* udma mode */
2000 put_le16(identify_data
+ 62,0x07);
2001 put_le16(identify_data
+ 63,0x07);
2002 put_le16(identify_data
+ 88,0x3f | (1 << (val
+ 8)));
2007 s
->status
= READY_STAT
| SEEK_STAT
;
2008 ide_set_irq(s
->bus
);
2015 case WIN_FLUSH_CACHE
:
2016 case WIN_FLUSH_CACHE_EXT
:
2018 bdrv_aio_flush(s
->bs
, ide_flush_cb
, s
);
2024 case WIN_STANDBYNOW1
:
2025 case WIN_STANDBYNOW2
:
2026 case WIN_IDLEIMMEDIATE
:
2027 case CFA_IDLEIMMEDIATE
:
2032 s
->status
= READY_STAT
;
2033 ide_set_irq(s
->bus
);
2038 /* XXX: Check that seek is within bounds */
2039 s
->status
= READY_STAT
| SEEK_STAT
;
2040 ide_set_irq(s
->bus
);
2042 /* ATAPI commands */
2045 ide_atapi_identify(s
);
2046 s
->status
= READY_STAT
| SEEK_STAT
;
2047 ide_transfer_start(s
, s
->io_buffer
, 512, ide_transfer_stop
);
2049 ide_abort_command(s
);
2051 ide_set_irq(s
->bus
);
2054 ide_set_signature(s
);
2056 s
->status
= 0; /* ATAPI spec (v6) section 9.10 defines packet
2057 * devices to return a clear status register
2058 * with READY_STAT *not* set. */
2060 s
->status
= READY_STAT
| SEEK_STAT
;
2061 s
->error
= 0x01; /* Device 0 passed, Device 1 passed or not
2064 ide_set_irq(s
->bus
);
2069 ide_set_signature(s
);
2070 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2076 /* overlapping commands not supported */
2077 if (s
->feature
& 0x02)
2079 s
->status
= READY_STAT
| SEEK_STAT
;
2080 s
->atapi_dma
= s
->feature
& 1;
2082 ide_transfer_start(s
, s
->io_buffer
, ATAPI_PACKET_SIZE
,
2085 /* CF-ATA commands */
2086 case CFA_REQ_EXT_ERROR_CODE
:
2089 s
->error
= 0x09; /* miscellaneous error */
2090 s
->status
= READY_STAT
| SEEK_STAT
;
2091 ide_set_irq(s
->bus
);
2093 case CFA_ERASE_SECTORS
:
2094 case CFA_WEAR_LEVEL
:
2097 if (val
== CFA_WEAR_LEVEL
)
2099 if (val
== CFA_ERASE_SECTORS
)
2100 s
->media_changed
= 1;
2102 s
->status
= READY_STAT
| SEEK_STAT
;
2103 ide_set_irq(s
->bus
);
2105 case CFA_TRANSLATE_SECTOR
:
2109 s
->status
= READY_STAT
| SEEK_STAT
;
2110 memset(s
->io_buffer
, 0, 0x200);
2111 s
->io_buffer
[0x00] = s
->hcyl
; /* Cyl MSB */
2112 s
->io_buffer
[0x01] = s
->lcyl
; /* Cyl LSB */
2113 s
->io_buffer
[0x02] = s
->select
; /* Head */
2114 s
->io_buffer
[0x03] = s
->sector
; /* Sector */
2115 s
->io_buffer
[0x04] = ide_get_sector(s
) >> 16; /* LBA MSB */
2116 s
->io_buffer
[0x05] = ide_get_sector(s
) >> 8; /* LBA */
2117 s
->io_buffer
[0x06] = ide_get_sector(s
) >> 0; /* LBA LSB */
2118 s
->io_buffer
[0x13] = 0x00; /* Erase flag */
2119 s
->io_buffer
[0x18] = 0x00; /* Hot count */
2120 s
->io_buffer
[0x19] = 0x00; /* Hot count */
2121 s
->io_buffer
[0x1a] = 0x01; /* Hot count */
2122 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2123 ide_set_irq(s
->bus
);
2125 case CFA_ACCESS_METADATA_STORAGE
:
2128 switch (s
->feature
) {
2129 case 0x02: /* Inquiry Metadata Storage */
2130 ide_cfata_metadata_inquiry(s
);
2132 case 0x03: /* Read Metadata Storage */
2133 ide_cfata_metadata_read(s
);
2135 case 0x04: /* Write Metadata Storage */
2136 ide_cfata_metadata_write(s
);
2141 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2142 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2143 ide_set_irq(s
->bus
);
2145 case IBM_SENSE_CONDITION
:
2148 switch (s
->feature
) {
2149 case 0x01: /* sense temperature in device */
2150 s
->nsector
= 0x50; /* +20 C */
2155 s
->status
= READY_STAT
| SEEK_STAT
;
2156 ide_set_irq(s
->bus
);
2162 if (s
->hcyl
!= 0xc2 || s
->lcyl
!= 0x4f)
2164 if (!s
->smart_enabled
&& s
->feature
!= SMART_ENABLE
)
2166 switch (s
->feature
) {
2168 s
->smart_enabled
= 0;
2169 s
->status
= READY_STAT
| SEEK_STAT
;
2170 ide_set_irq(s
->bus
);
2173 s
->smart_enabled
= 1;
2174 s
->status
= READY_STAT
| SEEK_STAT
;
2175 ide_set_irq(s
->bus
);
2177 case SMART_ATTR_AUTOSAVE
:
2178 switch (s
->sector
) {
2180 s
->smart_autosave
= 0;
2183 s
->smart_autosave
= 1;
2188 s
->status
= READY_STAT
| SEEK_STAT
;
2189 ide_set_irq(s
->bus
);
2192 if (!s
->smart_errors
) {
2199 s
->status
= READY_STAT
| SEEK_STAT
;
2200 ide_set_irq(s
->bus
);
2202 case SMART_READ_THRESH
:
2203 memset(s
->io_buffer
, 0, 0x200);
2204 s
->io_buffer
[0] = 0x01; /* smart struct version */
2205 for (n
=0; n
<30; n
++) {
2206 if (smart_attributes
[n
][0] == 0)
2208 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
2209 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][4];
2211 for (n
=0; n
<511; n
++) /* checksum */
2212 s
->io_buffer
[511] += s
->io_buffer
[n
];
2213 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2214 s
->status
= READY_STAT
| SEEK_STAT
;
2215 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2216 ide_set_irq(s
->bus
);
2218 case SMART_READ_DATA
:
2219 memset(s
->io_buffer
, 0, 0x200);
2220 s
->io_buffer
[0] = 0x01; /* smart struct version */
2221 for (n
=0; n
<30; n
++) {
2222 if (smart_attributes
[n
][0] == 0)
2224 s
->io_buffer
[2+0+(n
*12)] = smart_attributes
[n
][0];
2225 s
->io_buffer
[2+1+(n
*12)] = smart_attributes
[n
][1];
2226 s
->io_buffer
[2+3+(n
*12)] = smart_attributes
[n
][2];
2227 s
->io_buffer
[2+4+(n
*12)] = smart_attributes
[n
][3];
2229 s
->io_buffer
[362] = 0x02 | (s
->smart_autosave
?0x80:0x00);
2230 if (s
->smart_selftest_count
== 0) {
2231 s
->io_buffer
[363] = 0;
2234 s
->smart_selftest_data
[3 +
2235 (s
->smart_selftest_count
- 1) *
2238 s
->io_buffer
[364] = 0x20;
2239 s
->io_buffer
[365] = 0x01;
2240 /* offline data collection capacity: execute + self-test*/
2241 s
->io_buffer
[367] = (1<<4 | 1<<3 | 1);
2242 s
->io_buffer
[368] = 0x03; /* smart capability (1) */
2243 s
->io_buffer
[369] = 0x00; /* smart capability (2) */
2244 s
->io_buffer
[370] = 0x01; /* error logging supported */
2245 s
->io_buffer
[372] = 0x02; /* minutes for poll short test */
2246 s
->io_buffer
[373] = 0x36; /* minutes for poll ext test */
2247 s
->io_buffer
[374] = 0x01; /* minutes for poll conveyance */
2249 for (n
=0; n
<511; n
++)
2250 s
->io_buffer
[511] += s
->io_buffer
[n
];
2251 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2252 s
->status
= READY_STAT
| SEEK_STAT
;
2253 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2254 ide_set_irq(s
->bus
);
2256 case SMART_READ_LOG
:
2257 switch (s
->sector
) {
2258 case 0x01: /* summary smart error log */
2259 memset(s
->io_buffer
, 0, 0x200);
2260 s
->io_buffer
[0] = 0x01;
2261 s
->io_buffer
[1] = 0x00; /* no error entries */
2262 s
->io_buffer
[452] = s
->smart_errors
& 0xff;
2263 s
->io_buffer
[453] = (s
->smart_errors
& 0xff00) >> 8;
2265 for (n
=0; n
<511; n
++)
2266 s
->io_buffer
[511] += s
->io_buffer
[n
];
2267 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2269 case 0x06: /* smart self test log */
2270 memset(s
->io_buffer
, 0, 0x200);
2271 s
->io_buffer
[0] = 0x01;
2272 if (s
->smart_selftest_count
== 0) {
2273 s
->io_buffer
[508] = 0;
2275 s
->io_buffer
[508] = s
->smart_selftest_count
;
2276 for (n
=2; n
<506; n
++)
2277 s
->io_buffer
[n
] = s
->smart_selftest_data
[n
];
2279 for (n
=0; n
<511; n
++)
2280 s
->io_buffer
[511] += s
->io_buffer
[n
];
2281 s
->io_buffer
[511] = 0x100 - s
->io_buffer
[511];
2286 s
->status
= READY_STAT
| SEEK_STAT
;
2287 ide_transfer_start(s
, s
->io_buffer
, 0x200, ide_transfer_stop
);
2288 ide_set_irq(s
->bus
);
2290 case SMART_EXECUTE_OFFLINE
:
2291 switch (s
->sector
) {
2292 case 0: /* off-line routine */
2293 case 1: /* short self test */
2294 case 2: /* extended self test */
2295 s
->smart_selftest_count
++;
2296 if(s
->smart_selftest_count
> 21)
2297 s
->smart_selftest_count
= 0;
2298 n
= 2 + (s
->smart_selftest_count
- 1) * 24;
2299 s
->smart_selftest_data
[n
] = s
->sector
;
2300 s
->smart_selftest_data
[n
+1] = 0x00; /* OK and finished */
2301 s
->smart_selftest_data
[n
+2] = 0x34; /* hour count lsb */
2302 s
->smart_selftest_data
[n
+3] = 0x12; /* hour count msb */
2303 s
->status
= READY_STAT
| SEEK_STAT
;
2304 ide_set_irq(s
->bus
);
2316 ide_abort_command(s
);
2317 ide_set_irq(s
->bus
);
2323 uint32_t ide_ioport_read(void *opaque
, uint32_t addr1
)
2325 IDEBus
*bus
= opaque
;
2326 IDEState
*s
= idebus_active_if(bus
);
2331 /* FIXME: HOB readback uses bit 7, but it's always set right now */
2332 //hob = s->select & (1 << 7);
2339 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2340 (s
!= bus
->ifs
&& !s
->bs
))
2345 ret
= s
->hob_feature
;
2348 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2351 ret
= s
->nsector
& 0xff;
2353 ret
= s
->hob_nsector
;
2356 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2361 ret
= s
->hob_sector
;
2364 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2372 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2380 if (!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
)
2387 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2388 (s
!= bus
->ifs
&& !s
->bs
))
2392 qemu_irq_lower(bus
->irq
);
2396 printf("ide: read addr=0x%x val=%02x\n", addr1
, ret
);
2401 uint32_t ide_status_read(void *opaque
, uint32_t addr
)
2403 IDEBus
*bus
= opaque
;
2404 IDEState
*s
= idebus_active_if(bus
);
2407 if ((!bus
->ifs
[0].bs
&& !bus
->ifs
[1].bs
) ||
2408 (s
!= bus
->ifs
&& !s
->bs
))
2413 printf("ide: read status addr=0x%x val=%02x\n", addr
, ret
);
2418 void ide_cmd_write(void *opaque
, uint32_t addr
, uint32_t val
)
2420 IDEBus
*bus
= opaque
;
2425 printf("ide: write control addr=0x%x val=%02x\n", addr
, val
);
2427 /* common for both drives */
2428 if (!(bus
->cmd
& IDE_CMD_RESET
) &&
2429 (val
& IDE_CMD_RESET
)) {
2430 /* reset low to high */
2431 for(i
= 0;i
< 2; i
++) {
2433 s
->status
= BUSY_STAT
| SEEK_STAT
;
2436 } else if ((bus
->cmd
& IDE_CMD_RESET
) &&
2437 !(val
& IDE_CMD_RESET
)) {
2439 for(i
= 0;i
< 2; i
++) {
2442 s
->status
= 0x00; /* NOTE: READY is _not_ set */
2444 s
->status
= READY_STAT
| SEEK_STAT
;
2445 ide_set_signature(s
);
2452 void ide_data_writew(void *opaque
, uint32_t addr
, uint32_t val
)
2454 IDEBus
*bus
= opaque
;
2455 IDEState
*s
= idebus_active_if(bus
);
2458 /* PIO data access allowed only when DRQ bit is set */
2459 if (!(s
->status
& DRQ_STAT
))
2463 *(uint16_t *)p
= le16_to_cpu(val
);
2466 if (p
>= s
->data_end
)
2467 s
->end_transfer_func(s
);
2470 uint32_t ide_data_readw(void *opaque
, uint32_t addr
)
2472 IDEBus
*bus
= opaque
;
2473 IDEState
*s
= idebus_active_if(bus
);
2477 /* PIO data access allowed only when DRQ bit is set */
2478 if (!(s
->status
& DRQ_STAT
))
2482 ret
= cpu_to_le16(*(uint16_t *)p
);
2485 if (p
>= s
->data_end
)
2486 s
->end_transfer_func(s
);
2490 void ide_data_writel(void *opaque
, uint32_t addr
, uint32_t val
)
2492 IDEBus
*bus
= opaque
;
2493 IDEState
*s
= idebus_active_if(bus
);
2496 /* PIO data access allowed only when DRQ bit is set */
2497 if (!(s
->status
& DRQ_STAT
))
2501 *(uint32_t *)p
= le32_to_cpu(val
);
2504 if (p
>= s
->data_end
)
2505 s
->end_transfer_func(s
);
2508 uint32_t ide_data_readl(void *opaque
, uint32_t addr
)
2510 IDEBus
*bus
= opaque
;
2511 IDEState
*s
= idebus_active_if(bus
);
2515 /* PIO data access allowed only when DRQ bit is set */
2516 if (!(s
->status
& DRQ_STAT
))
2520 ret
= cpu_to_le32(*(uint32_t *)p
);
2523 if (p
>= s
->data_end
)
2524 s
->end_transfer_func(s
);
2528 static void ide_dummy_transfer_stop(IDEState
*s
)
2530 s
->data_ptr
= s
->io_buffer
;
2531 s
->data_end
= s
->io_buffer
;
2532 s
->io_buffer
[0] = 0xff;
2533 s
->io_buffer
[1] = 0xff;
2534 s
->io_buffer
[2] = 0xff;
2535 s
->io_buffer
[3] = 0xff;
2538 static void ide_reset(IDEState
*s
)
2541 printf("ide: reset\n");
2544 s
->mult_sectors
= 0;
2546 s
->mult_sectors
= MAX_MULT_SECTORS
;
2563 s
->status
= READY_STAT
| SEEK_STAT
;
2567 /* ATAPI specific */
2570 s
->cdrom_changed
= 0;
2571 s
->packet_transfer_size
= 0;
2572 s
->elementary_transfer_size
= 0;
2573 s
->io_buffer_index
= 0;
2574 s
->cd_sector_size
= 0;
2577 s
->io_buffer_size
= 0;
2578 s
->req_nb_sectors
= 0;
2580 ide_set_signature(s
);
2581 /* init the transfer handler so that 0xffff is returned on data
2583 s
->end_transfer_func
= ide_dummy_transfer_stop
;
2584 ide_dummy_transfer_stop(s
);
2585 s
->media_changed
= 0;
2588 void ide_bus_reset(IDEBus
*bus
)
2592 ide_reset(&bus
->ifs
[0]);
2593 ide_reset(&bus
->ifs
[1]);
2597 void ide_init_drive(IDEState
*s
, BlockDriverState
*bs
,
2598 const char *version
, const char *serial
)
2600 int cylinders
, heads
, secs
;
2601 uint64_t nb_sectors
;
2604 bdrv_get_geometry(bs
, &nb_sectors
);
2605 bdrv_guess_geometry(bs
, &cylinders
, &heads
, &secs
);
2606 s
->cylinders
= cylinders
;
2609 s
->nb_sectors
= nb_sectors
;
2610 /* The SMART values should be preserved across power cycles
2612 s
->smart_enabled
= 1;
2613 s
->smart_autosave
= 1;
2614 s
->smart_errors
= 0;
2615 s
->smart_selftest_count
= 0;
2616 if (bdrv_get_type_hint(bs
) == BDRV_TYPE_CDROM
) {
2618 bdrv_set_change_cb(bs
, cdrom_change_cb
, s
);
2621 strncpy(s
->drive_serial_str
, serial
, sizeof(s
->drive_serial_str
));
2623 snprintf(s
->drive_serial_str
, sizeof(s
->drive_serial_str
),
2624 "QM%05d", s
->drive_serial
);
2627 pstrcpy(s
->version
, sizeof(s
->version
), version
);
2629 pstrcpy(s
->version
, sizeof(s
->version
), QEMU_VERSION
);
2632 bdrv_set_removable(bs
, s
->is_cdrom
);
2635 static void ide_init1(IDEBus
*bus
, int unit
)
2637 static int drive_serial
= 1;
2638 IDEState
*s
= &bus
->ifs
[unit
];
2642 s
->drive_serial
= drive_serial
++;
2643 s
->io_buffer
= qemu_blockalign(s
->bs
, IDE_DMA_BUF_SECTORS
*512 + 4);
2644 s
->io_buffer_total_len
= IDE_DMA_BUF_SECTORS
*512 + 4;
2645 s
->smart_selftest_data
= qemu_blockalign(s
->bs
, 512);
2646 s
->sector_write_timer
= qemu_new_timer(vm_clock
,
2647 ide_sector_write_timer_cb
, s
);
2650 void ide_init2(IDEBus
*bus
, qemu_irq irq
)
2654 for(i
= 0; i
< 2; i
++) {
2656 ide_reset(&bus
->ifs
[i
]);
2661 /* TODO convert users to qdev and remove */
2662 void ide_init2_with_non_qdev_drives(IDEBus
*bus
, DriveInfo
*hd0
,
2663 DriveInfo
*hd1
, qemu_irq irq
)
2668 for(i
= 0; i
< 2; i
++) {
2669 dinfo
= i
== 0 ? hd0
: hd1
;
2672 ide_init_drive(&bus
->ifs
[i
], dinfo
->bdrv
, NULL
,
2673 *dinfo
->serial
? dinfo
->serial
: NULL
);
2675 ide_reset(&bus
->ifs
[i
]);
2681 void ide_init_ioport(IDEBus
*bus
, int iobase
, int iobase2
)
2683 register_ioport_write(iobase
, 8, 1, ide_ioport_write
, bus
);
2684 register_ioport_read(iobase
, 8, 1, ide_ioport_read
, bus
);
2686 register_ioport_read(iobase2
, 1, 1, ide_status_read
, bus
);
2687 register_ioport_write(iobase2
, 1, 1, ide_cmd_write
, bus
);
2691 register_ioport_write(iobase
, 2, 2, ide_data_writew
, bus
);
2692 register_ioport_read(iobase
, 2, 2, ide_data_readw
, bus
);
2693 register_ioport_write(iobase
, 4, 4, ide_data_writel
, bus
);
2694 register_ioport_read(iobase
, 4, 4, ide_data_readl
, bus
);
2697 static bool is_identify_set(void *opaque
, int version_id
)
2699 IDEState
*s
= opaque
;
2701 return s
->identify_set
!= 0;
2704 static EndTransferFunc
* transfer_end_table
[] = {
2708 ide_atapi_cmd_reply_end
,
2712 static int transfer_end_table_idx(EndTransferFunc
*fn
)
2716 for (i
= 0; i
< ARRAY_SIZE(transfer_end_table
); i
++)
2717 if (transfer_end_table
[i
] == fn
)
2723 static int ide_drive_post_load(void *opaque
, int version_id
)
2725 IDEState
*s
= opaque
;
2727 if (version_id
< 3) {
2728 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
2729 s
->asc
== ASC_MEDIUM_MAY_HAVE_CHANGED
) {
2730 s
->cdrom_changed
= 1;
2734 if (s
->cur_io_buffer_len
) {
2735 s
->end_transfer_func
= transfer_end_table
[s
->end_transfer_fn_idx
];
2736 s
->data_ptr
= s
->io_buffer
+ s
->cur_io_buffer_offset
;
2737 s
->data_end
= s
->data_ptr
+ s
->cur_io_buffer_len
;
2743 static void ide_drive_pre_save(void *opaque
)
2745 IDEState
*s
= opaque
;
2748 s
->cur_io_buffer_len
= 0;
2750 if (!(s
->status
& DRQ_STAT
))
2753 s
->cur_io_buffer_offset
= s
->data_ptr
- s
->io_buffer
;
2754 s
->cur_io_buffer_len
= s
->data_end
- s
->data_ptr
;
2756 idx
= transfer_end_table_idx(s
->end_transfer_func
);
2758 fprintf(stderr
, "%s: invalid end_transfer_func for DRQ_STAT\n",
2760 s
->end_transfer_fn_idx
= 2;
2762 s
->end_transfer_fn_idx
= idx
;
2766 const VMStateDescription vmstate_ide_drive
= {
2767 .name
= "ide_drive",
2769 .minimum_version_id
= 0,
2770 .minimum_version_id_old
= 0,
2771 .pre_save
= ide_drive_pre_save
,
2772 .post_load
= ide_drive_post_load
,
2773 .fields
= (VMStateField
[]) {
2774 VMSTATE_INT32(mult_sectors
, IDEState
),
2775 VMSTATE_INT32(identify_set
, IDEState
),
2776 VMSTATE_BUFFER_TEST(identify_data
, IDEState
, is_identify_set
),
2777 VMSTATE_UINT8(feature
, IDEState
),
2778 VMSTATE_UINT8(error
, IDEState
),
2779 VMSTATE_UINT32(nsector
, IDEState
),
2780 VMSTATE_UINT8(sector
, IDEState
),
2781 VMSTATE_UINT8(lcyl
, IDEState
),
2782 VMSTATE_UINT8(hcyl
, IDEState
),
2783 VMSTATE_UINT8(hob_feature
, IDEState
),
2784 VMSTATE_UINT8(hob_sector
, IDEState
),
2785 VMSTATE_UINT8(hob_nsector
, IDEState
),
2786 VMSTATE_UINT8(hob_lcyl
, IDEState
),
2787 VMSTATE_UINT8(hob_hcyl
, IDEState
),
2788 VMSTATE_UINT8(select
, IDEState
),
2789 VMSTATE_UINT8(status
, IDEState
),
2790 VMSTATE_UINT8(lba48
, IDEState
),
2791 VMSTATE_UINT8(sense_key
, IDEState
),
2792 VMSTATE_UINT8(asc
, IDEState
),
2793 VMSTATE_UINT8_V(cdrom_changed
, IDEState
, 3),
2794 VMSTATE_INT32_V(req_nb_sectors
, IDEState
, 4),
2795 VMSTATE_VARRAY_INT32(io_buffer
, IDEState
, io_buffer_total_len
, 4,
2796 vmstate_info_uint8
, uint8_t),
2797 VMSTATE_INT32_V(cur_io_buffer_offset
, IDEState
, 4),
2798 VMSTATE_INT32_V(cur_io_buffer_len
, IDEState
, 4),
2799 VMSTATE_UINT8_V(end_transfer_fn_idx
, IDEState
, 4),
2800 VMSTATE_INT32_V(elementary_transfer_size
, IDEState
, 4),
2801 VMSTATE_INT32_V(packet_transfer_size
, IDEState
, 4),
2802 VMSTATE_END_OF_LIST()
2806 const VMStateDescription vmstate_ide_bus
= {
2809 .minimum_version_id
= 1,
2810 .minimum_version_id_old
= 1,
2811 .fields
= (VMStateField
[]) {
2812 VMSTATE_UINT8(cmd
, IDEBus
),
2813 VMSTATE_UINT8(unit
, IDEBus
),
2814 VMSTATE_END_OF_LIST()
2818 /***********************************************************/
2819 /* PCI IDE definitions */
2821 static void ide_dma_start(IDEState
*s
, BlockDriverCompletionFunc
*dma_cb
)
2823 BMDMAState
*bm
= s
->bus
->bmdma
;
2827 bm
->dma_cb
= dma_cb
;
2828 bm
->cur_prd_last
= 0;
2829 bm
->cur_prd_addr
= 0;
2830 bm
->cur_prd_len
= 0;
2831 bm
->sector_num
= ide_get_sector(s
);
2832 bm
->nsector
= s
->nsector
;
2833 if (bm
->status
& BM_STATUS_DMAING
) {
2838 static void ide_dma_restart(IDEState
*s
, int is_read
)
2840 BMDMAState
*bm
= s
->bus
->bmdma
;
2841 ide_set_sector(s
, bm
->sector_num
);
2842 s
->io_buffer_index
= 0;
2843 s
->io_buffer_size
= 0;
2844 s
->nsector
= bm
->nsector
;
2845 bm
->cur_addr
= bm
->addr
;
2848 bm
->dma_cb
= ide_read_dma_cb
;
2850 bm
->dma_cb
= ide_write_dma_cb
;
2853 ide_dma_start(s
, bm
->dma_cb
);
2856 void ide_dma_cancel(BMDMAState
*bm
)
2858 if (bm
->status
& BM_STATUS_DMAING
) {
2861 printf("aio_cancel\n");
2863 bdrv_aio_cancel(bm
->aiocb
);
2866 bm
->status
&= ~BM_STATUS_DMAING
;
2867 /* cancel DMA request */
2873 void ide_dma_reset(BMDMAState
*bm
)
2876 printf("ide: dma_reset\n");
2883 bm
->cur_prd_last
= 0;
2884 bm
->cur_prd_addr
= 0;
2885 bm
->cur_prd_len
= 0;