--- /dev/null
+diff --git a/Makefile b/Makefile
+index a06c9bf..8a91d28 100644
+--- a/Makefile
++++ b/Makefile
+@@ -318,8 +318,9 @@ endif
+ test speed: all
+ $(MAKE) -C tests $@
+
++.PHONY: TAGS
+ TAGS:
+- etags *.[ch] tests/*.[ch]
++ find "$(SRC_PATH)" -name '*.[hc]' -print0 | xargs -0 etags
+
+ cscope:
+ rm -f ./cscope.*
+diff --git a/block.c b/block.c
+index aca5a6d..334e558 100644
+--- a/block.c
++++ b/block.c
+@@ -876,6 +876,7 @@ void bdrv_set_type_hint(BlockDriverState *bs, int type)
+ {
+ bs->type = type;
+ bs->removable = ((type == BDRV_TYPE_CDROM ||
++ type == BDRV_TYPE_CDROM_PT ||
+ type == BDRV_TYPE_FLOPPY));
+ }
+
+diff --git a/block.h b/block.h
+index 71e87fc..487eafb 100644
+--- a/block.h
++++ b/block.h
+@@ -100,9 +100,11 @@ void bdrv_flush_all(void);
+ int bdrv_is_allocated(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
+ int *pnum);
+
+-#define BDRV_TYPE_HD 0
+-#define BDRV_TYPE_CDROM 1
+-#define BDRV_TYPE_FLOPPY 2
++#define BDRV_TYPE_HD 0
++#define BDRV_TYPE_CDROM 1
++#define BDRV_TYPE_FLOPPY 2
++#define BDRV_TYPE_CDROM_PT 3
++
+ #define BIOS_ATA_TRANSLATION_AUTO 0
+ #define BIOS_ATA_TRANSLATION_NONE 1
+ #define BIOS_ATA_TRANSLATION_LBA 2
+diff --git a/block-raw-posix.c b/block-raw-posix.c
+index fa1a394..8f56654 100644
+--- a/block-raw-posix.c
++++ b/block-raw-posix.c
+@@ -99,20 +99,7 @@
+ reopen it to see if the disk has been changed */
+ #define FD_OPEN_TIMEOUT 1000
+
+-typedef struct BDRVRawState {
+- int fd;
+- int type;
+- unsigned int lseek_err_cnt;
+-#if defined(__linux__)
+- /* linux floppy specific */
+- int fd_open_flags;
+- int64_t fd_open_time;
+- int64_t fd_error_time;
+- int fd_got_error;
+- int fd_media_changed;
+-#endif
+- uint8_t* aligned_buf;
+-} BDRVRawState;
++#include "raw-posix.h"
+
+ static int posix_aio_init(void);
+
+diff --git a/block/raw-posix.h b/block/raw-posix.h
+new file mode 100644
+index 0000000..0d3bf85
+--- /dev/null
++++ b/block/raw-posix.h
+@@ -0,0 +1,19 @@
++#ifndef BLOCK_RAW_POSIX_H
++# define BLOCK_RAW_POSIX_H
++
++typedef struct BDRVRawState {
++ int fd;
++ int type;
++ unsigned int lseek_err_cnt;
++#if defined(__linux__)
++ /* linux floppy specific */
++ int fd_open_flags;
++ int64_t fd_open_time;
++ int64_t fd_error_time;
++ int fd_got_error;
++ int fd_media_changed;
++#endif
++ uint8_t* aligned_buf;
++} BDRVRawState;
++
++#endif /* !BLOCK_RAW_POSIX_H */
+diff --git a/hw/atapi-pt.c b/hw/atapi-pt.c
+new file mode 100644
+index 0000000..24358ac
+--- /dev/null
++++ b/hw/atapi-pt.c
+@@ -0,0 +1,964 @@
++#define DEBUG_IDE_ATAPI_PT
++
++#define MSF_TO_FRAMES(M, S, F) (((M) * CD_SECS + (S)) * CD_FRAMES + (F))
++
++#ifdef DEBUG_IDE_ATAPI_PT
++# define DEBUG_PRINTF(Args...) printf(Args)
++# define CHECK_SAME_VALUE(Val1, Val2) \
++ do { \
++ if ((Val1) != (Val2)) \
++ printf("[\e[1;32m!VALUE\e[m] %s:%d, %s=%d %s=%d\n", \
++ __PRETTY_FUNCTION__, __LINE__, #Val1, (Val1), \
++ #Val2, (Val2)); \
++ } while (0)
++#else
++# define DEBUG_PRINTF(Args...)
++# define CHECK_SAME_VALUE(Val1, Val2)
++#endif /* DEBUG_IDE_ATAPI_PT */
++
++/* The generic packet command opcodes for CD/DVD Logical Units,
++ * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
++static const struct {
++ unsigned short packet_command;
++ const char * const text;
++} packet_command_texts[] = {
++ { GPCMD_TEST_UNIT_READY, "Test Unit Ready" },
++ { GPCMD_REQUEST_SENSE, "Request Sense" },
++ { GPCMD_FORMAT_UNIT, "Format Unit" },
++ { GPCMD_INQUIRY, "Inquiry" },
++ { GPCMD_START_STOP_UNIT, "Start/Stop Unit" },
++ { GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL, "Prevent/Allow Medium Removal" },
++ { GPCMD_READ_FORMAT_CAPACITIES, "Read Format Capacities" },
++ { GPCMD_READ_CDVD_CAPACITY, "Read Cd/Dvd Capacity" },
++ { GPCMD_READ_10, "Read 10" },
++ { GPCMD_WRITE_10, "Write 10" },
++ { GPCMD_SEEK, "Seek" },
++ { GPCMD_WRITE_AND_VERIFY_10, "Write and Verify 10" },
++ { GPCMD_VERIFY_10, "Verify 10" },
++ { GPCMD_FLUSH_CACHE, "Flush Cache" },
++ { GPCMD_READ_SUBCHANNEL, "Read Subchannel" },
++ { GPCMD_READ_TOC_PMA_ATIP, "Read Table of Contents" },
++ { GPCMD_READ_HEADER, "Read Header" },
++ { GPCMD_PLAY_AUDIO_10, "Play Audio 10" },
++ { GPCMD_GET_CONFIGURATION, "Get Configuration" },
++ { GPCMD_PLAY_AUDIO_MSF, "Play Audio MSF" },
++ { GPCMD_PLAYAUDIO_TI, "Play Audio TrackIndex" },
++ { GPCMD_GET_EVENT_STATUS_NOTIFICATION,
++ "Get Event Status Notification" },
++ { GPCMD_PAUSE_RESUME, "Pause/Resume" },
++ { GPCMD_STOP_PLAY_SCAN, "Stop Play/Scan" },
++ { GPCMD_READ_DISC_INFO, "Read Disc Info" },
++ { GPCMD_READ_TRACK_RZONE_INFO, "Read Track Rzone Info" },
++ { GPCMD_RESERVE_RZONE_TRACK, "Reserve Rzone Track" },
++ { GPCMD_SEND_OPC, "Send OPC" },
++ { GPCMD_MODE_SELECT_10, "Mode Select 10" },
++ { GPCMD_REPAIR_RZONE_TRACK, "Repair Rzone Track" },
++ { GPCMD_MODE_SENSE_10, "Mode Sense 10" },
++ { GPCMD_CLOSE_TRACK, "Close Track" },
++ { GPCMD_BLANK, "Blank" },
++ { GPCMD_SEND_EVENT, "Send Event" },
++ { GPCMD_SEND_KEY, "Send Key" },
++ { GPCMD_REPORT_KEY, "Report Key" },
++ { GPCMD_LOAD_UNLOAD, "Load/Unload" },
++ { GPCMD_SET_READ_AHEAD, "Set Read-ahead" },
++ { GPCMD_READ_12, "Read 12" },
++ { GPCMD_GET_PERFORMANCE, "Get Performance" },
++ { GPCMD_SEND_DVD_STRUCTURE, "Send DVD Structure" },
++ { GPCMD_READ_DVD_STRUCTURE, "Read DVD Structure" },
++ { GPCMD_SET_STREAMING, "Set Streaming" },
++ { GPCMD_READ_CD_MSF, "Read CD MSF" },
++ { GPCMD_SCAN, "Scan" },
++ { GPCMD_SET_SPEED, "Set Speed" },
++ { GPCMD_PLAY_CD, "Play CD" },
++ { GPCMD_MECHANISM_STATUS, "Mechanism Status" },
++ { GPCMD_READ_CD, "Read CD" },
++ { GPCMD_READ_BUFFER_CAPACITY, "Read Buffer Capacity" },
++ { GPCMD_READ_BUFFER, "Read Buffer" },
++ { GPCMD_SEND_CUE_SHEET, "Send Cue Sheet" },
++ { 0, 0 }
++};
++
++static const char *atapi_cmd_to_str(int cmd)
++{
++ int i;
++
++ for (i = 0; packet_command_texts[i].text; ++i)
++ if (packet_command_texts[i].packet_command == cmd)
++ return packet_command_texts[i].text;
++ return 0;
++}
++
++/* From Table 303 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
++static const char * const sense_key_texts[16] = {
++ "No sense data",
++ "Recovered error",
++ "Not ready",
++ "Medium error",
++ "Hardware error",
++ "Illegal request",
++ "Unit attention",
++ "Data protect",
++ "Blank check",
++ "(reserved)",
++ "(reserved)",
++ "Aborted command",
++ "(reserved)",
++ "(reserved)",
++ "Miscompare",
++ "(reserved)",
++};
++
++/* From Table 304 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
++static const struct {
++ unsigned long asc_ascq;
++ const char * const text;
++} sense_data_texts[] = {
++ { 0x000000, "No additional sense information" },
++ { 0x000011, "Play operation in progress" },
++ { 0x000012, "Play operation paused" },
++ { 0x000013, "Play operation successfully completed" },
++ { 0x000014, "Play operation stopped due to error" },
++ { 0x000015, "No current audio status to return" },
++ { 0x010c0a, "Write error - padding blocks added" },
++ { 0x011700, "Recovered data with no error correction applied" },
++ { 0x011701, "Recovered data with retries" },
++ { 0x011702, "Recovered data with positive head offset" },
++ { 0x011703, "Recovered data with negative head offset" },
++ { 0x011704, "Recovered data with retries and/or CIRC applied" },
++ { 0x011705, "Recovered data using previous sector ID" },
++ { 0x011800, "Recovered data with error correction applied" },
++ { 0x011801, "Recovered data with error correction and retries applied"},
++ { 0x011802, "Recovered data - the data was auto-reallocated" },
++ { 0x011803, "Recovered data with CIRC" },
++ { 0x011804, "Recovered data with L-EC" },
++ { 0x015d00, "Failure prediction threshold exceeded"
++ " - Predicted logical unit failure" },
++ { 0x015d01, "Failure prediction threshold exceeded"
++ " - Predicted media failure" },
++ { 0x015dff, "Failure prediction threshold exceeded - False" },
++ { 0x017301, "Power calibration area almost full" },
++ { 0x020400, "Logical unit not ready - cause not reportable" },
++ /* Following is misspelled in ATAPI 2.6, _and_ in Mt. Fuji */
++ { 0x020401, "Logical unit not ready"
++ " - in progress [sic] of becoming ready" },
++ { 0x020402, "Logical unit not ready - initializing command required" },
++ { 0x020403, "Logical unit not ready - manual intervention required" },
++ { 0x020404, "Logical unit not ready - format in progress" },
++ { 0x020407, "Logical unit not ready - operation in progress" },
++ { 0x020408, "Logical unit not ready - long write in progress" },
++ { 0x020600, "No reference position found (media may be upside down)" },
++ { 0x023000, "Incompatible medium installed" },
++ { 0x023a00, "Medium not present" },
++ { 0x025300, "Media load or eject failed" },
++ { 0x025700, "Unable to recover table of contents" },
++ { 0x030300, "Peripheral device write fault" },
++ { 0x030301, "No write current" },
++ { 0x030302, "Excessive write errors" },
++ { 0x030c00, "Write error" },
++ { 0x030c01, "Write error - Recovered with auto reallocation" },
++ { 0x030c02, "Write error - auto reallocation failed" },
++ { 0x030c03, "Write error - recommend reassignment" },
++ { 0x030c04, "Compression check miscompare error" },
++ { 0x030c05, "Data expansion occurred during compress" },
++ { 0x030c06, "Block not compressible" },
++ { 0x030c07, "Write error - recovery needed" },
++ { 0x030c08, "Write error - recovery failed" },
++ { 0x030c09, "Write error - loss of streaming" },
++ { 0x031100, "Unrecovered read error" },
++ { 0x031106, "CIRC unrecovered error" },
++ { 0x033101, "Format command failed" },
++ { 0x033200, "No defect spare location available" },
++ { 0x033201, "Defect list update failure" },
++ { 0x035100, "Erase failure" },
++ { 0x037200, "Session fixation error" },
++ { 0x037201, "Session fixation error writin lead-in" },
++ { 0x037202, "Session fixation error writin lead-out" },
++ { 0x037300, "CD control error" },
++ { 0x037302, "Power calibration area is full" },
++ { 0x037303, "Power calibration area error" },
++ { 0x037304, "Program memory area / RMA update failure" },
++ { 0x037305, "Program memory area / RMA is full" },
++ { 0x037306, "Program memory area / RMA is (almost) full" },
++ { 0x040200, "No seek complete" },
++ { 0x040300, "Write fault" },
++ { 0x040900, "Track following error" },
++ { 0x040901, "Tracking servo failure" },
++ { 0x040902, "Focus servo failure" },
++ { 0x040903, "Spindle servo failure" },
++ { 0x041500, "Random positioning error" },
++ { 0x041501, "Mechanical positioning or changer error" },
++ { 0x041502, "Positioning error detected by read of medium" },
++ { 0x043c00, "Mechanical positioning or changer error" },
++ { 0x044000, "Diagnostic failure on component (ASCQ)" },
++ { 0x044400, "Internal CD/DVD logical unit failure" },
++ { 0x04b600, "Media load mechanism failed" },
++ { 0x051a00, "Parameter list length error" },
++ { 0x052000, "Invalid command operation code" },
++ { 0x052100, "Logical block address out of range" },
++ { 0x052102, "Invalid address for write" },
++ { 0x052400, "Invalid field in command packet" },
++ { 0x052600, "Invalid field in parameter list" },
++ { 0x052601, "Parameter not supported" },
++ { 0x052602, "Parameter value invalid" },
++ { 0x052700, "Write protected media" },
++ { 0x052c00, "Command sequence error" },
++ { 0x052c03, "Current program area is not empty" },
++ { 0x052c04, "Current program area is empty" },
++ { 0x053001, "Cannot read medium - unknown format" },
++ { 0x053002, "Cannot read medium - incompatible format" },
++ { 0x053900, "Saving parameters not supported" },
++ { 0x054e00, "Overlapped commands attempted" },
++ { 0x055302, "Medium removal prevented" },
++ { 0x055500, "System resource failure" },
++ { 0x056300, "End of user area encountered on this track" },
++ { 0x056400, "Illegal mode for this track or incompatible medium" },
++ { 0x056f00, "Copy protection key exchange failure"
++ " - Authentication failure" },
++ { 0x056f01, "Copy protection key exchange failure - Key not present" },
++ { 0x056f02, "Copy protection key exchange failure"
++ " - Key not established" },
++ { 0x056f03, "Read of scrambled sector without authentication" },
++ { 0x056f04, "Media region code is mismatched to logical unit" },
++ { 0x056f05, "Drive region must be permanent"
++ " / region reset count error" },
++ { 0x057203, "Session fixation error - incomplete track in session" },
++ { 0x057204, "Empty or partially written reserved track" },
++ { 0x057205, "No more RZONE reservations are allowed" },
++ { 0x05bf00, "Loss of streaming" },
++ { 0x062800, "Not ready to ready transition, medium may have changed" },
++ { 0x062900, "Power on, reset or hardware reset occurred" },
++ { 0x062a00, "Parameters changed" },
++ { 0x062a01, "Mode parameters changed" },
++ { 0x062e00, "Insufficient time for operation" },
++ { 0x063f00, "Logical unit operating conditions have changed" },
++ { 0x063f01, "Microcode has been changed" },
++ { 0x065a00, "Operator request or state change input (unspecified)" },
++ { 0x065a01, "Operator medium removal request" },
++ { 0x0bb900, "Play operation aborted" },
++ /* Here we use 0xff for the key (not a valid key) to signify
++ * that these can have _any_ key value associated with them... */
++ { 0xff0401, "Logical unit is in process of becoming ready" },
++ { 0xff0400, "Logical unit not ready, cause not reportable" },
++ { 0xff0402, "Logical unit not ready, initializing command required" },
++ { 0xff0403, "Logical unit not ready, manual intervention required" },
++ { 0xff0500, "Logical unit does not respond to selection" },
++ { 0xff0800, "Logical unit communication failure" },
++ { 0xff0802, "Logical unit communication parity error" },
++ { 0xff0801, "Logical unit communication time-out" },
++ { 0xff2500, "Logical unit not supported" },
++ { 0xff4c00, "Logical unit failed self-configuration" },
++ { 0xff3e00, "Logical unit has not self-configured yet" },
++};
++
++static const char *atapi_ascq_to_str(int ascq)
++{
++ int i;
++
++ for (i = 0; sense_data_texts[i].text; ++i)
++ if (sense_data_texts[i].asc_ascq == ascq)
++ return sense_data_texts[i].text;
++ return 0;
++}
++
++static void ide_atapi_pt_set_error(IDEState *s, int sense_key, int asc, int error)
++{
++ s->atapi_pt.sense.sense_key = sense_key;
++ s->atapi_pt.sense.asc = asc;
++ s->atapi_pt.sense.error_code = error;
++ s->status = READY_STAT | ERR_STAT;
++ s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
++ ide_set_irq(s);
++}
++
++static void ide_atapi_pt_error(IDEState *s)
++{
++ s->status = READY_STAT | ERR_STAT;
++ s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
++ ide_set_irq(s);
++}
++
++static void ide_atapi_pt_sg_io_finished(IDEState *s)
++{
++ BDRVRawState *raw_state = s->bs->opaque;
++ int read_bytes;
++ read_bytes = read(raw_state->fd, &s->atapi_pt.cmd, sizeof (s->atapi_pt.cmd));
++
++ if (read_bytes != sizeof (s->atapi_pt.cmd))
++ {
++ ide_atapi_pt_error(s);
++ return;
++ }
++
++ if (s->atapi_pt.cmd.driver_status ||
++ s->atapi_pt.cmd.transport_status ||
++ s->atapi_pt.cmd.device_status)
++ {
++ DEBUG_PRINTF("[\e[1;31mERROR\e[m]\n"
++ "\tsense_key: 0x%02x (\e[0;35m%s\e[m)\n"
++ "\terror: 0x%02x\n"
++ "\tasc: 0x%02x, 0x%x (\e[0;35m%s\e[m)\n"
++ "\terrno: %d (%s)\n"
++ "\tdriver: %d, transport: %d, device: %d\n",
++ s->atapi_pt.sense.sense_key,
++ sense_key_texts[s->atapi_pt.sense.sense_key],
++ s->atapi_pt.sense.error_code,
++ s->atapi_pt.sense.asc,
++ s->atapi_pt.sense.ascq,
++ atapi_ascq_to_str(s->atapi_pt.sense.ascq),
++ errno,
++ strerror(errno) ? : "(null)",
++ s->atapi_pt.cmd.driver_status,
++ s->atapi_pt.cmd.transport_status,
++ s->atapi_pt.cmd.device_status);
++ ide_atapi_pt_error(s);
++ return;
++ }
++ s->atapi_pt.cmd_sent(s);
++}
++
++#define ATAPI_PT_SEND_PACKET \
++ do { \
++ BDRVRawState *raw_state = s->bs->opaque; \
++ DEBUG_PRINTF("[ATAPI:%d] sending command: 0x%02x (\e[0;32m%s\e[m)\n", \
++ raw_state->fd, s->atapi_pt.request[0], \
++ atapi_cmd_to_str(s->atapi_pt.request[0])); \
++ memset(&s->atapi_pt.sense, 0, sizeof (s->atapi_pt.sense)); \
++ int wrote = write(raw_state->fd, &s->atapi_pt.cmd, \
++ sizeof (s->atapi_pt.cmd)); \
++ if (wrote != sizeof (s->atapi_pt.cmd)) \
++ ide_atapi_pt_error(s); \
++ } while (0)
++
++static void ide_atapi_pt_read_finish(IDEState *s)
++{
++ assert(s->atapi_pt.cmd.dout_xfer_len > 0);
++ s->atapi_pt.cmd.dout_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_cmd_ok;
++ ATAPI_PT_SEND_PACKET;
++}
++
++static void ide_atapi_pt_read_pio_end(IDEState *s)
++{
++ ide_transfer_stop(s);
++ ide_atapi_pt_read_finish(s);
++}
++
++static void ide_atapi_pt_read_dma_cb(void *opaque, int ret)
++{
++ BMDMAState *bm = opaque;
++ IDEState *s = bm->ide_if;
++ int i = 0;
++
++ if (ret < 0) {
++ ide_atapi_io_error(s, ret);
++ return;
++ }
++
++ i = dma_buf_rw(bm, 0);
++ ide_atapi_pt_read_finish(s);
++}
++
++static void ide_atapi_pt_wcmd(IDEState *s)
++{
++ if (s->atapi_dma)
++ {
++ /* DMA */
++ s->io_buffer_index = 0;
++ s->io_buffer_size = s->atapi_pt.cmd.dout_xfer_len;
++ ide_dma_start(s, ide_atapi_pt_read_dma_cb);
++ return;
++ }
++
++ /* PIO */
++ s->packet_transfer_size = s->atapi_pt.cmd.dout_xfer_len;
++ s->io_buffer_size = 0;
++ s->elementary_transfer_size = 0;
++ s->io_buffer_index = 0;
++ s->status |= DRQ_STAT;
++ s->status &= ~BUSY_STAT;
++ s->nsector = (s->nsector & ~7) &
++ ~ATAPI_INT_REASON_IO &
++ ~ATAPI_INT_REASON_CD;
++ ide_transfer_start(s, s->io_buffer, s->atapi_pt.cmd.dout_xfer_len,
++ ide_atapi_pt_read_pio_end);
++ ide_set_irq(s);
++ return;
++}
++
++static void ide_atapi_pt_read_format_capacities_sent(IDEState *s)
++{
++ int size = (s->io_buffer[3] << 3) + 4;
++ ide_atapi_cmd_reply(s, size, s->atapi_pt.cmd.din_xfer_len);
++}
++
++static void ide_atapi_pt_standard_reply(IDEState *s)
++{
++ uint32_t size = s->atapi_pt.reply_size_init;
++
++ switch (s->atapi_pt.reply_size_len)
++ {
++ case 0:
++ break;
++ case 1:
++ size += s->io_buffer[s->atapi_pt.reply_size_offset];
++ break;
++ case 2:
++ size += ube16_to_cpu(s->io_buffer + s->atapi_pt.reply_size_offset);
++ break;
++ case 3:
++ size += ube24_to_cpu(s->io_buffer + s->atapi_pt.reply_size_offset);
++ break;
++ case 4:
++ size += ube32_to_cpu(s->io_buffer + s->atapi_pt.reply_size_offset);
++ break;
++ default:
++ assert(0);
++ break;
++ }
++ printf("[reply] size: %d, din_resid: %d, max_in:%d, response_len: %d\n",
++ size, s->atapi_pt.cmd.din_resid, s->atapi_pt.cmd.din_xfer_len,
++ s->atapi_pt.cmd.response_len);
++ ide_atapi_cmd_reply(s, size, s->atapi_pt.cmd.din_xfer_len);
++}
++
++static int ide_atapi_pt_read_cd_block_size(const uint8_t *io_buffer)
++{
++ int sector_type = (io_buffer[2] >> 2) & 7;
++ int error_flags = (io_buffer[9] >> 1) & 3;
++ int flags_bits = io_buffer[9] & ~7;
++ int block_size = 0;
++
++ // expected sector type
++ switch (sector_type)
++ {
++ case 0: // Any type
++ case 1: // CD-DA
++ block_size = (flags_bits) ? 2352 : 0;
++ break;
++
++ case 2: // Mode 1
++ switch (flags_bits)
++ {
++ case 0x0: block_size = 0; break;
++ case 0x10:
++ case 0x50: block_size = 2048; break;
++ case 0x18:
++ case 0x58: block_size = 2336; break;
++ case 0x20:
++ case 0x60: block_size = 4; break;
++ case 0x30:
++ case 0x70:
++ case 0x78: block_size = 2052; break;
++ case 0x38: block_size = 2340; break;
++ case 0x40: block_size = 0; break;
++ case 0xa0: block_size = 16; break;
++ case 0xb0: block_size = 2064; break;
++ case 0xb8: block_size = 2352; break;
++ case 0xe0: block_size = 16; break;
++ case 0xf0: block_size = 2064; break;
++ case 0xf8: block_size = 2352; break;
++
++ default: assert(0); // illegal
++ }
++ break;
++
++ case 3: // Mode 2
++ switch (flags_bits)
++ {
++ case 0x0: block_size = 0; break;
++ case 0x10:
++ case 0x50:
++ case 0x18:
++ case 0x58: block_size = 2336; break;
++ case 0x20:
++ case 0x60: block_size = 4; break;
++ case 0x30:
++ case 0x70:
++ case 0x78:
++ case 0x38: block_size = 2340; break;
++ case 0x40: block_size = 0; break;
++ case 0xa0: block_size = 16; break;
++ case 0xb0:
++ case 0xb8: block_size = 2352; break;
++ case 0xe0: block_size = 16; break;
++ case 0xf0:
++ case 0xf8: block_size = 2352; break;
++ default: assert(0); // illegal
++ }
++ break;
++
++ case 4: // Mode 2 Form 1
++ switch (flags_bits)
++ {
++ case 0x0: block_size = 0; break;
++ case 0x10: block_size = 2048; break;
++ case 0x18: block_size = 2328; break;
++ case 0x20: block_size = 4; break;
++ case 0x40: block_size = 8; break;
++ case 0x50: block_size = 2056; break;
++ case 0x58: block_size = 2336; break;
++ case 0x60: block_size = 12; break;
++ case 0x70: block_size = 2060; break;
++ case 0x78: block_size = 2340; break;
++ case 0xa0: block_size = 16; break;
++ case 0xe0: block_size = 24; break;
++ case 0xf0: block_size = 2072; break;
++ case 0xf8: block_size = 2352; break;
++ default: assert(0); // illegal
++ }
++ break;
++
++ case 5: // Mode 2 Form 2
++ switch (flags_bits)
++ {
++ case 0x0: block_size = 0; break;
++ case 0x10:
++ case 0x18: block_size = 2328; break;
++ case 0x20: block_size = 4; break;
++ case 0x40: block_size = 8; break;
++ case 0x50:
++ case 0x58: block_size = 2336; break;
++ case 0x60: block_size = 12; break;
++ case 0x70:
++ case 0x78: block_size = 2340; break;
++ case 0xa0: block_size = 16; break;
++ case 0xe0: block_size = 24; break;
++ case 0xf0:
++ case 0xf8: block_size = 2352; break;
++ default: assert(0); // illegal
++ }
++ break;
++
++ default:
++ assert(0);
++ }
++
++ switch (error_flags)
++ {
++ case 1: block_size += 294; break;
++ case 2: block_size += 296; break;
++ }
++
++ return block_size;
++}
++
++static void ide_atapi_pt_cmd(IDEState *s)
++{
++ struct sg_io_v4 *cmd = &s->atapi_pt.cmd;
++
++ memset(cmd, 0, sizeof (*cmd));
++ memcpy(s->atapi_pt.request, s->io_buffer, ATAPI_PACKET_SIZE);
++ cmd->guard = 'Q';
++ cmd->protocol = 0;
++ cmd->subprotocol = 0;
++ cmd->request_len = ATAPI_PACKET_SIZE;
++ cmd->request = (__u64)s->atapi_pt.request;
++ cmd->response = (__u64)&s->atapi_pt.sense;
++ cmd->max_response_len = sizeof (s->atapi_pt.sense);
++ cmd->timeout = 15000; // 15 seconds
++
++ s->status |= BUSY_STAT;
++ s->atapi_pt.reply_size_init = 0;
++ s->atapi_pt.reply_size_offset = 0;
++ s->atapi_pt.reply_size_len = 0;
++
++ switch (s->io_buffer[0])
++ {
++ /*******************/
++ /* SIMPLE COMMANDS */
++ /*******************/
++
++ case GPCMD_BLANK: // bigger timeout while blanking
++ cmd->timeout = 1000 * 60 * 80; // 80 mins
++ goto simple_cmd;
++ case GPCMD_CLOSE_TRACK:
++ cmd->timeout = 1000 * 60 * 5; // 5 mins
++ goto simple_cmd;
++ case GPCMD_FLUSH_CACHE: // also called SYNCHRONIZE_CACHE
++ case GPCMD_LOAD_UNLOAD:
++ case GPCMD_PAUSE_RESUME:
++ case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
++ case GPCMD_REPAIR_RZONE_TRACK:
++ case GPCMD_RESERVE_RZONE_TRACK:
++ case GPCMD_SCAN:
++ case GPCMD_SEEK:
++ case GPCMD_SET_READ_AHEAD:
++ case GPCMD_START_STOP_UNIT:
++ case GPCMD_STOP_PLAY_SCAN:
++ case GPCMD_TEST_UNIT_READY:
++ case GPCMD_VERIFY_10:
++ case GPCMD_SET_SPEED: /* FIXME: find the documentation */
++ simple_cmd:
++ CHECK_SAME_VALUE(s->lcyl, 0);
++ CHECK_SAME_VALUE(s->hcyl, 0);
++ s->atapi_pt.cmd_sent = ide_atapi_cmd_ok;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ /******************/
++ /* WRITE COMMANDS */
++ /******************/
++
++ case GPCMD_WRITE_10:
++ case GPCMD_WRITE_AND_VERIFY_10:
++ cmd->dout_xfer_len = ube16_to_cpu(s->io_buffer + 7) * CD_FRAMESIZE;
++ if (cmd->dout_xfer_len == 0)
++ goto simple_cmd;
++ ide_atapi_pt_wcmd(s);
++ return;
++
++ case GPCMD_WRITE_12:
++ cmd->dout_xfer_len = ube32_to_cpu(s->io_buffer + 6);
++ if (cmd->dout_xfer_len == 0)
++ goto simple_cmd;
++ ide_atapi_pt_wcmd(s);
++ return;
++
++ case GPCMD_WRITE_BUFFER:
++ {
++ int32_t parameter_list_length = ube24_to_cpu(s->io_buffer + 3);
++ int8_t mode = s->io_buffer[1] & 0x03;
++
++ switch (mode)
++ {
++ case 0x0: // Combined header and data mode
++ // The documentation is confusing because it says that parameter
++ // list length contains all the data, but the buffer should be
++ // greater than parameter list length + 4...
++ cmd->dout_xfer_len = parameter_list_length + 4;
++ break;
++ case 0x2: // Data mode
++ cmd->dout_xfer_len = parameter_list_length;
++ break;
++ case 0x1: // Vendor specific
++ case 0x4: // Download microcode
++ case 0x5: // Download microcode and save mode
++ case 0x6: // Download microcode with offsets
++ case 0x7: // Download microcode with offsets and save mode
++ default:
++ goto illegal_request;
++ }
++
++ ide_atapi_pt_wcmd(s);
++ return;
++ }
++
++ case GPCMD_SEND_CUE_SHEET:
++ cmd->dout_xfer_len = ube24_to_cpu(s->io_buffer + 6);
++ if (cmd->dout_xfer_len == 0)
++ goto simple_cmd;
++ ide_atapi_pt_wcmd(s);
++ return;
++
++ case GPCMD_MODE_SELECT_10:
++ cmd->dout_xfer_len = ube16_to_cpu(s->io_buffer + 7);
++ CHECK_SAME_VALUE(s->lcyl | (s->hcyl << 8), cmd->dout_xfer_len);
++ if (cmd->dout_xfer_len == 0)
++ goto simple_cmd;
++ ide_atapi_pt_wcmd(s);
++ return;
++
++ case GPCMD_SEND_KEY:
++ case GPCMD_SEND_EVENT:
++ cmd->dout_xfer_len = ube16_to_cpu(s->io_buffer + 8);
++ if (cmd->dout_xfer_len == 0)
++ goto simple_cmd;
++ ide_atapi_pt_wcmd(s);
++ return;
++
++ case GPCMD_SEND_OPC:
++ cmd->dout_xfer_len = ube16_to_cpu(s->io_buffer + 7) << 3;
++ CHECK_SAME_VALUE(s->lcyl | (s->hcyl << 8), cmd->dout_xfer_len);
++ if (cmd->dout_xfer_len == 0)
++ goto simple_cmd;
++ ide_atapi_pt_wcmd(s);
++ return;
++
++ case GPCMD_SET_STREAMING:
++ cmd->dout_xfer_len = ube16_to_cpu(s->io_buffer + 9);
++ if (cmd->dout_xfer_len == 0)
++ goto simple_cmd;
++ ide_atapi_pt_wcmd(s);
++ return;
++
++ case GPCMD_FORMAT_UNIT:
++ cmd->dout_xfer_len = 12;
++ ide_atapi_pt_wcmd(s);
++ return;
++
++ /*****************/
++ /* READ COMMANDS */
++ /*****************/
++
++ case GPCMD_INQUIRY:
++ cmd->din_xferp = (__u64)s->io_buffer;
++ cmd->din_xfer_len = s->io_buffer[4];
++ s->atapi_pt.reply_size_init = 5;
++ s->atapi_pt.reply_size_offset = 4;
++ s->atapi_pt.reply_size_len = 1;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ ATAPI_PT_SEND_PACKET;
++ break;
++
++ case GPCMD_REQUEST_SENSE:
++ {
++ // send the previous sense command
++ DEBUG_PRINTF("=== REQUEST SENSE ===\n"
++ "atapi_cmd_error: sense=0x%x asc=0x%x error=0x%x\n",
++ s->atapi_pt.sense.sense_key,
++ s->atapi_pt.sense.asc,
++ s->atapi_pt.sense.error_code);
++
++ int max_size = s->io_buffer[4];
++
++ int size = 8 + s->atapi_pt.sense.add_sense_len;
++
++ printf("max_size: %d, add_sense_len: %d, sizeof: %lu\n",
++ max_size, s->atapi_pt.sense.add_sense_len,
++ sizeof (s->atapi_pt.sense));
++ memcpy(s->io_buffer, &s->atapi_pt.sense, sizeof (s->atapi_pt.sense));
++ ide_atapi_cmd_reply(s, size, max_size);
++ return;
++ }
++ case GPCMD_READ_DVD_STRUCTURE:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 8);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_len = 4;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_READ_HEADER:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 7);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_MECHANISM_STATUS:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 8);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_offset = 6;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_REPORT_KEY:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 8);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_len = 2;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_READ_BUFFER_CAPACITY:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 7);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_len = 2;
++ s->atapi_pt.reply_size_init = 2;
++ return;
++
++ case GPCMD_GET_PERFORMANCE:
++ cmd->din_xfer_len = 8 + 8 * ube16_to_cpu(s->io_buffer + 8);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_len = 4;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_READ_10:
++ case GPCMD_READ_12:
++ {
++ int blocksize = 0, nbblocks;
++
++ switch (s->io_buffer[0]) {
++ case GPCMD_READ_10: blocksize = CD_FRAMESIZE; break;
++ case GPCMD_READ_12: blocksize = CD_FRAMESIZE_RAW0; break;
++ default: assert(0);
++ }
++ nbblocks = ube16_to_cpu(s->io_buffer + 7);
++ cmd->din_xfer_len = nbblocks * blocksize;
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ ATAPI_PT_SEND_PACKET;
++ return;
++ }
++
++ case GPCMD_READ_BUFFER:
++ // TODO check this one is correct
++ cmd->din_xferp = (__u64)s->io_buffer;
++ cmd->din_xfer_len = ube24_to_cpu(s->io_buffer + 6);
++
++ switch (s->io_buffer[1] & 0x7)
++ {
++ case 0: // data with header
++ s->atapi_pt.reply_size_init = 4;
++ s->atapi_pt.reply_size_len = 3;
++ s->atapi_pt.reply_size_offset = 1;
++ break;
++
++ case 2: // data only
++ s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ break;
++
++ case 3: // header only
++ s->atapi_pt.reply_size_init = 4;
++ break;
++
++ case 1: // vendor specific
++ default:
++ goto illegal_request;
++ }
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_READ_CDVD_CAPACITY:
++ cmd->din_xfer_len = 8;
++ CHECK_SAME_VALUE(s->lcyl | (s->hcyl << 8), cmd->din_xfer_len);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_MODE_SENSE_10:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 7);
++ CHECK_SAME_VALUE(s->lcyl | (s->hcyl << 8), cmd->din_xfer_len);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_len = 2;
++ s->atapi_pt.reply_size_init = 2;
++ //s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_GET_EVENT_STATUS_NOTIFICATION:
++ case GPCMD_READ_DISC_INFO:
++ case GPCMD_READ_TOC_PMA_ATIP:
++ case GPCMD_READ_TRACK_RZONE_INFO:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 7);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_len = 2;
++ s->atapi_pt.reply_size_init = 2;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_READ_SUBCHANNEL:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 7);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_len = 2;
++ s->atapi_pt.reply_size_offset = 2;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_READ_CD:
++ {
++ // command fields
++ int block_count = ((s->io_buffer[6] << 16) |
++ ube16_to_cpu(s->io_buffer + 7));
++ int block_size = ide_atapi_pt_read_cd_block_size(s->io_buffer);
++
++ cmd->din_xfer_len = block_count * block_size;
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ ATAPI_PT_SEND_PACKET;
++ return;
++ }
++
++ case GPCMD_READ_CD_MSF:
++ {
++ // command fields
++ int starting_frame =
++ MSF_TO_FRAMES(s->io_buffer[3], s->io_buffer[4], s->io_buffer[5]);
++ int ending_frame =
++ MSF_TO_FRAMES(s->io_buffer[6], s->io_buffer[7], s->io_buffer[8]);
++ int block_count = ending_frame - starting_frame;
++ int block_size = ide_atapi_pt_read_cd_block_size(s->io_buffer);
++
++ cmd->din_xfer_len = block_count * block_size;
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ ATAPI_PT_SEND_PACKET;
++ return;
++ }
++
++ case GPCMD_PLAY_AUDIO_10:
++ {
++ int block_count = ube16_to_cpu(s->io_buffer + 7);
++ cmd->din_xfer_len = block_count * CD_FRAMESIZE;
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ ATAPI_PT_SEND_PACKET;
++ return;
++ }
++
++ case GPCMD_PLAY_AUDIO_MSF:
++ {
++ int starting_frame =
++ MSF_TO_FRAMES(s->io_buffer[3], s->io_buffer[4], s->io_buffer[5]);
++ int ending_frame =
++ MSF_TO_FRAMES(s->io_buffer[6], s->io_buffer[7], s->io_buffer[8]);
++ int block_count = ending_frame - starting_frame;
++ cmd->din_xfer_len = block_count * CD_FRAMESIZE;
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = cmd->din_xfer_len;
++ ATAPI_PT_SEND_PACKET;
++ return;
++ }
++
++ case GPCMD_READ_FORMAT_CAPACITIES:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 7);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_read_format_capacities_sent;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_GET_CONFIGURATION:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 7);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = 4;
++ s->atapi_pt.reply_size_len = 4;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case GPCMD_SEND_DVD_STRUCTURE:
++ cmd->din_xfer_len = ube16_to_cpu(s->io_buffer + 8);
++ cmd->din_xferp = (__u64)s->io_buffer;
++ s->atapi_pt.cmd_sent = ide_atapi_pt_standard_reply;
++ s->atapi_pt.reply_size_init = 2;
++ s->atapi_pt.reply_size_len = 2;
++ ATAPI_PT_SEND_PACKET;
++ return;
++
++ case 0x01: // GPMODE_R_W_ERROR_PAGE ?
++ case 0x1a: // GPMODE_POWER_PAGE ?
++ case 0xfa:
++ case 0xfd:
++ case 0xf2:
++ case 0xf3: // WIN_SECURITY_ERASE_PREPARE ?
++ case 0xee: // WIN_IDENTIFY_DMA ?
++ case 0xdf: // WIN_DOORUNLOCK ?
++ DEBUG_PRINTF("[\e[3;31mILLEGAL?\e[m] 0x%02x, size: %d\n",
++ s->io_buffer[0], s->lcyl | (s->hcyl << 8));
++ illegal_request:
++ ide_atapi_pt_set_error(s, SENSE_ILLEGAL_REQUEST,
++ ASC_ILLEGAL_OPCODE, 0x70);
++ return;
++
++ default:
++ DEBUG_PRINTF("[UNHANDLED] 0x%02x\n", s->io_buffer[0]);
++ exit(1);
++ return;
++ }
++}
+diff --git a/hw/ide.c b/hw/ide.c
+index f3787f2..ee6a3aa 100644
+--- a/hw/ide.c
++++ b/hw/ide.c
+@@ -22,6 +22,7 @@
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
++
+ #include "hw.h"
+ #include "pc.h"
+ #include "pci.h"
+@@ -36,6 +37,15 @@
+ #include "sh.h"
+ #include "dma.h"
+
++#ifdef __linux__
++# include "block/raw-posix.h"
++
++# include <linux/cdrom.h>
++# include <linux/bsg.h>
++#endif /* __linux__ */
++
++#include <assert.h>
++
+ /* debug IDE devices */
+ //#define DEBUG_IDE
+ //#define DEBUG_IDE_ATAPI
+@@ -216,83 +226,94 @@
+
+ #define ATAPI_PACKET_SIZE 12
+
+-/* The generic packet command opcodes for CD/DVD Logical Units,
+- * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
+-#define GPCMD_BLANK 0xa1
+-#define GPCMD_CLOSE_TRACK 0x5b
+-#define GPCMD_FLUSH_CACHE 0x35
+-#define GPCMD_FORMAT_UNIT 0x04
+-#define GPCMD_GET_CONFIGURATION 0x46
+-#define GPCMD_GET_EVENT_STATUS_NOTIFICATION 0x4a
+-#define GPCMD_GET_PERFORMANCE 0xac
+-#define GPCMD_INQUIRY 0x12
+-#define GPCMD_LOAD_UNLOAD 0xa6
+-#define GPCMD_MECHANISM_STATUS 0xbd
+-#define GPCMD_MODE_SELECT_10 0x55
+-#define GPCMD_MODE_SENSE_10 0x5a
+-#define GPCMD_PAUSE_RESUME 0x4b
+-#define GPCMD_PLAY_AUDIO_10 0x45
+-#define GPCMD_PLAY_AUDIO_MSF 0x47
+-#define GPCMD_PLAY_AUDIO_TI 0x48
+-#define GPCMD_PLAY_CD 0xbc
+-#define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
+-#define GPCMD_READ_10 0x28
+-#define GPCMD_READ_12 0xa8
+-#define GPCMD_READ_CDVD_CAPACITY 0x25
+-#define GPCMD_READ_CD 0xbe
+-#define GPCMD_READ_CD_MSF 0xb9
+-#define GPCMD_READ_DISC_INFO 0x51
+-#define GPCMD_READ_DVD_STRUCTURE 0xad
+-#define GPCMD_READ_FORMAT_CAPACITIES 0x23
+-#define GPCMD_READ_HEADER 0x44
+-#define GPCMD_READ_TRACK_RZONE_INFO 0x52
+-#define GPCMD_READ_SUBCHANNEL 0x42
+-#define GPCMD_READ_TOC_PMA_ATIP 0x43
+-#define GPCMD_REPAIR_RZONE_TRACK 0x58
+-#define GPCMD_REPORT_KEY 0xa4
+-#define GPCMD_REQUEST_SENSE 0x03
+-#define GPCMD_RESERVE_RZONE_TRACK 0x53
+-#define GPCMD_SCAN 0xba
+-#define GPCMD_SEEK 0x2b
+-#define GPCMD_SEND_DVD_STRUCTURE 0xad
+-#define GPCMD_SEND_EVENT 0xa2
+-#define GPCMD_SEND_KEY 0xa3
+-#define GPCMD_SEND_OPC 0x54
+-#define GPCMD_SET_READ_AHEAD 0xa7
+-#define GPCMD_SET_STREAMING 0xb6
+-#define GPCMD_START_STOP_UNIT 0x1b
+-#define GPCMD_STOP_PLAY_SCAN 0x4e
+-#define GPCMD_TEST_UNIT_READY 0x00
+-#define GPCMD_VERIFY_10 0x2f
+-#define GPCMD_WRITE_10 0x2a
+-#define GPCMD_WRITE_AND_VERIFY_10 0x2e
++#ifndef _LINUX_CDROM_H
++/*********************************************************************
++ * Generic Packet commands, MMC commands, and such
++ *********************************************************************/
++
++ /* The generic packet command opcodes for CD/DVD Logical Units,
++ * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
++# define GPCMD_BLANK 0xa1
++# define GPCMD_CLOSE_TRACK 0x5b
++# define GPCMD_FLUSH_CACHE 0x35
++# define GPCMD_FORMAT_UNIT 0x04
++# define GPCMD_GET_CONFIGURATION 0x46
++# define GPCMD_GET_EVENT_STATUS_NOTIFICATION 0x4a
++# define GPCMD_GET_PERFORMANCE 0xac
++# define GPCMD_INQUIRY 0x12
++# define GPCMD_LOAD_UNLOAD 0xa6
++# define GPCMD_MECHANISM_STATUS 0xbd
++# define GPCMD_MODE_SELECT_10 0x55
++# define GPCMD_MODE_SENSE_10 0x5a
++# define GPCMD_PAUSE_RESUME 0x4b
++# define GPCMD_PLAY_AUDIO_10 0x45
++# define GPCMD_PLAY_AUDIO_MSF 0x47
++# define GPCMD_PLAY_AUDIO_TI 0x48
++# define GPCMD_PLAY_CD 0xbc
++# define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
++# define GPCMD_READ_10 0x28
++# define GPCMD_READ_12 0xa8
++# define GPCMD_READ_BUFFER 0x3c
++# define GPCMD_READ_BUFFER_CAPACITY 0x5c
++# define GPCMD_READ_CDVD_CAPACITY 0x25
++# define GPCMD_READ_CD 0xbe
++# define GPCMD_READ_CD_MSF 0xb9
++# define GPCMD_READ_DISC_INFO 0x51
++# define GPCMD_READ_DVD_STRUCTURE 0xad
++# define GPCMD_READ_FORMAT_CAPACITIES 0x23
++# define GPCMD_READ_HEADER 0x44
++# define GPCMD_READ_TRACK_RZONE_INFO 0x52
++# define GPCMD_READ_SUBCHANNEL 0x42
++# define GPCMD_READ_TOC_PMA_ATIP 0x43
++# define GPCMD_REPAIR_RZONE_TRACK 0x58
++# define GPCMD_REPORT_KEY 0xa4
++# define GPCMD_REQUEST_SENSE 0x03
++# define GPCMD_RESERVE_RZONE_TRACK 0x53
++# define GPCMD_SEND_CUE_SHEET 0x5d
++# define GPCMD_SCAN 0xba
++# define GPCMD_SEEK 0x2b
++# define GPCMD_SEND_DVD_STRUCTURE 0xbf
++# define GPCMD_SEND_EVENT 0xa2
++# define GPCMD_SEND_KEY 0xa3
++# define GPCMD_SEND_OPC 0x54
++# define GPCMD_SET_READ_AHEAD 0xa7
++# define GPCMD_SET_STREAMING 0xb6
++# define GPCMD_START_STOP_UNIT 0x1b
++# define GPCMD_STOP_PLAY_SCAN 0x4e
++# define GPCMD_TEST_UNIT_READY 0x00
++# define GPCMD_VERIFY_10 0x2f
++# define GPCMD_WRITE_10 0x2a
++# define GPCMD_WRITE_12 0xaa
++# define GPCMD_WRITE_AND_VERIFY_10 0x2e
++# define GPCMD_WRITE_BUFFER 0x3b
+ /* This is listed as optional in ATAPI 2.6, but is (curiously)
+ * missing from Mt. Fuji, Table 57. It _is_ mentioned in Mt. Fuji
+ * Table 377 as an MMC command for SCSi devices though... Most ATAPI
+ * drives support it. */
+-#define GPCMD_SET_SPEED 0xbb
++# define GPCMD_SET_SPEED 0xbb
+ /* This seems to be a SCSI specific CD-ROM opcode
+ * to play data at track/index */
+-#define GPCMD_PLAYAUDIO_TI 0x48
++# define GPCMD_PLAYAUDIO_TI 0x48
+ /*
+ * From MS Media Status Notification Support Specification. For
+ * older drives only.
+ */
+-#define GPCMD_GET_MEDIA_STATUS 0xda
+-#define GPCMD_MODE_SENSE_6 0x1a
++# define GPCMD_GET_MEDIA_STATUS 0xda
+
+ /* Mode page codes for mode sense/set */
+-#define GPMODE_R_W_ERROR_PAGE 0x01
+-#define GPMODE_WRITE_PARMS_PAGE 0x05
+-#define GPMODE_AUDIO_CTL_PAGE 0x0e
+-#define GPMODE_POWER_PAGE 0x1a
+-#define GPMODE_FAULT_FAIL_PAGE 0x1c
+-#define GPMODE_TO_PROTECT_PAGE 0x1d
+-#define GPMODE_CAPABILITIES_PAGE 0x2a
+-#define GPMODE_ALL_PAGES 0x3f
+-/* Not in Mt. Fuji, but in ATAPI 2.6 -- depricated now in favor
++# define GPMODE_VENDOR_PAGE 0x00
++# define GPMODE_R_W_ERROR_PAGE 0x01
++# define GPMODE_WRITE_PARMS_PAGE 0x05
++# define GPMODE_WCACHING_PAGE 0x08
++# define GPMODE_AUDIO_CTL_PAGE 0x0e
++# define GPMODE_POWER_PAGE 0x1a
++# define GPMODE_FAULT_FAIL_PAGE 0x1c
++# define GPMODE_TO_PROTECT_PAGE 0x1d
++# define GPMODE_CAPABILITIES_PAGE 0x2a
++# define GPMODE_ALL_PAGES 0x3f
++/* Not in Mt. Fuji, but in ATAPI 2.6 -- deprecated now in favor
+ * of MODE_SENSE_POWER_PAGE */
+-#define GPMODE_CDROM_PAGE 0x0d
++# define GPMODE_CDROM_PAGE 0x0d
+
+ /*
+ * Based on values from <linux/cdrom.h> but extending CD_MINS
+@@ -304,10 +325,13 @@
+ */
+
+ /* Some generally useful CD-ROM information */
+-#define CD_MINS 80 /* max. minutes per CD */
+-#define CD_SECS 60 /* seconds per minute */
+-#define CD_FRAMES 75 /* frames per second */
+-#define CD_FRAMESIZE 2048 /* bytes per frame, "cooked" mode */
++# define CD_MINS 80 /* max. minutes per CD */
++# define CD_SECS 60 /* seconds per minute */
++# define CD_FRAMES 75 /* frames per second */
++# define CD_FRAMESIZE 2048 /* bytes per frame, "cooked" mode */
++
++#endif /* !_LINUX_CDROM_H */
++
+ #define CD_MAX_BYTES (CD_MINS * CD_SECS * CD_FRAMES * CD_FRAMESIZE)
+ #define CD_MAX_SECTORS (CD_MAX_BYTES / 512)
+
+@@ -346,12 +370,15 @@
+ #define MMC_PROFILE_HDDVD_RW_DL 0x005A
+ #define MMC_PROFILE_INVALID 0xFFFF
+
++
+ #define ATAPI_INT_REASON_CD 0x01 /* 0 = data transfer */
+ #define ATAPI_INT_REASON_IO 0x02 /* 1 = transfer to the host */
+ #define ATAPI_INT_REASON_REL 0x04
+ #define ATAPI_INT_REASON_TAG 0xf8
+
+ /* same constants as bochs */
++#define ASC_NONE 0x00
++#define ASC_READ_ERROR 0x11
+ #define ASC_ILLEGAL_OPCODE 0x20
+ #define ASC_LOGICAL_BLOCK_OOR 0x21
+ #define ASC_INV_FIELD_IN_CMD_PACKET 0x24
+@@ -367,15 +394,42 @@
+ #define CFA_INVALID_ADDRESS 0x21
+ #define CFA_ADDRESS_OVERFLOW 0x2f
+
+-#define SENSE_NONE 0
+-#define SENSE_NOT_READY 2
+-#define SENSE_ILLEGAL_REQUEST 5
+-#define SENSE_UNIT_ATTENTION 6
++/* Sense keys */
++#define SENSE_NONE 0
++#define SENSE_RECOVERED_ERROR 1
++#define SENSE_NOT_READY 2
++#define SENSE_MEDIUM_ERROR 3
++#define SENSE_HARDWARE_ERROR 4
++#define SENSE_ILLEGAL_REQUEST 5
++#define SENSE_UNIT_ATTENTION 6
++#define SENSE_DATA_PROTECT 7
++#define SENSE_BLANK_CHECK 8
++#define SENSE_VENDOR_SPECIFIC 9
++#define SENSE_COPY_ABORTED 10
++#define SENSE_ABORTED_COMMAND 11
++#define SENSE_VOLUME_OVERFLOW 13
++#define SENSE_MISCOMPARE 14
++
++#define IO_BUFFER_MAX_SIZE (IDE_DMA_BUF_SECTORS * 512 + 4)
+
+ struct IDEState;
+
+ typedef void EndTransferFunc(struct IDEState *);
+
++#ifdef __linux__
++typedef struct ATAPIPassThroughState
++{
++ uint8_t request[ATAPI_PACKET_SIZE];
++ struct sg_io_v4 cmd;
++ struct request_sense sense;
++ void (*cmd_sent)(struct IDEState *);
++
++ uint32_t reply_size_init; // initial value
++ uint32_t reply_size_offset; // offset in s->io_buffer
++ uint32_t reply_size_len; // length in byte (0, 1, 2, 3 or 4)
++} ATAPIPassThroughState;
++#endif /* __linux__ */
++
+ /* NOTE: IDEState represents in fact one drive */
+ typedef struct IDEState {
+ /* ide config */
+@@ -424,6 +478,10 @@ typedef struct IDEState {
+ int lba;
+ int cd_sector_size;
+ int atapi_dma; /* true if dma is requested for the packet cmd */
++#ifdef __linux__
++ ATAPIPassThroughState atapi_pt;
++#endif /* __linux__ */
++ void (*atapi_cmd)(struct IDEState *); // the ATAPI cmd handler
+ /* ATA DMA state */
+ int io_buffer_size;
+ QEMUSGList sg;
+@@ -764,6 +822,8 @@ static inline void ide_set_irq(IDEState *s)
+ if (bm) {
+ bm->status |= BM_STATUS_INT;
+ }
++ if (s->is_cdrom)
++ puts("@@@@@@@@ CDROM IRQ");
+ qemu_irq_raise(s->irq);
+ }
+ }
+@@ -1100,9 +1160,9 @@ static void ide_sector_write(IDEState *s)
+ that at the expense of slower write performances. Use this
+ option _only_ to install Windows 2000. You must disable it
+ for normal use. */
+- qemu_mod_timer(s->sector_write_timer,
++ qemu_mod_timer(s->sector_write_timer,
+ qemu_get_clock(vm_clock) + (ticks_per_sec / 1000));
+- } else
++ } else
+ #endif
+ {
+ ide_set_irq(s);
+@@ -1229,6 +1289,13 @@ static inline int ube16_to_cpu(const uint8_t *buf)
+ return (buf[0] << 8) | buf[1];
+ }
+
++#ifdef __linux__ /* only atapi-pt uses it so let's avoid unused warning */
++static inline int ube24_to_cpu(const uint8_t *buf)
++{
++ return (buf[0] << 16) | (buf[1] << 8) | buf[2];
++}
++#endif /* __linux */
++
+ static inline int ube32_to_cpu(const uint8_t *buf)
+ {
+ return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
+@@ -1297,12 +1364,14 @@ static void ide_atapi_io_error(IDEState *s, int ret)
+ static void ide_atapi_cmd_reply_end(IDEState *s)
+ {
+ int byte_count_limit, size, ret;
++
+ #ifdef DEBUG_IDE_ATAPI
+ printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
+ s->packet_transfer_size,
+ s->elementary_transfer_size,
+ s->io_buffer_index);
+ #endif
++
+ if (s->packet_transfer_size <= 0) {
+ /* end of transfer */
+ ide_transfer_stop(s);
+@@ -1312,63 +1381,65 @@ static void ide_atapi_cmd_reply_end(IDEState *s)
+ #ifdef DEBUG_IDE_ATAPI
+ printf("status=0x%x\n", s->status);
+ #endif
+- } else {
+- /* see if a new sector must be read */
+- if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
+- ret = cd_read_sector(s->bs, s->lba, s->io_buffer, s->cd_sector_size);
+- if (ret < 0) {
+- ide_transfer_stop(s);
+- ide_atapi_io_error(s, ret);
+- return;
+- }
+- s->lba++;
+- s->io_buffer_index = 0;
++ return;
++ }
++
++ /* see if a new sector must be read */
++ if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
++ ret = cd_read_sector(s->bs, s->lba, s->io_buffer, s->cd_sector_size);
++ if (ret < 0) {
++ ide_transfer_stop(s);
++ ide_atapi_io_error(s, ret);
++ return;
+ }
+- if (s->elementary_transfer_size > 0) {
+- /* there are some data left to transmit in this elementary
+- transfer */
+- size = s->cd_sector_size - s->io_buffer_index;
+- if (size > s->elementary_transfer_size)
+- size = s->elementary_transfer_size;
+- ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
+- size, ide_atapi_cmd_reply_end);
+- s->packet_transfer_size -= size;
+- s->elementary_transfer_size -= size;
+- s->io_buffer_index += size;
+- } else {
+- /* a new transfer is needed */
+- s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
+- byte_count_limit = s->lcyl | (s->hcyl << 8);
++ s->lba++;
++ s->io_buffer_index = 0;
++ }
++
++ if (s->elementary_transfer_size > 0) {
++ /* there are some data left to transmit in this elementary
++ transfer */
++ size = s->cd_sector_size - s->io_buffer_index;
++ if (size > s->elementary_transfer_size)
++ size = s->elementary_transfer_size;
++ ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
++ size, ide_atapi_cmd_reply_end);
++ s->packet_transfer_size -= size;
++ s->elementary_transfer_size -= size;
++ s->io_buffer_index += size;
++ } else {
++ /* a new transfer is needed */
++ s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
++ byte_count_limit = s->lcyl | (s->hcyl << 8);
+ #ifdef DEBUG_IDE_ATAPI
+- printf("byte_count_limit=%d\n", byte_count_limit);
++ printf("byte_count_limit=%d\n", byte_count_limit);
+ #endif
+- if (byte_count_limit == 0xffff)
++ if (byte_count_limit == 0xffff)
++ byte_count_limit--;
++ size = s->packet_transfer_size;
++ if (size > byte_count_limit) {
++ /* byte count limit must be even if this case */
++ if (byte_count_limit & 1)
+ byte_count_limit--;
+- size = s->packet_transfer_size;
+- if (size > byte_count_limit) {
+- /* byte count limit must be even if this case */
+- if (byte_count_limit & 1)
+- byte_count_limit--;
+- size = byte_count_limit;
+- }
+- s->lcyl = size;
+- s->hcyl = size >> 8;
+- s->elementary_transfer_size = size;
+- /* we cannot transmit more than one sector at a time */
+- if (s->lba != -1) {
+- if (size > (s->cd_sector_size - s->io_buffer_index))
+- size = (s->cd_sector_size - s->io_buffer_index);
+- }
+- ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
+- size, ide_atapi_cmd_reply_end);
+- s->packet_transfer_size -= size;
+- s->elementary_transfer_size -= size;
+- s->io_buffer_index += size;
+- ide_set_irq(s);
++ size = byte_count_limit;
++ }
++ s->lcyl = size;
++ s->hcyl = size >> 8;
++ s->elementary_transfer_size = size;
++ /* we cannot transmit more than one sector at a time */
++ if (s->lba != -1) {
++ if (size > (s->cd_sector_size - s->io_buffer_index))
++ size = (s->cd_sector_size - s->io_buffer_index);
++ }
++ ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
++ size, ide_atapi_cmd_reply_end);
++ s->packet_transfer_size -= size;
++ s->elementary_transfer_size -= size;
++ s->io_buffer_index += size;
++ ide_set_irq(s);
+ #ifdef DEBUG_IDE_ATAPI
+- printf("status=0x%x\n", s->status);
++ printf("status=0x%x\n", s->status);
+ #endif
+- }
+ }
+ }
+
+@@ -1616,6 +1687,10 @@ static int ide_dvd_read_structure(IDEState *s, int format,
+ }
+ }
+
++#ifdef __linux__
++# include "atapi-pt.c"
++#endif
++
+ static void ide_atapi_cmd(IDEState *s)
+ {
+ const uint8_t *packet;
+@@ -1651,7 +1726,6 @@ static void ide_atapi_cmd(IDEState *s)
+ ASC_MEDIUM_NOT_PRESENT);
+ }
+ break;
+- case GPCMD_MODE_SENSE_6:
+ case GPCMD_MODE_SENSE_10:
+ {
+ int action, code;
+@@ -1664,9 +1738,9 @@ static void ide_atapi_cmd(IDEState *s)
+ switch(action) {
+ case 0: /* current values */
+ switch(code) {
+- case 0x01: /* error recovery */
++ case 0x01: /* read write error recovery parameters */
+ cpu_to_ube16(&buf[0], 16 + 6);
+- buf[2] = 0x70;
++ buf[2] = 0x70; /* Obselete: medium type code */
+ buf[3] = 0;
+ buf[4] = 0;
+ buf[5] = 0;
+@@ -1683,17 +1757,17 @@ static void ide_atapi_cmd(IDEState *s)
+ buf[15] = 0x00;
+ ide_atapi_cmd_reply(s, 16, max_len);
+ break;
+- case 0x2a:
++ case 0x2a: /* CD/DVD capabilities & mechanical status */
+ cpu_to_ube16(&buf[0], 28 + 6);
+- buf[2] = 0x70;
++ buf[2] = 0x70; /* Obselete: medium type code */
+ buf[3] = 0;
+ buf[4] = 0;
+ buf[5] = 0;
+ buf[6] = 0;
+ buf[7] = 0;
+
+- buf[8] = 0x2a;
+- buf[9] = 0x12;
++ buf[8] = 0x2a; /* page code */
++ buf[9] = 0x12; /* page lenght */
+ buf[10] = 0x00;
+ buf[11] = 0x00;
+
+@@ -1716,6 +1790,7 @@ static void ide_atapi_cmd(IDEState *s)
+ buf[27] = 0;
+ ide_atapi_cmd_reply(s, 28, max_len);
+ break;
++
+ default:
+ goto error_cmd;
+ }
+@@ -1848,7 +1923,7 @@ static void ide_atapi_cmd(IDEState *s)
+ break;
+ case GPCMD_MECHANISM_STATUS:
+ {
+- max_len = ube16_to_cpu(packet + 8);
++ max_len = ube16_to_cpu(packet + 8);
+ cpu_to_ube16(buf, 0);
+ /* no current LBA */
+ buf[2] = 0;
+@@ -1863,7 +1938,6 @@ static void ide_atapi_cmd(IDEState *s)
+ {
+ int format, msf, start_track, len;
+ uint64_t total_sectors;
+-
+ bdrv_get_geometry(s->bs, &total_sectors);
+ total_sectors >>= 2;
+ if (total_sectors == 0) {
+@@ -2017,7 +2091,7 @@ static void ide_atapi_cmd(IDEState *s)
+ max_len = 512;
+
+ memset(buf, 0, max_len);
+- /*
++ /*
+ * the number of sectors from the media tells us which profile
+ * to use as current. 0 means there is no media
+ */
+@@ -2218,7 +2292,11 @@ static void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
+
+ /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
+ if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET)
++ {
++ if (s->is_cdrom)
++ puts("------ DEVICE BUSY");
+ break;
++ }
+
+ switch(val) {
+ case WIN_IDENTIFY:
+@@ -2453,7 +2531,7 @@ static void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
+ else
+ s->status = READY_STAT | SEEK_STAT;
+ s->error = 0x01; /* Device 0 passed, Device 1 passed or not
+- * present.
++ * present.
+ */
+ ide_set_irq(s);
+ break;
+@@ -2474,7 +2552,7 @@ static void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
+ s->atapi_dma = s->feature & 1;
+ s->nsector = 1;
+ ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
+- ide_atapi_cmd);
++ s->atapi_cmd);
+ break;
+ /* CF-ATA commands */
+ case CFA_REQ_EXT_ERROR_CODE:
+@@ -2813,8 +2891,20 @@ static void ide_init2(IDEState *ide_state,
+
+ if (bdrv_get_type_hint(s->bs) == BDRV_TYPE_CDROM) {
+ s->is_cdrom = 1;
++ s->atapi_cmd = ide_atapi_cmd;
+ bdrv_set_change_cb(s->bs, cdrom_change_cb, s);
+ }
++#ifdef __linux__
++ else if (bdrv_get_type_hint(s->bs) == BDRV_TYPE_CDROM_PT) {
++ BDRVRawState *raw_state = s->bs->opaque;
++ s->is_cdrom = 1;
++ s->atapi_cmd = ide_atapi_pt_cmd;
++ bdrv_set_change_cb(s->bs, cdrom_change_cb, s);
++ qemu_set_fd_handler(raw_state->fd,
++ (IOHandler *)ide_atapi_pt_sg_io_finished,
++ NULL, s);
++ }
++#endif /* __linux__ */
+ }
+ s->drive_serial = drive_serial++;
+ strncpy(s->drive_serial_str, drive_get_serial(s->bs),
+diff --git a/vl.c b/vl.c
+index 60a00e1..42a72c8 100644
+--- a/vl.c
++++ b/vl.c
+@@ -2192,10 +2192,12 @@ static int bt_parse(const char *opt)
+
+ #define HD_ALIAS "index=%d,media=disk"
+ #ifdef TARGET_PPC
+ #define CDROM_ALIAS "index=1,media=cdrom"
++#define CDROM_PT_ALIAS "index=1,media=cdrompt"
+ #else
+ #define CDROM_ALIAS "index=2,media=cdrom"
++#define CDROM_PT_ALIAS "index=2,media=cdrompt"
+ #endif
+ #define FD_ALIAS "index=%d,if=floppy"
+ #define PFLASH_ALIAS "if=pflash"
+ #define MTD_ALIAS "if=mtd"
+@@ -2199,7 +2200,7 @@ int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
+ char serial[21];
+ const char *mediastr = "";
+ BlockInterfaceType type;
+- enum { MEDIA_DISK, MEDIA_CDROM } media;
++ enum { MEDIA_DISK, MEDIA_CDROM, MEDIA_CDROM_PT } media;
+ int bus_id, unit_id;
+ int cyls, heads, secs, translation;
+ BlockDriverState *bdrv;
+@@ -2358,6 +2359,8 @@ int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
+ return -1;
+ }
+ media = MEDIA_CDROM;
++ } else if (!strcmp(buf, "cdrompt")) {
++ media = MEDIA_CDROM_PT;
+ } else {
+ fprintf(stderr, "qemu: '%s' invalid media\n", str);
+ return -1;
+@@ -2523,6 +2526,9 @@ int drive_init(struct drive_opt *arg, int snapshot, void *opaque)
+ case MEDIA_CDROM:
+ bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM);
+ break;
++ case MEDIA_CDROM_PT:
++ bdrv_set_type_hint(bdrv, BDRV_TYPE_CDROM_PT);
++ break;
+ }
+ break;
+ case IF_SD:
+@@ -5249,13 +5255,16 @@ int main(int argc, char **argv, char **envp)
+ case QEMU_OPTION_cdrom:
+ drive_add(optarg, CDROM_ALIAS);
+ break;
++ case QEMU_OPTION_cdrom_pt:
++ drive_add(optarg, CDROM_PT_ALIAS);
++ break;
+ case QEMU_OPTION_boot:
+ boot_devices = optarg;
+ /* We just do some generic consistency checks */
+ {
+ /* Could easily be extended to 64 devices if needed */
+ const char *p;
+-
++
+ boot_devices_bitmap = 0;
+ for (p = boot_devices; *p != '\0'; p++) {
+ /* Allowed boot devices are:
projects / xenclient / ioemu-pq.git / commitdiff