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
26 #include "hw/ide/internal.h"
29 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
);
31 static void padstr8(uint8_t *buf
, int buf_size
, const char *src
)
34 for(i
= 0; i
< buf_size
; i
++) {
42 static inline void cpu_to_ube16(uint8_t *buf
, int val
)
48 static inline void cpu_to_ube32(uint8_t *buf
, unsigned int val
)
56 static inline int ube16_to_cpu(const uint8_t *buf
)
58 return (buf
[0] << 8) | buf
[1];
61 static inline int ube32_to_cpu(const uint8_t *buf
)
63 return (buf
[0] << 24) | (buf
[1] << 16) | (buf
[2] << 8) | buf
[3];
66 static void lba_to_msf(uint8_t *buf
, int lba
)
69 buf
[0] = (lba
/ 75) / 60;
70 buf
[1] = (lba
/ 75) % 60;
74 /* XXX: DVDs that could fit on a CD will be reported as a CD */
75 static inline int media_present(IDEState
*s
)
77 return (s
->nb_sectors
> 0);
80 static inline int media_is_dvd(IDEState
*s
)
82 return (media_present(s
) && s
->nb_sectors
> CD_MAX_SECTORS
);
85 static inline int media_is_cd(IDEState
*s
)
87 return (media_present(s
) && s
->nb_sectors
<= CD_MAX_SECTORS
);
90 static void cd_data_to_raw(uint8_t *buf
, int lba
)
94 memset(buf
+ 1, 0xff, 10);
99 buf
[3] = 0x01; /* mode 1 data */
103 /* XXX: ECC not computed */
107 static int cd_read_sector(BlockDriverState
*bs
, int lba
, uint8_t *buf
,
112 switch(sector_size
) {
114 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
, 4);
117 ret
= bdrv_read(bs
, (int64_t)lba
<< 2, buf
+ 16, 4);
120 cd_data_to_raw(buf
, lba
);
129 void ide_atapi_cmd_ok(IDEState
*s
)
132 s
->status
= READY_STAT
| SEEK_STAT
;
133 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
137 void ide_atapi_cmd_error(IDEState
*s
, int sense_key
, int asc
)
139 #ifdef DEBUG_IDE_ATAPI
140 printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key
, asc
);
142 s
->error
= sense_key
<< 4;
143 s
->status
= READY_STAT
| ERR_STAT
;
144 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
145 s
->sense_key
= sense_key
;
150 void ide_atapi_io_error(IDEState
*s
, int ret
)
152 /* XXX: handle more errors */
153 if (ret
== -ENOMEDIUM
) {
154 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
155 ASC_MEDIUM_NOT_PRESENT
);
157 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
158 ASC_LOGICAL_BLOCK_OOR
);
162 /* The whole ATAPI transfer logic is handled in this function */
163 void ide_atapi_cmd_reply_end(IDEState
*s
)
165 int byte_count_limit
, size
, ret
;
166 #ifdef DEBUG_IDE_ATAPI
167 printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
168 s
->packet_transfer_size
,
169 s
->elementary_transfer_size
,
172 if (s
->packet_transfer_size
<= 0) {
173 /* end of transfer */
174 ide_transfer_stop(s
);
175 s
->status
= READY_STAT
| SEEK_STAT
;
176 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
178 #ifdef DEBUG_IDE_ATAPI
179 printf("status=0x%x\n", s
->status
);
182 /* see if a new sector must be read */
183 if (s
->lba
!= -1 && s
->io_buffer_index
>= s
->cd_sector_size
) {
184 ret
= cd_read_sector(s
->bs
, s
->lba
, s
->io_buffer
, s
->cd_sector_size
);
186 ide_transfer_stop(s
);
187 ide_atapi_io_error(s
, ret
);
191 s
->io_buffer_index
= 0;
193 if (s
->elementary_transfer_size
> 0) {
194 /* there are some data left to transmit in this elementary
196 size
= s
->cd_sector_size
- s
->io_buffer_index
;
197 if (size
> s
->elementary_transfer_size
)
198 size
= s
->elementary_transfer_size
;
199 s
->packet_transfer_size
-= size
;
200 s
->elementary_transfer_size
-= size
;
201 s
->io_buffer_index
+= size
;
202 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
- size
,
203 size
, ide_atapi_cmd_reply_end
);
205 /* a new transfer is needed */
206 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
;
207 byte_count_limit
= s
->lcyl
| (s
->hcyl
<< 8);
208 #ifdef DEBUG_IDE_ATAPI
209 printf("byte_count_limit=%d\n", byte_count_limit
);
211 if (byte_count_limit
== 0xffff)
213 size
= s
->packet_transfer_size
;
214 if (size
> byte_count_limit
) {
215 /* byte count limit must be even if this case */
216 if (byte_count_limit
& 1)
218 size
= byte_count_limit
;
222 s
->elementary_transfer_size
= size
;
223 /* we cannot transmit more than one sector at a time */
225 if (size
> (s
->cd_sector_size
- s
->io_buffer_index
))
226 size
= (s
->cd_sector_size
- s
->io_buffer_index
);
228 s
->packet_transfer_size
-= size
;
229 s
->elementary_transfer_size
-= size
;
230 s
->io_buffer_index
+= size
;
231 ide_transfer_start(s
, s
->io_buffer
+ s
->io_buffer_index
- size
,
232 size
, ide_atapi_cmd_reply_end
);
234 #ifdef DEBUG_IDE_ATAPI
235 printf("status=0x%x\n", s
->status
);
241 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
242 static void ide_atapi_cmd_reply(IDEState
*s
, int size
, int max_size
)
246 s
->lba
= -1; /* no sector read */
247 s
->packet_transfer_size
= size
;
248 s
->io_buffer_size
= size
; /* dma: send the reply data as one chunk */
249 s
->elementary_transfer_size
= 0;
250 s
->io_buffer_index
= 0;
253 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
;
254 s
->bus
->dma
->ops
->start_dma(s
->bus
->dma
, s
,
255 ide_atapi_cmd_read_dma_cb
);
257 s
->status
= READY_STAT
| SEEK_STAT
;
258 ide_atapi_cmd_reply_end(s
);
262 /* start a CD-CDROM read command */
263 static void ide_atapi_cmd_read_pio(IDEState
*s
, int lba
, int nb_sectors
,
267 s
->packet_transfer_size
= nb_sectors
* sector_size
;
268 s
->elementary_transfer_size
= 0;
269 s
->io_buffer_index
= sector_size
;
270 s
->cd_sector_size
= sector_size
;
272 s
->status
= READY_STAT
| SEEK_STAT
;
273 ide_atapi_cmd_reply_end(s
);
276 static void ide_atapi_cmd_check_status(IDEState
*s
)
278 #ifdef DEBUG_IDE_ATAPI
279 printf("atapi_cmd_check_status\n");
281 s
->error
= MC_ERR
| (SENSE_UNIT_ATTENTION
<< 4);
282 s
->status
= ERR_STAT
;
286 /* ATAPI DMA support */
288 /* XXX: handle read errors */
289 static void ide_atapi_cmd_read_dma_cb(void *opaque
, int ret
)
291 IDEState
*s
= opaque
;
295 ide_atapi_io_error(s
, ret
);
299 if (s
->io_buffer_size
> 0) {
301 * For a cdrom read sector command (s->lba != -1),
302 * adjust the lba for the next s->io_buffer_size chunk
303 * and dma the current chunk.
304 * For a command != read (s->lba == -1), just transfer
308 if (s
->cd_sector_size
== 2352) {
310 cd_data_to_raw(s
->io_buffer
, s
->lba
);
312 n
= s
->io_buffer_size
>> 11;
316 s
->packet_transfer_size
-= s
->io_buffer_size
;
317 if (s
->bus
->dma
->ops
->rw_buf(s
->bus
->dma
, 1) == 0)
321 if (s
->packet_transfer_size
<= 0) {
322 s
->status
= READY_STAT
| SEEK_STAT
;
323 s
->nsector
= (s
->nsector
& ~7) | ATAPI_INT_REASON_IO
| ATAPI_INT_REASON_CD
;
326 s
->bus
->dma
->ops
->add_status(s
->bus
->dma
, BM_STATUS_INT
);
331 s
->io_buffer_index
= 0;
332 if (s
->cd_sector_size
== 2352) {
334 s
->io_buffer_size
= s
->cd_sector_size
;
337 n
= s
->packet_transfer_size
>> 11;
338 if (n
> (IDE_DMA_BUF_SECTORS
/ 4))
339 n
= (IDE_DMA_BUF_SECTORS
/ 4);
340 s
->io_buffer_size
= n
* 2048;
344 printf("aio_read_cd: lba=%u n=%d\n", s
->lba
, n
);
346 s
->bus
->dma
->iov
.iov_base
= (void *)(s
->io_buffer
+ data_offset
);
347 s
->bus
->dma
->iov
.iov_len
= n
* 4 * 512;
348 qemu_iovec_init_external(&s
->bus
->dma
->qiov
, &s
->bus
->dma
->iov
, 1);
349 s
->bus
->dma
->aiocb
= bdrv_aio_readv(s
->bs
, (int64_t)s
->lba
<< 2,
350 &s
->bus
->dma
->qiov
, n
* 4,
351 ide_atapi_cmd_read_dma_cb
, s
);
352 if (!s
->bus
->dma
->aiocb
) {
353 /* Note: media not present is the most likely case */
354 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
355 ASC_MEDIUM_NOT_PRESENT
);
360 /* start a CD-CDROM read command with DMA */
361 /* XXX: test if DMA is available */
362 static void ide_atapi_cmd_read_dma(IDEState
*s
, int lba
, int nb_sectors
,
366 s
->packet_transfer_size
= nb_sectors
* sector_size
;
367 s
->io_buffer_index
= 0;
368 s
->io_buffer_size
= 0;
369 s
->cd_sector_size
= sector_size
;
371 /* XXX: check if BUSY_STAT should be set */
372 s
->status
= READY_STAT
| SEEK_STAT
| DRQ_STAT
| BUSY_STAT
;
373 s
->bus
->dma
->ops
->start_dma(s
->bus
->dma
, s
,
374 ide_atapi_cmd_read_dma_cb
);
377 static void ide_atapi_cmd_read(IDEState
*s
, int lba
, int nb_sectors
,
380 #ifdef DEBUG_IDE_ATAPI
381 printf("read %s: LBA=%d nb_sectors=%d\n", s
->atapi_dma
? "dma" : "pio",
385 ide_atapi_cmd_read_dma(s
, lba
, nb_sectors
, sector_size
);
387 ide_atapi_cmd_read_pio(s
, lba
, nb_sectors
, sector_size
);
391 static inline uint8_t ide_atapi_set_profile(uint8_t *buf
, uint8_t *index
,
394 uint8_t *buf_profile
= buf
+ 12; /* start of profiles */
396 buf_profile
+= ((*index
) * 4); /* start of indexed profile */
397 cpu_to_ube16 (buf_profile
, profile
);
398 buf_profile
[2] = ((buf_profile
[0] == buf
[6]) && (buf_profile
[1] == buf
[7]));
400 /* each profile adds 4 bytes to the response */
402 buf
[11] += 4; /* Additional Length */
407 static int ide_dvd_read_structure(IDEState
*s
, int format
,
408 const uint8_t *packet
, uint8_t *buf
)
411 case 0x0: /* Physical format information */
413 int layer
= packet
[6];
414 uint64_t total_sectors
;
417 return -ASC_INV_FIELD_IN_CMD_PACKET
;
419 bdrv_get_geometry(s
->bs
, &total_sectors
);
421 if (total_sectors
== 0)
422 return -ASC_MEDIUM_NOT_PRESENT
;
424 buf
[4] = 1; /* DVD-ROM, part version 1 */
425 buf
[5] = 0xf; /* 120mm disc, minimum rate unspecified */
426 buf
[6] = 1; /* one layer, read-only (per MMC-2 spec) */
427 buf
[7] = 0; /* default densities */
429 /* FIXME: 0x30000 per spec? */
430 cpu_to_ube32(buf
+ 8, 0); /* start sector */
431 cpu_to_ube32(buf
+ 12, total_sectors
- 1); /* end sector */
432 cpu_to_ube32(buf
+ 16, total_sectors
- 1); /* l0 end sector */
434 /* Size of buffer, not including 2 byte size field */
435 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
437 /* 2k data + 4 byte header */
441 case 0x01: /* DVD copyright information */
442 buf
[4] = 0; /* no copyright data */
443 buf
[5] = 0; /* no region restrictions */
445 /* Size of buffer, not including 2 byte size field */
446 cpu_to_be16wu((uint16_t *)buf
, 4 + 2);
448 /* 4 byte header + 4 byte data */
451 case 0x03: /* BCA information - invalid field for no BCA info */
452 return -ASC_INV_FIELD_IN_CMD_PACKET
;
454 case 0x04: /* DVD disc manufacturing information */
455 /* Size of buffer, not including 2 byte size field */
456 cpu_to_be16wu((uint16_t *)buf
, 2048 + 2);
458 /* 2k data + 4 byte header */
463 * This lists all the command capabilities above. Add new ones
464 * in order and update the length and buffer return values.
467 buf
[4] = 0x00; /* Physical format */
468 buf
[5] = 0x40; /* Not writable, is readable */
469 cpu_to_be16wu((uint16_t *)(buf
+ 6), 2048 + 4);
471 buf
[8] = 0x01; /* Copyright info */
472 buf
[9] = 0x40; /* Not writable, is readable */
473 cpu_to_be16wu((uint16_t *)(buf
+ 10), 4 + 4);
475 buf
[12] = 0x03; /* BCA info */
476 buf
[13] = 0x40; /* Not writable, is readable */
477 cpu_to_be16wu((uint16_t *)(buf
+ 14), 188 + 4);
479 buf
[16] = 0x04; /* Manufacturing info */
480 buf
[17] = 0x40; /* Not writable, is readable */
481 cpu_to_be16wu((uint16_t *)(buf
+ 18), 2048 + 4);
483 /* Size of buffer, not including 2 byte size field */
484 cpu_to_be16wu((uint16_t *)buf
, 16 + 2);
486 /* data written + 4 byte header */
489 default: /* TODO: formats beyond DVD-ROM requires */
490 return -ASC_INV_FIELD_IN_CMD_PACKET
;
494 static unsigned int event_status_media(IDEState
*s
,
497 enum media_event_code
{
498 MEC_NO_CHANGE
= 0, /* Status unchanged */
499 MEC_EJECT_REQUESTED
, /* received a request from user to eject */
500 MEC_NEW_MEDIA
, /* new media inserted and ready for access */
501 MEC_MEDIA_REMOVAL
, /* only for media changers */
502 MEC_MEDIA_CHANGED
, /* only for media changers */
503 MEC_BG_FORMAT_COMPLETED
, /* MRW or DVD+RW b/g format completed */
504 MEC_BG_FORMAT_RESTARTED
, /* MRW or DVD+RW b/g format restarted */
508 MS_MEDIA_PRESENT
= 2,
510 uint8_t event_code
, media_status
;
513 if (s
->bs
->tray_open
) {
514 media_status
= MS_TRAY_OPEN
;
515 } else if (bdrv_is_inserted(s
->bs
)) {
516 media_status
= MS_MEDIA_PRESENT
;
519 /* Event notification descriptor */
520 event_code
= MEC_NO_CHANGE
;
521 if (media_status
!= MS_TRAY_OPEN
&& s
->events
.new_media
) {
522 event_code
= MEC_NEW_MEDIA
;
523 s
->events
.new_media
= false;
527 buf
[5] = media_status
;
529 /* These fields are reserved, just clear them. */
533 return 8; /* We wrote to 4 extra bytes from the header */
536 static void handle_get_event_status_notification(IDEState
*s
,
538 const uint8_t *packet
)
542 uint8_t polled
; /* lsb bit is polled; others are reserved */
543 uint8_t reserved2
[2];
545 uint8_t reserved3
[2];
548 } __attribute__((packed
)) *gesn_cdb
;
552 uint8_t notification_class
;
553 uint8_t supported_events
;
554 } __attribute((packed
)) *gesn_event_header
;
556 enum notification_class_request_type
{
557 NCR_RESERVED1
= 1 << 0,
558 NCR_OPERATIONAL_CHANGE
= 1 << 1,
559 NCR_POWER_MANAGEMENT
= 1 << 2,
560 NCR_EXTERNAL_REQUEST
= 1 << 3,
562 NCR_MULTI_HOST
= 1 << 5,
563 NCR_DEVICE_BUSY
= 1 << 6,
564 NCR_RESERVED2
= 1 << 7,
566 enum event_notification_class_field
{
568 ENC_OPERATIONAL_CHANGE
,
569 ENC_POWER_MANAGEMENT
,
570 ENC_EXTERNAL_REQUEST
,
576 unsigned int max_len
, used_len
;
578 gesn_cdb
= (void *)packet
;
579 gesn_event_header
= (void *)buf
;
581 max_len
= be16_to_cpu(gesn_cdb
->len
);
583 /* It is fine by the MMC spec to not support async mode operations */
584 if (!(gesn_cdb
->polled
& 0x01)) { /* asynchronous mode */
585 /* Only polling is supported, asynchronous mode is not. */
586 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
587 ASC_INV_FIELD_IN_CMD_PACKET
);
591 /* polling mode operation */
594 * These are the supported events.
596 * We currently only support requests of the 'media' type.
598 gesn_event_header
->supported_events
= NCR_MEDIA
;
601 * We use |= below to set the class field; other bits in this byte
602 * are reserved now but this is useful to do if we have to use the
603 * reserved fields later.
605 gesn_event_header
->notification_class
= 0;
608 * Responses to requests are to be based on request priority. The
609 * notification_class_request_type enum above specifies the
610 * priority: upper elements are higher prio than lower ones.
612 if (gesn_cdb
->class & NCR_MEDIA
) {
613 gesn_event_header
->notification_class
|= ENC_MEDIA
;
614 used_len
= event_status_media(s
, buf
);
616 gesn_event_header
->notification_class
= 0x80; /* No event available */
617 used_len
= sizeof(*gesn_event_header
);
619 gesn_event_header
->len
= cpu_to_be16(used_len
620 - sizeof(*gesn_event_header
));
621 ide_atapi_cmd_reply(s
, used_len
, max_len
);
624 void ide_atapi_cmd(IDEState
*s
)
626 const uint8_t *packet
;
630 packet
= s
->io_buffer
;
632 #ifdef DEBUG_IDE_ATAPI
635 printf("ATAPI limit=0x%x packet:", s
->lcyl
| (s
->hcyl
<< 8));
636 for(i
= 0; i
< ATAPI_PACKET_SIZE
; i
++) {
637 printf(" %02x", packet
[i
]);
643 * If there's a UNIT_ATTENTION condition pending, only
644 * REQUEST_SENSE, INQUIRY, GET_CONFIGURATION and
645 * GET_EVENT_STATUS_NOTIFICATION commands are allowed to complete.
646 * MMC-5, section 4.1.6.1 lists only these commands being allowed
647 * to complete, with other commands getting a CHECK condition
648 * response unless a higher priority status, defined by the drive
651 if (s
->sense_key
== SENSE_UNIT_ATTENTION
&&
652 s
->io_buffer
[0] != GPCMD_REQUEST_SENSE
&&
653 s
->io_buffer
[0] != GPCMD_INQUIRY
&&
654 s
->io_buffer
[0] != GPCMD_GET_EVENT_STATUS_NOTIFICATION
) {
655 ide_atapi_cmd_check_status(s
);
658 if (bdrv_is_inserted(s
->bs
) && s
->cdrom_changed
) {
659 ide_atapi_cmd_error(s
, SENSE_NOT_READY
, ASC_MEDIUM_NOT_PRESENT
);
661 s
->cdrom_changed
= 0;
662 s
->sense_key
= SENSE_UNIT_ATTENTION
;
663 s
->asc
= ASC_MEDIUM_MAY_HAVE_CHANGED
;
666 switch(s
->io_buffer
[0]) {
667 case GPCMD_TEST_UNIT_READY
:
668 if (bdrv_is_inserted(s
->bs
)) {
671 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
672 ASC_MEDIUM_NOT_PRESENT
);
675 case GPCMD_MODE_SENSE_6
:
676 case GPCMD_MODE_SENSE_10
:
679 if (packet
[0] == GPCMD_MODE_SENSE_10
)
680 max_len
= ube16_to_cpu(packet
+ 7);
683 action
= packet
[2] >> 6;
684 code
= packet
[2] & 0x3f;
686 case 0: /* current values */
688 case GPMODE_R_W_ERROR_PAGE
: /* error recovery */
689 cpu_to_ube16(&buf
[0], 16 + 6);
705 ide_atapi_cmd_reply(s
, 16, max_len
);
707 case GPMODE_AUDIO_CTL_PAGE
:
708 cpu_to_ube16(&buf
[0], 24 + 6);
716 /* Fill with CDROM audio volume */
722 ide_atapi_cmd_reply(s
, 24, max_len
);
724 case GPMODE_CAPABILITIES_PAGE
:
725 cpu_to_ube16(&buf
[0], 28 + 6);
738 /* Claim PLAY_AUDIO capability (0x01) since some Linux
739 code checks for this to automount media. */
742 buf
[14] = (1 << 0) | (1 << 3) | (1 << 5);
743 if (bdrv_is_locked(s
->bs
))
746 cpu_to_ube16(&buf
[16], 706);
749 cpu_to_ube16(&buf
[20], 512);
750 cpu_to_ube16(&buf
[22], 706);
755 ide_atapi_cmd_reply(s
, 28, max_len
);
761 case 1: /* changeable values */
763 case 2: /* default values */
766 case 3: /* saved values */
767 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
768 ASC_SAVING_PARAMETERS_NOT_SUPPORTED
);
773 case GPCMD_REQUEST_SENSE
:
776 buf
[0] = 0x70 | (1 << 7);
777 buf
[2] = s
->sense_key
;
780 if (s
->sense_key
== SENSE_UNIT_ATTENTION
)
781 s
->sense_key
= SENSE_NONE
;
782 ide_atapi_cmd_reply(s
, 18, max_len
);
784 case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL
:
785 bdrv_set_locked(s
->bs
, packet
[4] & 1);
793 if (packet
[0] == GPCMD_READ_10
)
794 nb_sectors
= ube16_to_cpu(packet
+ 7);
796 nb_sectors
= ube32_to_cpu(packet
+ 6);
797 lba
= ube32_to_cpu(packet
+ 2);
798 if (nb_sectors
== 0) {
802 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
807 int nb_sectors
, lba
, transfer_request
;
809 nb_sectors
= (packet
[6] << 16) | (packet
[7] << 8) | packet
[8];
810 lba
= ube32_to_cpu(packet
+ 2);
811 if (nb_sectors
== 0) {
815 transfer_request
= packet
[9];
816 switch(transfer_request
& 0xf8) {
823 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2048);
827 ide_atapi_cmd_read(s
, lba
, nb_sectors
, 2352);
830 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
831 ASC_INV_FIELD_IN_CMD_PACKET
);
839 uint64_t total_sectors
;
841 bdrv_get_geometry(s
->bs
, &total_sectors
);
843 if (total_sectors
== 0) {
844 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
845 ASC_MEDIUM_NOT_PRESENT
);
848 lba
= ube32_to_cpu(packet
+ 2);
849 if (lba
>= total_sectors
) {
850 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
851 ASC_LOGICAL_BLOCK_OOR
);
857 case GPCMD_START_STOP_UNIT
:
859 int start
, eject
, sense
, err
= 0;
860 start
= packet
[4] & 1;
861 eject
= (packet
[4] >> 1) & 1;
864 err
= bdrv_eject(s
->bs
, !start
);
872 sense
= SENSE_NOT_READY
;
873 if (bdrv_is_inserted(s
->bs
)) {
874 sense
= SENSE_ILLEGAL_REQUEST
;
876 ide_atapi_cmd_error(s
, sense
,
877 ASC_MEDIA_REMOVAL_PREVENTED
);
880 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
881 ASC_MEDIUM_NOT_PRESENT
);
886 case GPCMD_MECHANISM_STATUS
:
888 max_len
= ube16_to_cpu(packet
+ 8);
889 cpu_to_ube16(buf
, 0);
895 cpu_to_ube16(buf
+ 6, 0);
896 ide_atapi_cmd_reply(s
, 8, max_len
);
899 case GPCMD_READ_TOC_PMA_ATIP
:
901 int format
, msf
, start_track
, len
;
902 uint64_t total_sectors
;
904 bdrv_get_geometry(s
->bs
, &total_sectors
);
906 if (total_sectors
== 0) {
907 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
908 ASC_MEDIUM_NOT_PRESENT
);
911 max_len
= ube16_to_cpu(packet
+ 7);
912 format
= packet
[9] >> 6;
913 msf
= (packet
[1] >> 1) & 1;
914 start_track
= packet
[6];
917 len
= cdrom_read_toc(total_sectors
, buf
, msf
, start_track
);
920 ide_atapi_cmd_reply(s
, len
, max_len
);
923 /* multi session : only a single session defined */
928 ide_atapi_cmd_reply(s
, 12, max_len
);
931 len
= cdrom_read_toc_raw(total_sectors
, buf
, msf
, start_track
);
934 ide_atapi_cmd_reply(s
, len
, max_len
);
938 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
939 ASC_INV_FIELD_IN_CMD_PACKET
);
944 case GPCMD_READ_CDVD_CAPACITY
:
946 uint64_t total_sectors
;
948 bdrv_get_geometry(s
->bs
, &total_sectors
);
950 if (total_sectors
== 0) {
951 ide_atapi_cmd_error(s
, SENSE_NOT_READY
,
952 ASC_MEDIUM_NOT_PRESENT
);
955 /* NOTE: it is really the number of sectors minus 1 */
956 cpu_to_ube32(buf
, total_sectors
- 1);
957 cpu_to_ube32(buf
+ 4, 2048);
958 ide_atapi_cmd_reply(s
, 8, 8);
961 case GPCMD_READ_DVD_STRUCTURE
:
963 int media
= packet
[1];
964 int format
= packet
[7];
967 max_len
= ube16_to_cpu(packet
+ 8);
970 if (media_is_cd(s
)) {
971 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
972 ASC_INCOMPATIBLE_FORMAT
);
974 } else if (!media_present(s
)) {
975 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
976 ASC_INV_FIELD_IN_CMD_PACKET
);
981 memset(buf
, 0, max_len
> IDE_DMA_BUF_SECTORS
* 512 + 4 ?
982 IDE_DMA_BUF_SECTORS
* 512 + 4 : max_len
);
988 ret
= ide_dvd_read_structure(s
, format
, packet
, buf
);
991 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
, -ret
);
993 ide_atapi_cmd_reply(s
, ret
, max_len
);
997 /* TODO: BD support, fall through for now */
999 /* Generic disk structures */
1000 case 0x80: /* TODO: AACS volume identifier */
1001 case 0x81: /* TODO: AACS media serial number */
1002 case 0x82: /* TODO: AACS media identifier */
1003 case 0x83: /* TODO: AACS media key block */
1004 case 0x90: /* TODO: List of recognized format layers */
1005 case 0xc0: /* TODO: Write protection status */
1007 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1008 ASC_INV_FIELD_IN_CMD_PACKET
);
1013 case GPCMD_SET_SPEED
:
1014 ide_atapi_cmd_ok(s
);
1017 max_len
= packet
[4];
1018 buf
[0] = 0x05; /* CD-ROM */
1019 buf
[1] = 0x80; /* removable */
1020 buf
[2] = 0x00; /* ISO */
1021 buf
[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1022 buf
[4] = 31; /* additional length */
1023 buf
[5] = 0; /* reserved */
1024 buf
[6] = 0; /* reserved */
1025 buf
[7] = 0; /* reserved */
1026 padstr8(buf
+ 8, 8, "QEMU");
1027 padstr8(buf
+ 16, 16, "QEMU DVD-ROM");
1028 padstr8(buf
+ 32, 4, s
->version
);
1029 ide_atapi_cmd_reply(s
, 36, max_len
);
1031 case GPCMD_GET_CONFIGURATION
:
1036 /* only feature 0 is supported */
1037 if (packet
[2] != 0 || packet
[3] != 0) {
1038 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1039 ASC_INV_FIELD_IN_CMD_PACKET
);
1043 /* XXX: could result in alignment problems in some architectures */
1044 max_len
= ube16_to_cpu(packet
+ 7);
1047 * XXX: avoid overflow for io_buffer if max_len is bigger than
1048 * the size of that buffer (dimensioned to max number of
1049 * sectors to transfer at once)
1051 * Only a problem if the feature/profiles grow.
1053 if (max_len
> 512) /* XXX: assume 1 sector */
1056 memset(buf
, 0, max_len
);
1058 * the number of sectors from the media tells us which profile
1059 * to use as current. 0 means there is no media
1061 if (media_is_dvd(s
))
1062 cpu_to_ube16(buf
+ 6, MMC_PROFILE_DVD_ROM
);
1063 else if (media_is_cd(s
))
1064 cpu_to_ube16(buf
+ 6, MMC_PROFILE_CD_ROM
);
1066 buf
[10] = 0x02 | 0x01; /* persistent and current */
1067 len
= 12; /* headers: 8 + 4 */
1068 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_DVD_ROM
);
1069 len
+= ide_atapi_set_profile(buf
, &index
, MMC_PROFILE_CD_ROM
);
1070 cpu_to_ube32(buf
, len
- 4); /* data length */
1072 ide_atapi_cmd_reply(s
, len
, max_len
);
1075 case GPCMD_GET_EVENT_STATUS_NOTIFICATION
:
1076 handle_get_event_status_notification(s
, buf
, packet
);
1079 ide_atapi_cmd_error(s
, SENSE_ILLEGAL_REQUEST
,
1080 ASC_ILLEGAL_OPCODE
);