![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to atapi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / hw / ide|
Return to atapi.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw / ide |
1.1 root 1: /*
2: * QEMU ATAPI Emulation
3: *
4: * Copyright (c) 2003 Fabrice Bellard
5: * Copyright (c) 2006 Openedhand Ltd.
6: *
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:
13: *
14: * The above copyright notice and this permission notice shall be included in
15: * all copies or substantial portions of the Software.
16: *
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
23: * THE SOFTWARE.
24: */
25:
26: #include "hw/ide/internal.h"
27: #include "hw/scsi.h"
28:
29: static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);
30:
31: static void padstr8(uint8_t *buf, int buf_size, const char *src)
32: {
33: int i;
34: for(i = 0; i < buf_size; i++) {
35: if (*src)
36: buf[i] = *src++;
37: else
38: buf[i] = ' ';
39: }
40: }
41:
42: static inline void cpu_to_ube16(uint8_t *buf, int val)
43: {
44: buf[0] = val >> 8;
45: buf[1] = val & 0xff;
46: }
47:
48: static inline void cpu_to_ube32(uint8_t *buf, unsigned int val)
49: {
50: buf[0] = val >> 24;
51: buf[1] = val >> 16;
52: buf[2] = val >> 8;
53: buf[3] = val & 0xff;
54: }
55:
56: static inline int ube16_to_cpu(const uint8_t *buf)
57: {
58: return (buf[0] << 8) | buf[1];
59: }
60:
61: static inline int ube32_to_cpu(const uint8_t *buf)
62: {
63: return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
64: }
65:
66: static void lba_to_msf(uint8_t *buf, int lba)
67: {
68: lba += 150;
69: buf[0] = (lba / 75) / 60;
70: buf[1] = (lba / 75) % 60;
71: buf[2] = lba % 75;
72: }
73:
74: static inline int media_present(IDEState *s)
75: {
1.1.1.2 root 76: return !s->tray_open && s->nb_sectors > 0;
1.1 root 77: }
78:
79: /* XXX: DVDs that could fit on a CD will be reported as a CD */
80: static inline int media_is_dvd(IDEState *s)
81: {
82: return (media_present(s) && s->nb_sectors > CD_MAX_SECTORS);
83: }
84:
85: static inline int media_is_cd(IDEState *s)
86: {
87: return (media_present(s) && s->nb_sectors <= CD_MAX_SECTORS);
88: }
89:
90: static void cd_data_to_raw(uint8_t *buf, int lba)
91: {
92: /* sync bytes */
93: buf[0] = 0x00;
94: memset(buf + 1, 0xff, 10);
95: buf[11] = 0x00;
96: buf += 12;
97: /* MSF */
98: lba_to_msf(buf, lba);
99: buf[3] = 0x01; /* mode 1 data */
100: buf += 4;
101: /* data */
102: buf += 2048;
103: /* XXX: ECC not computed */
104: memset(buf, 0, 288);
105: }
106:
1.1.1.2 root 107: static int cd_read_sector(IDEState *s, int lba, uint8_t *buf, int sector_size)
1.1 root 108: {
109: int ret;
110:
111: switch(sector_size) {
112: case 2048:
1.1.1.2 root 113: bdrv_acct_start(s->bs, &s->acct, 4 * BDRV_SECTOR_SIZE, BDRV_ACCT_READ);
114: ret = bdrv_read(s->bs, (int64_t)lba << 2, buf, 4);
115: bdrv_acct_done(s->bs, &s->acct);
1.1 root 116: break;
117: case 2352:
1.1.1.2 root 118: bdrv_acct_start(s->bs, &s->acct, 4 * BDRV_SECTOR_SIZE, BDRV_ACCT_READ);
119: ret = bdrv_read(s->bs, (int64_t)lba << 2, buf + 16, 4);
120: bdrv_acct_done(s->bs, &s->acct);
1.1 root 121: if (ret < 0)
122: return ret;
123: cd_data_to_raw(buf, lba);
124: break;
125: default:
126: ret = -EIO;
127: break;
128: }
129: return ret;
130: }
131:
132: void ide_atapi_cmd_ok(IDEState *s)
133: {
134: s->error = 0;
135: s->status = READY_STAT | SEEK_STAT;
136: s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
137: ide_set_irq(s->bus);
138: }
139:
140: void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc)
141: {
142: #ifdef DEBUG_IDE_ATAPI
143: printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key, asc);
144: #endif
145: s->error = sense_key << 4;
146: s->status = READY_STAT | ERR_STAT;
147: s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
148: s->sense_key = sense_key;
149: s->asc = asc;
150: ide_set_irq(s->bus);
151: }
152:
153: void ide_atapi_io_error(IDEState *s, int ret)
154: {
155: /* XXX: handle more errors */
156: if (ret == -ENOMEDIUM) {
1.1.1.2 root 157: ide_atapi_cmd_error(s, NOT_READY,
1.1 root 158: ASC_MEDIUM_NOT_PRESENT);
159: } else {
1.1.1.2 root 160: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 161: ASC_LOGICAL_BLOCK_OOR);
162: }
163: }
164:
165: /* The whole ATAPI transfer logic is handled in this function */
166: void ide_atapi_cmd_reply_end(IDEState *s)
167: {
168: int byte_count_limit, size, ret;
169: #ifdef DEBUG_IDE_ATAPI
170: printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
171: s->packet_transfer_size,
172: s->elementary_transfer_size,
173: s->io_buffer_index);
174: #endif
175: if (s->packet_transfer_size <= 0) {
176: /* end of transfer */
177: ide_transfer_stop(s);
178: s->status = READY_STAT | SEEK_STAT;
179: s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
180: ide_set_irq(s->bus);
181: #ifdef DEBUG_IDE_ATAPI
182: printf("status=0x%x\n", s->status);
183: #endif
184: } else {
185: /* see if a new sector must be read */
186: if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
1.1.1.2 root 187: ret = cd_read_sector(s, s->lba, s->io_buffer, s->cd_sector_size);
1.1 root 188: if (ret < 0) {
189: ide_transfer_stop(s);
190: ide_atapi_io_error(s, ret);
191: return;
192: }
193: s->lba++;
194: s->io_buffer_index = 0;
195: }
196: if (s->elementary_transfer_size > 0) {
197: /* there are some data left to transmit in this elementary
198: transfer */
199: size = s->cd_sector_size - s->io_buffer_index;
200: if (size > s->elementary_transfer_size)
201: size = s->elementary_transfer_size;
202: s->packet_transfer_size -= size;
203: s->elementary_transfer_size -= size;
204: s->io_buffer_index += size;
205: ide_transfer_start(s, s->io_buffer + s->io_buffer_index - size,
206: size, ide_atapi_cmd_reply_end);
207: } else {
208: /* a new transfer is needed */
209: s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
210: byte_count_limit = s->lcyl | (s->hcyl << 8);
211: #ifdef DEBUG_IDE_ATAPI
212: printf("byte_count_limit=%d\n", byte_count_limit);
213: #endif
214: if (byte_count_limit == 0xffff)
215: byte_count_limit--;
216: size = s->packet_transfer_size;
217: if (size > byte_count_limit) {
218: /* byte count limit must be even if this case */
219: if (byte_count_limit & 1)
220: byte_count_limit--;
221: size = byte_count_limit;
222: }
223: s->lcyl = size;
224: s->hcyl = size >> 8;
225: s->elementary_transfer_size = size;
226: /* we cannot transmit more than one sector at a time */
227: if (s->lba != -1) {
228: if (size > (s->cd_sector_size - s->io_buffer_index))
229: size = (s->cd_sector_size - s->io_buffer_index);
230: }
231: s->packet_transfer_size -= size;
232: s->elementary_transfer_size -= size;
233: s->io_buffer_index += size;
234: ide_transfer_start(s, s->io_buffer + s->io_buffer_index - size,
235: size, ide_atapi_cmd_reply_end);
236: ide_set_irq(s->bus);
237: #ifdef DEBUG_IDE_ATAPI
238: printf("status=0x%x\n", s->status);
239: #endif
240: }
241: }
242: }
243:
244: /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
245: static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
246: {
247: if (size > max_size)
248: size = max_size;
249: s->lba = -1; /* no sector read */
250: s->packet_transfer_size = size;
251: s->io_buffer_size = size; /* dma: send the reply data as one chunk */
252: s->elementary_transfer_size = 0;
253: s->io_buffer_index = 0;
254:
255: if (s->atapi_dma) {
1.1.1.2 root 256: bdrv_acct_start(s->bs, &s->acct, size, BDRV_ACCT_READ);
1.1 root 257: s->status = READY_STAT | SEEK_STAT | DRQ_STAT;
258: s->bus->dma->ops->start_dma(s->bus->dma, s,
259: ide_atapi_cmd_read_dma_cb);
260: } else {
261: s->status = READY_STAT | SEEK_STAT;
262: ide_atapi_cmd_reply_end(s);
263: }
264: }
265:
266: /* start a CD-CDROM read command */
267: static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
268: int sector_size)
269: {
270: s->lba = lba;
271: s->packet_transfer_size = nb_sectors * sector_size;
272: s->elementary_transfer_size = 0;
273: s->io_buffer_index = sector_size;
274: s->cd_sector_size = sector_size;
275:
276: s->status = READY_STAT | SEEK_STAT;
277: ide_atapi_cmd_reply_end(s);
278: }
279:
280: static void ide_atapi_cmd_check_status(IDEState *s)
281: {
282: #ifdef DEBUG_IDE_ATAPI
283: printf("atapi_cmd_check_status\n");
284: #endif
1.1.1.2 root 285: s->error = MC_ERR | (UNIT_ATTENTION << 4);
1.1 root 286: s->status = ERR_STAT;
287: s->nsector = 0;
288: ide_set_irq(s->bus);
289: }
290: /* ATAPI DMA support */
291:
292: /* XXX: handle read errors */
293: static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
294: {
295: IDEState *s = opaque;
296: int data_offset, n;
297:
298: if (ret < 0) {
299: ide_atapi_io_error(s, ret);
300: goto eot;
301: }
302:
303: if (s->io_buffer_size > 0) {
304: /*
305: * For a cdrom read sector command (s->lba != -1),
306: * adjust the lba for the next s->io_buffer_size chunk
307: * and dma the current chunk.
308: * For a command != read (s->lba == -1), just transfer
309: * the reply data.
310: */
311: if (s->lba != -1) {
312: if (s->cd_sector_size == 2352) {
313: n = 1;
314: cd_data_to_raw(s->io_buffer, s->lba);
315: } else {
316: n = s->io_buffer_size >> 11;
317: }
318: s->lba += n;
319: }
320: s->packet_transfer_size -= s->io_buffer_size;
321: if (s->bus->dma->ops->rw_buf(s->bus->dma, 1) == 0)
322: goto eot;
323: }
324:
325: if (s->packet_transfer_size <= 0) {
326: s->status = READY_STAT | SEEK_STAT;
327: s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
328: ide_set_irq(s->bus);
1.1.1.2 root 329: goto eot;
1.1 root 330: }
331:
332: s->io_buffer_index = 0;
333: if (s->cd_sector_size == 2352) {
334: n = 1;
335: s->io_buffer_size = s->cd_sector_size;
336: data_offset = 16;
337: } else {
338: n = s->packet_transfer_size >> 11;
339: if (n > (IDE_DMA_BUF_SECTORS / 4))
340: n = (IDE_DMA_BUF_SECTORS / 4);
341: s->io_buffer_size = n * 2048;
342: data_offset = 0;
343: }
344: #ifdef DEBUG_AIO
345: printf("aio_read_cd: lba=%u n=%d\n", s->lba, n);
346: #endif
1.1.1.2 root 347:
1.1 root 348: s->bus->dma->iov.iov_base = (void *)(s->io_buffer + data_offset);
349: s->bus->dma->iov.iov_len = n * 4 * 512;
350: qemu_iovec_init_external(&s->bus->dma->qiov, &s->bus->dma->iov, 1);
1.1.1.2 root 351:
1.1 root 352: s->bus->dma->aiocb = bdrv_aio_readv(s->bs, (int64_t)s->lba << 2,
353: &s->bus->dma->qiov, n * 4,
354: ide_atapi_cmd_read_dma_cb, s);
1.1.1.2 root 355: return;
1.1.1.3 ! root 356:
1.1.1.2 root 357: eot:
358: bdrv_acct_done(s->bs, &s->acct);
359: s->bus->dma->ops->add_status(s->bus->dma, BM_STATUS_INT);
360: ide_set_inactive(s);
1.1 root 361: }
362:
363: /* start a CD-CDROM read command with DMA */
364: /* XXX: test if DMA is available */
365: static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors,
366: int sector_size)
367: {
368: s->lba = lba;
369: s->packet_transfer_size = nb_sectors * sector_size;
370: s->io_buffer_index = 0;
371: s->io_buffer_size = 0;
372: s->cd_sector_size = sector_size;
373:
1.1.1.2 root 374: bdrv_acct_start(s->bs, &s->acct, s->packet_transfer_size, BDRV_ACCT_READ);
375:
1.1 root 376: /* XXX: check if BUSY_STAT should be set */
377: s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
378: s->bus->dma->ops->start_dma(s->bus->dma, s,
379: ide_atapi_cmd_read_dma_cb);
380: }
381:
382: static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors,
383: int sector_size)
384: {
385: #ifdef DEBUG_IDE_ATAPI
386: printf("read %s: LBA=%d nb_sectors=%d\n", s->atapi_dma ? "dma" : "pio",
387: lba, nb_sectors);
388: #endif
389: if (s->atapi_dma) {
390: ide_atapi_cmd_read_dma(s, lba, nb_sectors, sector_size);
391: } else {
392: ide_atapi_cmd_read_pio(s, lba, nb_sectors, sector_size);
393: }
394: }
395:
396: static inline uint8_t ide_atapi_set_profile(uint8_t *buf, uint8_t *index,
397: uint16_t profile)
398: {
399: uint8_t *buf_profile = buf + 12; /* start of profiles */
400:
401: buf_profile += ((*index) * 4); /* start of indexed profile */
402: cpu_to_ube16 (buf_profile, profile);
403: buf_profile[2] = ((buf_profile[0] == buf[6]) && (buf_profile[1] == buf[7]));
404:
405: /* each profile adds 4 bytes to the response */
406: (*index)++;
407: buf[11] += 4; /* Additional Length */
408:
409: return 4;
410: }
411:
412: static int ide_dvd_read_structure(IDEState *s, int format,
413: const uint8_t *packet, uint8_t *buf)
414: {
415: switch (format) {
416: case 0x0: /* Physical format information */
417: {
418: int layer = packet[6];
419: uint64_t total_sectors;
420:
421: if (layer != 0)
422: return -ASC_INV_FIELD_IN_CMD_PACKET;
423:
424: total_sectors = s->nb_sectors >> 2;
425: if (total_sectors == 0) {
426: return -ASC_MEDIUM_NOT_PRESENT;
427: }
428:
429: buf[4] = 1; /* DVD-ROM, part version 1 */
430: buf[5] = 0xf; /* 120mm disc, minimum rate unspecified */
431: buf[6] = 1; /* one layer, read-only (per MMC-2 spec) */
432: buf[7] = 0; /* default densities */
433:
434: /* FIXME: 0x30000 per spec? */
435: cpu_to_ube32(buf + 8, 0); /* start sector */
436: cpu_to_ube32(buf + 12, total_sectors - 1); /* end sector */
437: cpu_to_ube32(buf + 16, total_sectors - 1); /* l0 end sector */
438:
439: /* Size of buffer, not including 2 byte size field */
440: cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
441:
442: /* 2k data + 4 byte header */
443: return (2048 + 4);
444: }
445:
446: case 0x01: /* DVD copyright information */
447: buf[4] = 0; /* no copyright data */
448: buf[5] = 0; /* no region restrictions */
449:
450: /* Size of buffer, not including 2 byte size field */
451: cpu_to_be16wu((uint16_t *)buf, 4 + 2);
452:
453: /* 4 byte header + 4 byte data */
454: return (4 + 4);
455:
456: case 0x03: /* BCA information - invalid field for no BCA info */
457: return -ASC_INV_FIELD_IN_CMD_PACKET;
458:
459: case 0x04: /* DVD disc manufacturing information */
460: /* Size of buffer, not including 2 byte size field */
461: cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
462:
463: /* 2k data + 4 byte header */
464: return (2048 + 4);
465:
466: case 0xff:
467: /*
468: * This lists all the command capabilities above. Add new ones
469: * in order and update the length and buffer return values.
470: */
471:
472: buf[4] = 0x00; /* Physical format */
473: buf[5] = 0x40; /* Not writable, is readable */
474: cpu_to_be16wu((uint16_t *)(buf + 6), 2048 + 4);
475:
476: buf[8] = 0x01; /* Copyright info */
477: buf[9] = 0x40; /* Not writable, is readable */
478: cpu_to_be16wu((uint16_t *)(buf + 10), 4 + 4);
479:
480: buf[12] = 0x03; /* BCA info */
481: buf[13] = 0x40; /* Not writable, is readable */
482: cpu_to_be16wu((uint16_t *)(buf + 14), 188 + 4);
483:
484: buf[16] = 0x04; /* Manufacturing info */
485: buf[17] = 0x40; /* Not writable, is readable */
486: cpu_to_be16wu((uint16_t *)(buf + 18), 2048 + 4);
487:
488: /* Size of buffer, not including 2 byte size field */
489: cpu_to_be16wu((uint16_t *)buf, 16 + 2);
490:
491: /* data written + 4 byte header */
492: return (16 + 4);
493:
494: default: /* TODO: formats beyond DVD-ROM requires */
495: return -ASC_INV_FIELD_IN_CMD_PACKET;
496: }
497: }
498:
499: static unsigned int event_status_media(IDEState *s,
500: uint8_t *buf)
501: {
502: uint8_t event_code, media_status;
503:
504: media_status = 0;
1.1.1.2 root 505: if (s->tray_open) {
1.1 root 506: media_status = MS_TRAY_OPEN;
507: } else if (bdrv_is_inserted(s->bs)) {
508: media_status = MS_MEDIA_PRESENT;
509: }
510:
511: /* Event notification descriptor */
512: event_code = MEC_NO_CHANGE;
1.1.1.2 root 513: if (media_status != MS_TRAY_OPEN) {
514: if (s->events.new_media) {
515: event_code = MEC_NEW_MEDIA;
516: s->events.new_media = false;
517: } else if (s->events.eject_request) {
518: event_code = MEC_EJECT_REQUESTED;
519: s->events.eject_request = false;
520: }
1.1 root 521: }
522:
523: buf[4] = event_code;
524: buf[5] = media_status;
525:
526: /* These fields are reserved, just clear them. */
527: buf[6] = 0;
528: buf[7] = 0;
529:
530: return 8; /* We wrote to 4 extra bytes from the header */
531: }
532:
533: static void cmd_get_event_status_notification(IDEState *s,
534: uint8_t *buf)
535: {
536: const uint8_t *packet = buf;
537:
538: struct {
539: uint8_t opcode;
540: uint8_t polled; /* lsb bit is polled; others are reserved */
541: uint8_t reserved2[2];
542: uint8_t class;
543: uint8_t reserved3[2];
544: uint16_t len;
545: uint8_t control;
1.1.1.2 root 546: } QEMU_PACKED *gesn_cdb;
1.1 root 547:
548: struct {
549: uint16_t len;
550: uint8_t notification_class;
551: uint8_t supported_events;
1.1.1.2 root 552: } QEMU_PACKED *gesn_event_header;
1.1 root 553: unsigned int max_len, used_len;
554:
555: gesn_cdb = (void *)packet;
556: gesn_event_header = (void *)buf;
557:
558: max_len = be16_to_cpu(gesn_cdb->len);
559:
560: /* It is fine by the MMC spec to not support async mode operations */
561: if (!(gesn_cdb->polled & 0x01)) { /* asynchronous mode */
562: /* Only polling is supported, asynchronous mode is not. */
1.1.1.2 root 563: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 564: ASC_INV_FIELD_IN_CMD_PACKET);
565: return;
566: }
567:
568: /* polling mode operation */
569:
570: /*
571: * These are the supported events.
572: *
573: * We currently only support requests of the 'media' type.
1.1.1.2 root 574: * Notification class requests and supported event classes are bitmasks,
575: * but they are build from the same values as the "notification class"
576: * field.
1.1 root 577: */
1.1.1.2 root 578: gesn_event_header->supported_events = 1 << GESN_MEDIA;
1.1 root 579:
580: /*
581: * We use |= below to set the class field; other bits in this byte
582: * are reserved now but this is useful to do if we have to use the
583: * reserved fields later.
584: */
585: gesn_event_header->notification_class = 0;
586:
587: /*
588: * Responses to requests are to be based on request priority. The
589: * notification_class_request_type enum above specifies the
590: * priority: upper elements are higher prio than lower ones.
591: */
1.1.1.2 root 592: if (gesn_cdb->class & (1 << GESN_MEDIA)) {
593: gesn_event_header->notification_class |= GESN_MEDIA;
1.1 root 594: used_len = event_status_media(s, buf);
595: } else {
596: gesn_event_header->notification_class = 0x80; /* No event available */
597: used_len = sizeof(*gesn_event_header);
598: }
599: gesn_event_header->len = cpu_to_be16(used_len
600: - sizeof(*gesn_event_header));
601: ide_atapi_cmd_reply(s, used_len, max_len);
602: }
603:
604: static void cmd_request_sense(IDEState *s, uint8_t *buf)
605: {
606: int max_len = buf[4];
607:
608: memset(buf, 0, 18);
609: buf[0] = 0x70 | (1 << 7);
610: buf[2] = s->sense_key;
611: buf[7] = 10;
612: buf[12] = s->asc;
613:
1.1.1.2 root 614: if (s->sense_key == UNIT_ATTENTION) {
615: s->sense_key = NO_SENSE;
1.1 root 616: }
617:
618: ide_atapi_cmd_reply(s, 18, max_len);
619: }
620:
621: static void cmd_inquiry(IDEState *s, uint8_t *buf)
622: {
623: int max_len = buf[4];
624:
625: buf[0] = 0x05; /* CD-ROM */
626: buf[1] = 0x80; /* removable */
627: buf[2] = 0x00; /* ISO */
628: buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
629: buf[4] = 31; /* additional length */
630: buf[5] = 0; /* reserved */
631: buf[6] = 0; /* reserved */
632: buf[7] = 0; /* reserved */
633: padstr8(buf + 8, 8, "QEMU");
634: padstr8(buf + 16, 16, "QEMU DVD-ROM");
635: padstr8(buf + 32, 4, s->version);
636: ide_atapi_cmd_reply(s, 36, max_len);
637: }
638:
639: static void cmd_get_configuration(IDEState *s, uint8_t *buf)
640: {
641: uint32_t len;
642: uint8_t index = 0;
643: int max_len;
644:
645: /* only feature 0 is supported */
646: if (buf[2] != 0 || buf[3] != 0) {
1.1.1.2 root 647: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 648: ASC_INV_FIELD_IN_CMD_PACKET);
649: return;
650: }
651:
652: /* XXX: could result in alignment problems in some architectures */
653: max_len = ube16_to_cpu(buf + 7);
654:
655: /*
656: * XXX: avoid overflow for io_buffer if max_len is bigger than
657: * the size of that buffer (dimensioned to max number of
658: * sectors to transfer at once)
659: *
660: * Only a problem if the feature/profiles grow.
661: */
662: if (max_len > 512) {
663: /* XXX: assume 1 sector */
664: max_len = 512;
665: }
666:
667: memset(buf, 0, max_len);
668: /*
669: * the number of sectors from the media tells us which profile
670: * to use as current. 0 means there is no media
671: */
672: if (media_is_dvd(s)) {
673: cpu_to_ube16(buf + 6, MMC_PROFILE_DVD_ROM);
674: } else if (media_is_cd(s)) {
675: cpu_to_ube16(buf + 6, MMC_PROFILE_CD_ROM);
676: }
677:
678: buf[10] = 0x02 | 0x01; /* persistent and current */
679: len = 12; /* headers: 8 + 4 */
680: len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_DVD_ROM);
681: len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_CD_ROM);
682: cpu_to_ube32(buf, len - 4); /* data length */
683:
684: ide_atapi_cmd_reply(s, len, max_len);
685: }
686:
687: static void cmd_mode_sense(IDEState *s, uint8_t *buf)
688: {
689: int action, code;
690: int max_len;
691:
1.1.1.2 root 692: max_len = ube16_to_cpu(buf + 7);
1.1 root 693: action = buf[2] >> 6;
694: code = buf[2] & 0x3f;
695:
696: switch(action) {
697: case 0: /* current values */
698: switch(code) {
1.1.1.2 root 699: case MODE_PAGE_R_W_ERROR: /* error recovery */
700: cpu_to_ube16(&buf[0], 16 - 2);
1.1 root 701: buf[2] = 0x70;
702: buf[3] = 0;
703: buf[4] = 0;
704: buf[5] = 0;
705: buf[6] = 0;
706: buf[7] = 0;
707:
1.1.1.2 root 708: buf[8] = MODE_PAGE_R_W_ERROR;
709: buf[9] = 16 - 10;
1.1 root 710: buf[10] = 0x00;
711: buf[11] = 0x05;
712: buf[12] = 0x00;
713: buf[13] = 0x00;
714: buf[14] = 0x00;
715: buf[15] = 0x00;
716: ide_atapi_cmd_reply(s, 16, max_len);
717: break;
1.1.1.2 root 718: case MODE_PAGE_AUDIO_CTL:
719: cpu_to_ube16(&buf[0], 24 - 2);
1.1 root 720: buf[2] = 0x70;
721: buf[3] = 0;
722: buf[4] = 0;
723: buf[5] = 0;
724: buf[6] = 0;
725: buf[7] = 0;
726:
1.1.1.2 root 727: buf[8] = MODE_PAGE_AUDIO_CTL;
728: buf[9] = 24 - 10;
1.1 root 729: /* Fill with CDROM audio volume */
730: buf[17] = 0;
731: buf[19] = 0;
732: buf[21] = 0;
733: buf[23] = 0;
734:
735: ide_atapi_cmd_reply(s, 24, max_len);
736: break;
1.1.1.2 root 737: case MODE_PAGE_CAPABILITIES:
738: cpu_to_ube16(&buf[0], 30 - 2);
1.1 root 739: buf[2] = 0x70;
740: buf[3] = 0;
741: buf[4] = 0;
742: buf[5] = 0;
743: buf[6] = 0;
744: buf[7] = 0;
745:
1.1.1.2 root 746: buf[8] = MODE_PAGE_CAPABILITIES;
747: buf[9] = 30 - 10;
748: buf[10] = 0x3b; /* read CDR/CDRW/DVDROM/DVDR/DVDRAM */
1.1 root 749: buf[11] = 0x00;
750:
751: /* Claim PLAY_AUDIO capability (0x01) since some Linux
752: code checks for this to automount media. */
753: buf[12] = 0x71;
754: buf[13] = 3 << 5;
755: buf[14] = (1 << 0) | (1 << 3) | (1 << 5);
1.1.1.2 root 756: if (s->tray_locked) {
757: buf[14] |= 1 << 1;
758: }
759: buf[15] = 0x00; /* No volume & mute control, no changer */
760: cpu_to_ube16(&buf[16], 704); /* 4x read speed */
761: buf[18] = 0; /* Two volume levels */
1.1 root 762: buf[19] = 2;
1.1.1.2 root 763: cpu_to_ube16(&buf[20], 512); /* 512k buffer */
764: cpu_to_ube16(&buf[22], 704); /* 4x read speed current */
1.1 root 765: buf[24] = 0;
766: buf[25] = 0;
767: buf[26] = 0;
768: buf[27] = 0;
1.1.1.2 root 769: buf[28] = 0;
770: buf[29] = 0;
771: ide_atapi_cmd_reply(s, 30, max_len);
1.1 root 772: break;
773: default:
774: goto error_cmd;
775: }
776: break;
777: case 1: /* changeable values */
778: goto error_cmd;
779: case 2: /* default values */
780: goto error_cmd;
781: default:
782: case 3: /* saved values */
1.1.1.2 root 783: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 784: ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
785: break;
786: }
787: return;
788:
789: error_cmd:
1.1.1.2 root 790: ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_INV_FIELD_IN_CMD_PACKET);
1.1 root 791: }
792:
793: static void cmd_test_unit_ready(IDEState *s, uint8_t *buf)
794: {
795: /* Not Ready Conditions are already handled in ide_atapi_cmd(), so if we
796: * come here, we know that it's ready. */
797: ide_atapi_cmd_ok(s);
798: }
799:
800: static void cmd_prevent_allow_medium_removal(IDEState *s, uint8_t* buf)
801: {
1.1.1.2 root 802: s->tray_locked = buf[4] & 1;
803: bdrv_lock_medium(s->bs, buf[4] & 1);
1.1 root 804: ide_atapi_cmd_ok(s);
805: }
806:
807: static void cmd_read(IDEState *s, uint8_t* buf)
808: {
809: int nb_sectors, lba;
810:
811: if (buf[0] == GPCMD_READ_10) {
812: nb_sectors = ube16_to_cpu(buf + 7);
813: } else {
814: nb_sectors = ube32_to_cpu(buf + 6);
815: }
816:
817: lba = ube32_to_cpu(buf + 2);
818: if (nb_sectors == 0) {
819: ide_atapi_cmd_ok(s);
820: return;
821: }
822:
823: ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
824: }
825:
826: static void cmd_read_cd(IDEState *s, uint8_t* buf)
827: {
828: int nb_sectors, lba, transfer_request;
829:
830: nb_sectors = (buf[6] << 16) | (buf[7] << 8) | buf[8];
831: lba = ube32_to_cpu(buf + 2);
832:
833: if (nb_sectors == 0) {
834: ide_atapi_cmd_ok(s);
835: return;
836: }
837:
838: transfer_request = buf[9];
839: switch(transfer_request & 0xf8) {
840: case 0x00:
841: /* nothing */
842: ide_atapi_cmd_ok(s);
843: break;
844: case 0x10:
845: /* normal read */
846: ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
847: break;
848: case 0xf8:
849: /* read all data */
850: ide_atapi_cmd_read(s, lba, nb_sectors, 2352);
851: break;
852: default:
1.1.1.2 root 853: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 854: ASC_INV_FIELD_IN_CMD_PACKET);
855: break;
856: }
857: }
858:
859: static void cmd_seek(IDEState *s, uint8_t* buf)
860: {
861: unsigned int lba;
862: uint64_t total_sectors = s->nb_sectors >> 2;
863:
864: lba = ube32_to_cpu(buf + 2);
865: if (lba >= total_sectors) {
1.1.1.2 root 866: ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_LOGICAL_BLOCK_OOR);
1.1 root 867: return;
868: }
869:
870: ide_atapi_cmd_ok(s);
871: }
872:
873: static void cmd_start_stop_unit(IDEState *s, uint8_t* buf)
874: {
1.1.1.2 root 875: int sense;
876: bool start = buf[4] & 1;
877: bool loej = buf[4] & 2; /* load on start, eject on !start */
878:
879: if (loej) {
880: if (!start && !s->tray_open && s->tray_locked) {
881: sense = bdrv_is_inserted(s->bs)
882: ? NOT_READY : ILLEGAL_REQUEST;
883: ide_atapi_cmd_error(s, sense, ASC_MEDIA_REMOVAL_PREVENTED);
884: return;
1.1 root 885: }
1.1.1.3 ! root 886:
! 887: if (s->tray_open != !start) {
! 888: bdrv_eject(s->bs, !start);
! 889: s->tray_open = !start;
! 890: }
1.1 root 891: }
1.1.1.2 root 892:
893: ide_atapi_cmd_ok(s);
1.1 root 894: }
895:
896: static void cmd_mechanism_status(IDEState *s, uint8_t* buf)
897: {
898: int max_len = ube16_to_cpu(buf + 8);
899:
900: cpu_to_ube16(buf, 0);
901: /* no current LBA */
902: buf[2] = 0;
903: buf[3] = 0;
904: buf[4] = 0;
905: buf[5] = 1;
906: cpu_to_ube16(buf + 6, 0);
907: ide_atapi_cmd_reply(s, 8, max_len);
908: }
909:
910: static void cmd_read_toc_pma_atip(IDEState *s, uint8_t* buf)
911: {
912: int format, msf, start_track, len;
913: int max_len;
914: uint64_t total_sectors = s->nb_sectors >> 2;
915:
916: max_len = ube16_to_cpu(buf + 7);
917: format = buf[9] >> 6;
918: msf = (buf[1] >> 1) & 1;
919: start_track = buf[6];
920:
921: switch(format) {
922: case 0:
923: len = cdrom_read_toc(total_sectors, buf, msf, start_track);
924: if (len < 0)
925: goto error_cmd;
926: ide_atapi_cmd_reply(s, len, max_len);
927: break;
928: case 1:
929: /* multi session : only a single session defined */
930: memset(buf, 0, 12);
931: buf[1] = 0x0a;
932: buf[2] = 0x01;
933: buf[3] = 0x01;
934: ide_atapi_cmd_reply(s, 12, max_len);
935: break;
936: case 2:
937: len = cdrom_read_toc_raw(total_sectors, buf, msf, start_track);
938: if (len < 0)
939: goto error_cmd;
940: ide_atapi_cmd_reply(s, len, max_len);
941: break;
942: default:
943: error_cmd:
1.1.1.2 root 944: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 945: ASC_INV_FIELD_IN_CMD_PACKET);
946: }
947: }
948:
949: static void cmd_read_cdvd_capacity(IDEState *s, uint8_t* buf)
950: {
951: uint64_t total_sectors = s->nb_sectors >> 2;
952:
953: /* NOTE: it is really the number of sectors minus 1 */
954: cpu_to_ube32(buf, total_sectors - 1);
955: cpu_to_ube32(buf + 4, 2048);
956: ide_atapi_cmd_reply(s, 8, 8);
957: }
958:
959: static void cmd_read_dvd_structure(IDEState *s, uint8_t* buf)
960: {
961: int max_len;
962: int media = buf[1];
963: int format = buf[7];
964: int ret;
965:
966: max_len = ube16_to_cpu(buf + 8);
967:
968: if (format < 0xff) {
969: if (media_is_cd(s)) {
1.1.1.2 root 970: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 971: ASC_INCOMPATIBLE_FORMAT);
972: return;
973: } else if (!media_present(s)) {
1.1.1.2 root 974: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 975: ASC_INV_FIELD_IN_CMD_PACKET);
976: return;
977: }
978: }
979:
980: memset(buf, 0, max_len > IDE_DMA_BUF_SECTORS * 512 + 4 ?
981: IDE_DMA_BUF_SECTORS * 512 + 4 : max_len);
982:
983: switch (format) {
984: case 0x00 ... 0x7f:
985: case 0xff:
986: if (media == 0) {
987: ret = ide_dvd_read_structure(s, format, buf, buf);
988:
989: if (ret < 0) {
1.1.1.2 root 990: ide_atapi_cmd_error(s, ILLEGAL_REQUEST, -ret);
1.1 root 991: } else {
992: ide_atapi_cmd_reply(s, ret, max_len);
993: }
994:
995: break;
996: }
997: /* TODO: BD support, fall through for now */
998:
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 */
1006: default:
1.1.1.2 root 1007: ide_atapi_cmd_error(s, ILLEGAL_REQUEST,
1.1 root 1008: ASC_INV_FIELD_IN_CMD_PACKET);
1009: break;
1010: }
1011: }
1012:
1013: static void cmd_set_speed(IDEState *s, uint8_t* buf)
1014: {
1015: ide_atapi_cmd_ok(s);
1016: }
1017:
1018: enum {
1019: /*
1020: * Only commands flagged as ALLOW_UA are allowed to run under a
1021: * unit attention condition. (See MMC-5, section 4.1.6.1)
1022: */
1023: ALLOW_UA = 0x01,
1024:
1025: /*
1026: * Commands flagged with CHECK_READY can only execute if a medium is present.
1027: * Otherwise they report the Not Ready Condition. (See MMC-5, section
1028: * 4.1.8)
1029: */
1030: CHECK_READY = 0x02,
1031: };
1032:
1033: static const struct {
1034: void (*handler)(IDEState *s, uint8_t *buf);
1035: int flags;
1036: } atapi_cmd_table[0x100] = {
1037: [ 0x00 ] = { cmd_test_unit_ready, CHECK_READY },
1038: [ 0x03 ] = { cmd_request_sense, ALLOW_UA },
1039: [ 0x12 ] = { cmd_inquiry, ALLOW_UA },
1.1.1.2 root 1040: [ 0x1b ] = { cmd_start_stop_unit, 0 }, /* [1] */
1.1 root 1041: [ 0x1e ] = { cmd_prevent_allow_medium_removal, 0 },
1042: [ 0x25 ] = { cmd_read_cdvd_capacity, CHECK_READY },
1.1.1.2 root 1043: [ 0x28 ] = { cmd_read, /* (10) */ CHECK_READY },
1.1 root 1044: [ 0x2b ] = { cmd_seek, CHECK_READY },
1045: [ 0x43 ] = { cmd_read_toc_pma_atip, CHECK_READY },
1046: [ 0x46 ] = { cmd_get_configuration, ALLOW_UA },
1047: [ 0x4a ] = { cmd_get_event_status_notification, ALLOW_UA },
1048: [ 0x5a ] = { cmd_mode_sense, /* (10) */ 0 },
1.1.1.2 root 1049: [ 0xa8 ] = { cmd_read, /* (12) */ CHECK_READY },
1050: [ 0xad ] = { cmd_read_dvd_structure, CHECK_READY },
1.1 root 1051: [ 0xbb ] = { cmd_set_speed, 0 },
1052: [ 0xbd ] = { cmd_mechanism_status, 0 },
1.1.1.2 root 1053: [ 0xbe ] = { cmd_read_cd, CHECK_READY },
1054: /* [1] handler detects and reports not ready condition itself */
1.1 root 1055: };
1056:
1057: void ide_atapi_cmd(IDEState *s)
1058: {
1059: uint8_t *buf;
1060:
1061: buf = s->io_buffer;
1062: #ifdef DEBUG_IDE_ATAPI
1063: {
1064: int i;
1065: printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8));
1066: for(i = 0; i < ATAPI_PACKET_SIZE; i++) {
1067: printf(" %02x", buf[i]);
1068: }
1069: printf("\n");
1070: }
1071: #endif
1072: /*
1073: * If there's a UNIT_ATTENTION condition pending, only command flagged with
1074: * ALLOW_UA are allowed to complete. with other commands getting a CHECK
1075: * condition response unless a higher priority status, defined by the drive
1076: * here, is pending.
1077: */
1.1.1.2 root 1078: if (s->sense_key == UNIT_ATTENTION &&
1.1 root 1079: !(atapi_cmd_table[s->io_buffer[0]].flags & ALLOW_UA)) {
1080: ide_atapi_cmd_check_status(s);
1081: return;
1082: }
1083: /*
1084: * When a CD gets changed, we have to report an ejected state and
1085: * then a loaded state to guests so that they detect tray
1086: * open/close and media change events. Guests that do not use
1087: * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close
1088: * states rely on this behavior.
1089: */
1.1.1.2 root 1090: if (!s->tray_open && bdrv_is_inserted(s->bs) && s->cdrom_changed) {
1091: ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1.1 root 1092:
1093: s->cdrom_changed = 0;
1.1.1.2 root 1094: s->sense_key = UNIT_ATTENTION;
1.1 root 1095: s->asc = ASC_MEDIUM_MAY_HAVE_CHANGED;
1096: return;
1097: }
1098:
1099: /* Report a Not Ready condition if appropriate for the command */
1100: if ((atapi_cmd_table[s->io_buffer[0]].flags & CHECK_READY) &&
1101: (!media_present(s) || !bdrv_is_inserted(s->bs)))
1102: {
1.1.1.2 root 1103: ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT);
1.1 root 1104: return;
1105: }
1106:
1107: /* Execute the command */
1108: if (atapi_cmd_table[s->io_buffer[0]].handler) {
1109: atapi_cmd_table[s->io_buffer[0]].handler(s, buf);
1110: return;
1111: }
1112:
1.1.1.2 root 1113: ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_ILLEGAL_OPCODE);
1.1 root 1114: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.