]>
Commit | Line | Data |
---|---|---|
33231e0e KW |
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 | ||
53239262 | 26 | #include "qemu/osdep.h" |
33231e0e | 27 | #include "hw/ide/internal.h" |
0d09e41a | 28 | #include "hw/scsi/scsi.h" |
4be74634 | 29 | #include "sysemu/block-backend.h" |
82a13ff8 | 30 | #include "trace.h" |
33231e0e | 31 | |
26a122d3 EB |
32 | #define ATAPI_SECTOR_BITS (2 + BDRV_SECTOR_BITS) |
33 | #define ATAPI_SECTOR_SIZE (1 << ATAPI_SECTOR_BITS) | |
34 | ||
33231e0e KW |
35 | static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret); |
36 | ||
37 | static void padstr8(uint8_t *buf, int buf_size, const char *src) | |
38 | { | |
39 | int i; | |
40 | for(i = 0; i < buf_size; i++) { | |
41 | if (*src) | |
42 | buf[i] = *src++; | |
43 | else | |
44 | buf[i] = ' '; | |
45 | } | |
46 | } | |
47 | ||
33231e0e KW |
48 | static void lba_to_msf(uint8_t *buf, int lba) |
49 | { | |
50 | lba += 150; | |
51 | buf[0] = (lba / 75) / 60; | |
52 | buf[1] = (lba / 75) % 60; | |
53 | buf[2] = lba % 75; | |
54 | } | |
55 | ||
33231e0e KW |
56 | static inline int media_present(IDEState *s) |
57 | { | |
a1aff5bf | 58 | return !s->tray_open && s->nb_sectors > 0; |
33231e0e KW |
59 | } |
60 | ||
a7acf552 | 61 | /* XXX: DVDs that could fit on a CD will be reported as a CD */ |
33231e0e KW |
62 | static inline int media_is_dvd(IDEState *s) |
63 | { | |
64 | return (media_present(s) && s->nb_sectors > CD_MAX_SECTORS); | |
65 | } | |
66 | ||
67 | static inline int media_is_cd(IDEState *s) | |
68 | { | |
69 | return (media_present(s) && s->nb_sectors <= CD_MAX_SECTORS); | |
70 | } | |
71 | ||
72 | static void cd_data_to_raw(uint8_t *buf, int lba) | |
73 | { | |
74 | /* sync bytes */ | |
75 | buf[0] = 0x00; | |
76 | memset(buf + 1, 0xff, 10); | |
77 | buf[11] = 0x00; | |
78 | buf += 12; | |
79 | /* MSF */ | |
80 | lba_to_msf(buf, lba); | |
81 | buf[3] = 0x01; /* mode 1 data */ | |
82 | buf += 4; | |
83 | /* data */ | |
84 | buf += 2048; | |
85 | /* XXX: ECC not computed */ | |
86 | memset(buf, 0, 288); | |
87 | } | |
88 | ||
5f81724d PL |
89 | static int |
90 | cd_read_sector_sync(IDEState *s) | |
33231e0e KW |
91 | { |
92 | int ret; | |
ece2d05e | 93 | block_acct_start(blk_get_stats(s->blk), &s->acct, |
26a122d3 | 94 | ATAPI_SECTOR_SIZE, BLOCK_ACCT_READ); |
33231e0e | 95 | |
82a13ff8 | 96 | trace_cd_read_sector_sync(s->lba); |
5f81724d PL |
97 | |
98 | switch (s->cd_sector_size) { | |
33231e0e | 99 | case 2048: |
26a122d3 EB |
100 | ret = blk_pread(s->blk, (int64_t)s->lba << ATAPI_SECTOR_BITS, |
101 | s->io_buffer, ATAPI_SECTOR_SIZE); | |
33231e0e KW |
102 | break; |
103 | case 2352: | |
26a122d3 EB |
104 | ret = blk_pread(s->blk, (int64_t)s->lba << ATAPI_SECTOR_BITS, |
105 | s->io_buffer + 16, ATAPI_SECTOR_SIZE); | |
ece2d05e | 106 | if (ret >= 0) { |
5f81724d | 107 | cd_data_to_raw(s->io_buffer, s->lba); |
ece2d05e | 108 | } |
33231e0e KW |
109 | break; |
110 | default: | |
ece2d05e AG |
111 | block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_READ); |
112 | return -EIO; | |
113 | } | |
114 | ||
115 | if (ret < 0) { | |
116 | block_acct_failed(blk_get_stats(s->blk), &s->acct); | |
117 | } else { | |
118 | block_acct_done(blk_get_stats(s->blk), &s->acct); | |
5f81724d PL |
119 | s->lba++; |
120 | s->io_buffer_index = 0; | |
33231e0e | 121 | } |
ece2d05e | 122 | |
33231e0e KW |
123 | return ret; |
124 | } | |
125 | ||
5f81724d PL |
126 | static void cd_read_sector_cb(void *opaque, int ret) |
127 | { | |
128 | IDEState *s = opaque; | |
129 | ||
82a13ff8 | 130 | trace_cd_read_sector_cb(s->lba, ret); |
5f81724d PL |
131 | |
132 | if (ret < 0) { | |
36be0929 | 133 | block_acct_failed(blk_get_stats(s->blk), &s->acct); |
5f81724d PL |
134 | ide_atapi_io_error(s, ret); |
135 | return; | |
136 | } | |
137 | ||
36be0929 AG |
138 | block_acct_done(blk_get_stats(s->blk), &s->acct); |
139 | ||
5f81724d PL |
140 | if (s->cd_sector_size == 2352) { |
141 | cd_data_to_raw(s->io_buffer, s->lba); | |
142 | } | |
143 | ||
144 | s->lba++; | |
145 | s->io_buffer_index = 0; | |
146 | s->status &= ~BUSY_STAT; | |
147 | ||
148 | ide_atapi_cmd_reply_end(s); | |
149 | } | |
150 | ||
151 | static int cd_read_sector(IDEState *s) | |
152 | { | |
e5863d49 VSO |
153 | void *buf; |
154 | ||
5f81724d | 155 | if (s->cd_sector_size != 2048 && s->cd_sector_size != 2352) { |
36be0929 | 156 | block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_READ); |
5f81724d PL |
157 | return -EINVAL; |
158 | } | |
159 | ||
e5863d49 VSO |
160 | buf = (s->cd_sector_size == 2352) ? s->io_buffer + 16 : s->io_buffer; |
161 | qemu_iovec_init_buf(&s->qiov, buf, ATAPI_SECTOR_SIZE); | |
5f81724d | 162 | |
82a13ff8 | 163 | trace_cd_read_sector(s->lba); |
5f81724d PL |
164 | |
165 | block_acct_start(blk_get_stats(s->blk), &s->acct, | |
26a122d3 | 166 | ATAPI_SECTOR_SIZE, BLOCK_ACCT_READ); |
5f81724d | 167 | |
02506b20 PL |
168 | ide_buffered_readv(s, (int64_t)s->lba << 2, &s->qiov, 4, |
169 | cd_read_sector_cb, s); | |
5f81724d PL |
170 | |
171 | s->status |= BUSY_STAT; | |
172 | return 0; | |
173 | } | |
174 | ||
33231e0e KW |
175 | void ide_atapi_cmd_ok(IDEState *s) |
176 | { | |
177 | s->error = 0; | |
178 | s->status = READY_STAT | SEEK_STAT; | |
179 | s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD; | |
d735b620 | 180 | ide_transfer_stop(s); |
33231e0e KW |
181 | ide_set_irq(s->bus); |
182 | } | |
183 | ||
184 | void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc) | |
185 | { | |
82a13ff8 | 186 | trace_ide_atapi_cmd_error(s, sense_key, asc); |
33231e0e KW |
187 | s->error = sense_key << 4; |
188 | s->status = READY_STAT | ERR_STAT; | |
189 | s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD; | |
190 | s->sense_key = sense_key; | |
191 | s->asc = asc; | |
d735b620 | 192 | ide_transfer_stop(s); |
33231e0e KW |
193 | ide_set_irq(s->bus); |
194 | } | |
195 | ||
196 | void ide_atapi_io_error(IDEState *s, int ret) | |
197 | { | |
198 | /* XXX: handle more errors */ | |
199 | if (ret == -ENOMEDIUM) { | |
67cc61e4 | 200 | ide_atapi_cmd_error(s, NOT_READY, |
33231e0e KW |
201 | ASC_MEDIUM_NOT_PRESENT); |
202 | } else { | |
67cc61e4 | 203 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
33231e0e KW |
204 | ASC_LOGICAL_BLOCK_OOR); |
205 | } | |
206 | } | |
207 | ||
af0e00db JS |
208 | static uint16_t atapi_byte_count_limit(IDEState *s) |
209 | { | |
210 | uint16_t bcl; | |
211 | ||
212 | bcl = s->lcyl | (s->hcyl << 8); | |
213 | if (bcl == 0xffff) { | |
214 | return 0xfffe; | |
215 | } | |
216 | return bcl; | |
217 | } | |
218 | ||
33231e0e KW |
219 | /* The whole ATAPI transfer logic is handled in this function */ |
220 | void ide_atapi_cmd_reply_end(IDEState *s) | |
221 | { | |
222 | int byte_count_limit, size, ret; | |
c173723f PB |
223 | while (s->packet_transfer_size > 0) { |
224 | trace_ide_atapi_cmd_reply_end(s, s->packet_transfer_size, | |
225 | s->elementary_transfer_size, | |
226 | s->io_buffer_index); | |
227 | ||
33231e0e KW |
228 | /* see if a new sector must be read */ |
229 | if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) { | |
5f81724d PL |
230 | if (!s->elementary_transfer_size) { |
231 | ret = cd_read_sector(s); | |
232 | if (ret < 0) { | |
233 | ide_atapi_io_error(s, ret); | |
234 | } | |
33231e0e | 235 | return; |
5f81724d PL |
236 | } else { |
237 | /* rebuffering within an elementary transfer is | |
238 | * only possible with a sync request because we | |
239 | * end up with a race condition otherwise */ | |
240 | ret = cd_read_sector_sync(s); | |
241 | if (ret < 0) { | |
242 | ide_atapi_io_error(s, ret); | |
243 | return; | |
244 | } | |
33231e0e | 245 | } |
33231e0e KW |
246 | } |
247 | if (s->elementary_transfer_size > 0) { | |
248 | /* there are some data left to transmit in this elementary | |
249 | transfer */ | |
250 | size = s->cd_sector_size - s->io_buffer_index; | |
251 | if (size > s->elementary_transfer_size) | |
252 | size = s->elementary_transfer_size; | |
33231e0e KW |
253 | } else { |
254 | /* a new transfer is needed */ | |
255 | s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO; | |
d02cea64 | 256 | ide_set_irq(s->bus); |
af0e00db | 257 | byte_count_limit = atapi_byte_count_limit(s); |
82a13ff8 | 258 | trace_ide_atapi_cmd_reply_end_bcl(s, byte_count_limit); |
33231e0e KW |
259 | size = s->packet_transfer_size; |
260 | if (size > byte_count_limit) { | |
261 | /* byte count limit must be even if this case */ | |
262 | if (byte_count_limit & 1) | |
263 | byte_count_limit--; | |
264 | size = byte_count_limit; | |
265 | } | |
266 | s->lcyl = size; | |
267 | s->hcyl = size >> 8; | |
268 | s->elementary_transfer_size = size; | |
269 | /* we cannot transmit more than one sector at a time */ | |
270 | if (s->lba != -1) { | |
271 | if (size > (s->cd_sector_size - s->io_buffer_index)) | |
272 | size = (s->cd_sector_size - s->io_buffer_index); | |
273 | } | |
d02cea64 | 274 | trace_ide_atapi_cmd_reply_end_new(s, s->status); |
c173723f PB |
275 | } |
276 | s->packet_transfer_size -= size; | |
277 | s->elementary_transfer_size -= size; | |
278 | s->io_buffer_index += size; | |
279 | ||
280 | /* Some adapters process PIO data right away. In that case, we need | |
281 | * to avoid mutual recursion between ide_transfer_start | |
282 | * and ide_atapi_cmd_reply_end. | |
283 | */ | |
284 | if (!ide_transfer_start_norecurse(s, | |
285 | s->io_buffer + s->io_buffer_index - size, | |
286 | size, ide_atapi_cmd_reply_end)) { | |
287 | return; | |
33231e0e KW |
288 | } |
289 | } | |
c173723f PB |
290 | |
291 | /* end of transfer */ | |
292 | trace_ide_atapi_cmd_reply_end_eot(s, s->status); | |
293 | ide_atapi_cmd_ok(s); | |
294 | ide_set_irq(s->bus); | |
33231e0e KW |
295 | } |
296 | ||
297 | /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */ | |
298 | static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size) | |
299 | { | |
300 | if (size > max_size) | |
301 | size = max_size; | |
302 | s->lba = -1; /* no sector read */ | |
303 | s->packet_transfer_size = size; | |
304 | s->io_buffer_size = size; /* dma: send the reply data as one chunk */ | |
305 | s->elementary_transfer_size = 0; | |
33231e0e KW |
306 | |
307 | if (s->atapi_dma) { | |
4be74634 | 308 | block_acct_start(blk_get_stats(s->blk), &s->acct, size, |
5366d0c8 | 309 | BLOCK_ACCT_READ); |
33231e0e | 310 | s->status = READY_STAT | SEEK_STAT | DRQ_STAT; |
4855b576 | 311 | ide_start_dma(s, ide_atapi_cmd_read_dma_cb); |
33231e0e KW |
312 | } else { |
313 | s->status = READY_STAT | SEEK_STAT; | |
c71c06d4 | 314 | s->io_buffer_index = 0; |
33231e0e KW |
315 | ide_atapi_cmd_reply_end(s); |
316 | } | |
317 | } | |
318 | ||
319 | /* start a CD-CDROM read command */ | |
320 | static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors, | |
321 | int sector_size) | |
322 | { | |
323 | s->lba = lba; | |
324 | s->packet_transfer_size = nb_sectors * sector_size; | |
325 | s->elementary_transfer_size = 0; | |
326 | s->io_buffer_index = sector_size; | |
327 | s->cd_sector_size = sector_size; | |
328 | ||
33231e0e KW |
329 | ide_atapi_cmd_reply_end(s); |
330 | } | |
331 | ||
332 | static void ide_atapi_cmd_check_status(IDEState *s) | |
333 | { | |
82a13ff8 | 334 | trace_ide_atapi_cmd_check_status(s); |
67cc61e4 | 335 | s->error = MC_ERR | (UNIT_ATTENTION << 4); |
33231e0e KW |
336 | s->status = ERR_STAT; |
337 | s->nsector = 0; | |
338 | ide_set_irq(s->bus); | |
339 | } | |
340 | /* ATAPI DMA support */ | |
341 | ||
33231e0e KW |
342 | static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret) |
343 | { | |
344 | IDEState *s = opaque; | |
345 | int data_offset, n; | |
346 | ||
347 | if (ret < 0) { | |
502356ee PB |
348 | if (ide_handle_rw_error(s, -ret, ide_dma_cmd_to_retry(s->dma_cmd))) { |
349 | if (s->bus->error_status) { | |
7f951b2d | 350 | s->bus->dma->aiocb = NULL; |
502356ee PB |
351 | return; |
352 | } | |
353 | goto eot; | |
354 | } | |
33231e0e KW |
355 | } |
356 | ||
357 | if (s->io_buffer_size > 0) { | |
358 | /* | |
359 | * For a cdrom read sector command (s->lba != -1), | |
360 | * adjust the lba for the next s->io_buffer_size chunk | |
361 | * and dma the current chunk. | |
362 | * For a command != read (s->lba == -1), just transfer | |
363 | * the reply data. | |
364 | */ | |
365 | if (s->lba != -1) { | |
366 | if (s->cd_sector_size == 2352) { | |
367 | n = 1; | |
368 | cd_data_to_raw(s->io_buffer, s->lba); | |
369 | } else { | |
370 | n = s->io_buffer_size >> 11; | |
371 | } | |
372 | s->lba += n; | |
373 | } | |
374 | s->packet_transfer_size -= s->io_buffer_size; | |
375 | if (s->bus->dma->ops->rw_buf(s->bus->dma, 1) == 0) | |
376 | goto eot; | |
377 | } | |
378 | ||
379 | if (s->packet_transfer_size <= 0) { | |
380 | s->status = READY_STAT | SEEK_STAT; | |
381 | s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD; | |
382 | ide_set_irq(s->bus); | |
a597e79c | 383 | goto eot; |
33231e0e KW |
384 | } |
385 | ||
386 | s->io_buffer_index = 0; | |
387 | if (s->cd_sector_size == 2352) { | |
388 | n = 1; | |
389 | s->io_buffer_size = s->cd_sector_size; | |
390 | data_offset = 16; | |
391 | } else { | |
392 | n = s->packet_transfer_size >> 11; | |
393 | if (n > (IDE_DMA_BUF_SECTORS / 4)) | |
394 | n = (IDE_DMA_BUF_SECTORS / 4); | |
395 | s->io_buffer_size = n * 2048; | |
396 | data_offset = 0; | |
397 | } | |
0e168d35 | 398 | trace_ide_atapi_cmd_read_dma_cb_aio(s, s->lba, n); |
9942586b VSO |
399 | qemu_iovec_init_buf(&s->bus->dma->qiov, s->io_buffer + data_offset, |
400 | n * ATAPI_SECTOR_SIZE); | |
a597e79c | 401 | |
02506b20 PL |
402 | s->bus->dma->aiocb = ide_buffered_readv(s, (int64_t)s->lba << 2, |
403 | &s->bus->dma->qiov, n * 4, | |
404 | ide_atapi_cmd_read_dma_cb, s); | |
a597e79c | 405 | return; |
ad54ae80 | 406 | |
a597e79c | 407 | eot: |
ece2d05e AG |
408 | if (ret < 0) { |
409 | block_acct_failed(blk_get_stats(s->blk), &s->acct); | |
410 | } else { | |
73a27d9a | 411 | block_acct_done(blk_get_stats(s->blk), &s->acct); |
ece2d05e | 412 | } |
0e7ce54c | 413 | ide_set_inactive(s, false); |
33231e0e KW |
414 | } |
415 | ||
416 | /* start a CD-CDROM read command with DMA */ | |
417 | /* XXX: test if DMA is available */ | |
418 | static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors, | |
419 | int sector_size) | |
420 | { | |
421 | s->lba = lba; | |
422 | s->packet_transfer_size = nb_sectors * sector_size; | |
33231e0e KW |
423 | s->io_buffer_size = 0; |
424 | s->cd_sector_size = sector_size; | |
425 | ||
4be74634 | 426 | block_acct_start(blk_get_stats(s->blk), &s->acct, s->packet_transfer_size, |
5366d0c8 | 427 | BLOCK_ACCT_READ); |
a597e79c | 428 | |
33231e0e KW |
429 | /* XXX: check if BUSY_STAT should be set */ |
430 | s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT; | |
4855b576 | 431 | ide_start_dma(s, ide_atapi_cmd_read_dma_cb); |
33231e0e KW |
432 | } |
433 | ||
434 | static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors, | |
435 | int sector_size) | |
436 | { | |
82a13ff8 JS |
437 | trace_ide_atapi_cmd_read(s, s->atapi_dma ? "dma" : "pio", |
438 | lba, nb_sectors); | |
33231e0e KW |
439 | if (s->atapi_dma) { |
440 | ide_atapi_cmd_read_dma(s, lba, nb_sectors, sector_size); | |
441 | } else { | |
442 | ide_atapi_cmd_read_pio(s, lba, nb_sectors, sector_size); | |
443 | } | |
444 | } | |
445 | ||
a71754e5 DDAG |
446 | void ide_atapi_dma_restart(IDEState *s) |
447 | { | |
448 | /* | |
9a41826f PB |
449 | * At this point we can just re-evaluate the packet command and start over. |
450 | * The presence of ->dma_cb callback in the pre_save ensures that the packet | |
451 | * command has been completely sent and we can safely restart command. | |
a71754e5 | 452 | */ |
9a41826f PB |
453 | s->unit = s->bus->retry_unit; |
454 | s->bus->dma->ops->restart_dma(s->bus->dma); | |
455 | ide_atapi_cmd(s); | |
a71754e5 DDAG |
456 | } |
457 | ||
33231e0e KW |
458 | static inline uint8_t ide_atapi_set_profile(uint8_t *buf, uint8_t *index, |
459 | uint16_t profile) | |
460 | { | |
461 | uint8_t *buf_profile = buf + 12; /* start of profiles */ | |
462 | ||
463 | buf_profile += ((*index) * 4); /* start of indexed profile */ | |
614ab7d1 | 464 | stw_be_p(buf_profile, profile); |
33231e0e KW |
465 | buf_profile[2] = ((buf_profile[0] == buf[6]) && (buf_profile[1] == buf[7])); |
466 | ||
467 | /* each profile adds 4 bytes to the response */ | |
468 | (*index)++; | |
469 | buf[11] += 4; /* Additional Length */ | |
470 | ||
471 | return 4; | |
472 | } | |
473 | ||
474 | static int ide_dvd_read_structure(IDEState *s, int format, | |
475 | const uint8_t *packet, uint8_t *buf) | |
476 | { | |
477 | switch (format) { | |
478 | case 0x0: /* Physical format information */ | |
479 | { | |
480 | int layer = packet[6]; | |
481 | uint64_t total_sectors; | |
482 | ||
483 | if (layer != 0) | |
484 | return -ASC_INV_FIELD_IN_CMD_PACKET; | |
485 | ||
e119bcac KW |
486 | total_sectors = s->nb_sectors >> 2; |
487 | if (total_sectors == 0) { | |
33231e0e | 488 | return -ASC_MEDIUM_NOT_PRESENT; |
e119bcac | 489 | } |
33231e0e KW |
490 | |
491 | buf[4] = 1; /* DVD-ROM, part version 1 */ | |
492 | buf[5] = 0xf; /* 120mm disc, minimum rate unspecified */ | |
493 | buf[6] = 1; /* one layer, read-only (per MMC-2 spec) */ | |
494 | buf[7] = 0; /* default densities */ | |
495 | ||
496 | /* FIXME: 0x30000 per spec? */ | |
614ab7d1 PMD |
497 | stl_be_p(buf + 8, 0); /* start sector */ |
498 | stl_be_p(buf + 12, total_sectors - 1); /* end sector */ | |
499 | stl_be_p(buf + 16, total_sectors - 1); /* l0 end sector */ | |
33231e0e KW |
500 | |
501 | /* Size of buffer, not including 2 byte size field */ | |
d8ee2591 | 502 | stw_be_p(buf, 2048 + 2); |
33231e0e KW |
503 | |
504 | /* 2k data + 4 byte header */ | |
505 | return (2048 + 4); | |
506 | } | |
507 | ||
508 | case 0x01: /* DVD copyright information */ | |
509 | buf[4] = 0; /* no copyright data */ | |
510 | buf[5] = 0; /* no region restrictions */ | |
511 | ||
512 | /* Size of buffer, not including 2 byte size field */ | |
d8ee2591 | 513 | stw_be_p(buf, 4 + 2); |
33231e0e KW |
514 | |
515 | /* 4 byte header + 4 byte data */ | |
516 | return (4 + 4); | |
517 | ||
518 | case 0x03: /* BCA information - invalid field for no BCA info */ | |
519 | return -ASC_INV_FIELD_IN_CMD_PACKET; | |
520 | ||
521 | case 0x04: /* DVD disc manufacturing information */ | |
522 | /* Size of buffer, not including 2 byte size field */ | |
d8ee2591 | 523 | stw_be_p(buf, 2048 + 2); |
33231e0e KW |
524 | |
525 | /* 2k data + 4 byte header */ | |
526 | return (2048 + 4); | |
527 | ||
528 | case 0xff: | |
529 | /* | |
530 | * This lists all the command capabilities above. Add new ones | |
531 | * in order and update the length and buffer return values. | |
532 | */ | |
533 | ||
534 | buf[4] = 0x00; /* Physical format */ | |
535 | buf[5] = 0x40; /* Not writable, is readable */ | |
d8ee2591 | 536 | stw_be_p(buf + 6, 2048 + 4); |
33231e0e KW |
537 | |
538 | buf[8] = 0x01; /* Copyright info */ | |
539 | buf[9] = 0x40; /* Not writable, is readable */ | |
d8ee2591 | 540 | stw_be_p(buf + 10, 4 + 4); |
33231e0e KW |
541 | |
542 | buf[12] = 0x03; /* BCA info */ | |
543 | buf[13] = 0x40; /* Not writable, is readable */ | |
d8ee2591 | 544 | stw_be_p(buf + 14, 188 + 4); |
33231e0e KW |
545 | |
546 | buf[16] = 0x04; /* Manufacturing info */ | |
547 | buf[17] = 0x40; /* Not writable, is readable */ | |
d8ee2591 | 548 | stw_be_p(buf + 18, 2048 + 4); |
33231e0e KW |
549 | |
550 | /* Size of buffer, not including 2 byte size field */ | |
d8ee2591 | 551 | stw_be_p(buf, 16 + 2); |
33231e0e KW |
552 | |
553 | /* data written + 4 byte header */ | |
554 | return (16 + 4); | |
555 | ||
556 | default: /* TODO: formats beyond DVD-ROM requires */ | |
557 | return -ASC_INV_FIELD_IN_CMD_PACKET; | |
558 | } | |
559 | } | |
560 | ||
561 | static unsigned int event_status_media(IDEState *s, | |
562 | uint8_t *buf) | |
563 | { | |
33231e0e KW |
564 | uint8_t event_code, media_status; |
565 | ||
566 | media_status = 0; | |
dd063333 | 567 | if (s->tray_open) { |
33231e0e | 568 | media_status = MS_TRAY_OPEN; |
4be74634 | 569 | } else if (blk_is_inserted(s->blk)) { |
33231e0e KW |
570 | media_status = MS_MEDIA_PRESENT; |
571 | } | |
572 | ||
573 | /* Event notification descriptor */ | |
574 | event_code = MEC_NO_CHANGE; | |
2df0a3a3 PB |
575 | if (media_status != MS_TRAY_OPEN) { |
576 | if (s->events.new_media) { | |
577 | event_code = MEC_NEW_MEDIA; | |
578 | s->events.new_media = false; | |
579 | } else if (s->events.eject_request) { | |
580 | event_code = MEC_EJECT_REQUESTED; | |
581 | s->events.eject_request = false; | |
582 | } | |
33231e0e KW |
583 | } |
584 | ||
585 | buf[4] = event_code; | |
586 | buf[5] = media_status; | |
587 | ||
588 | /* These fields are reserved, just clear them. */ | |
589 | buf[6] = 0; | |
590 | buf[7] = 0; | |
591 | ||
592 | return 8; /* We wrote to 4 extra bytes from the header */ | |
593 | } | |
594 | ||
e7bd708e JS |
595 | /* |
596 | * Before transferring data or otherwise signalling acceptance of a command | |
597 | * marked CONDDATA, we must check the validity of the byte_count_limit. | |
598 | */ | |
599 | static bool validate_bcl(IDEState *s) | |
600 | { | |
601 | /* TODO: Check IDENTIFY data word 125 for defacult BCL (currently 0) */ | |
602 | if (s->atapi_dma || atapi_byte_count_limit(s)) { | |
603 | return true; | |
604 | } | |
605 | ||
606 | /* TODO: Move abort back into core.c and introduce proper error flow between | |
607 | * ATAPI layer and IDE core layer */ | |
608 | ide_abort_command(s); | |
609 | return false; | |
610 | } | |
611 | ||
e1a064f9 KW |
612 | static void cmd_get_event_status_notification(IDEState *s, |
613 | uint8_t *buf) | |
33231e0e | 614 | { |
e1a064f9 KW |
615 | const uint8_t *packet = buf; |
616 | ||
33231e0e KW |
617 | struct { |
618 | uint8_t opcode; | |
619 | uint8_t polled; /* lsb bit is polled; others are reserved */ | |
620 | uint8_t reserved2[2]; | |
621 | uint8_t class; | |
622 | uint8_t reserved3[2]; | |
623 | uint16_t len; | |
624 | uint8_t control; | |
541dc0d4 | 625 | } QEMU_PACKED *gesn_cdb; |
33231e0e KW |
626 | |
627 | struct { | |
628 | uint16_t len; | |
629 | uint8_t notification_class; | |
630 | uint8_t supported_events; | |
541dc0d4 | 631 | } QEMU_PACKED *gesn_event_header; |
33231e0e KW |
632 | unsigned int max_len, used_len; |
633 | ||
634 | gesn_cdb = (void *)packet; | |
635 | gesn_event_header = (void *)buf; | |
636 | ||
637 | max_len = be16_to_cpu(gesn_cdb->len); | |
638 | ||
639 | /* It is fine by the MMC spec to not support async mode operations */ | |
640 | if (!(gesn_cdb->polled & 0x01)) { /* asynchronous mode */ | |
641 | /* Only polling is supported, asynchronous mode is not. */ | |
67cc61e4 | 642 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
33231e0e KW |
643 | ASC_INV_FIELD_IN_CMD_PACKET); |
644 | return; | |
645 | } | |
646 | ||
647 | /* polling mode operation */ | |
648 | ||
649 | /* | |
650 | * These are the supported events. | |
651 | * | |
652 | * We currently only support requests of the 'media' type. | |
f0f992e6 PB |
653 | * Notification class requests and supported event classes are bitmasks, |
654 | * but they are build from the same values as the "notification class" | |
655 | * field. | |
33231e0e | 656 | */ |
f0f992e6 | 657 | gesn_event_header->supported_events = 1 << GESN_MEDIA; |
33231e0e KW |
658 | |
659 | /* | |
660 | * We use |= below to set the class field; other bits in this byte | |
661 | * are reserved now but this is useful to do if we have to use the | |
662 | * reserved fields later. | |
663 | */ | |
664 | gesn_event_header->notification_class = 0; | |
665 | ||
666 | /* | |
667 | * Responses to requests are to be based on request priority. The | |
668 | * notification_class_request_type enum above specifies the | |
669 | * priority: upper elements are higher prio than lower ones. | |
670 | */ | |
f0f992e6 PB |
671 | if (gesn_cdb->class & (1 << GESN_MEDIA)) { |
672 | gesn_event_header->notification_class |= GESN_MEDIA; | |
33231e0e KW |
673 | used_len = event_status_media(s, buf); |
674 | } else { | |
675 | gesn_event_header->notification_class = 0x80; /* No event available */ | |
676 | used_len = sizeof(*gesn_event_header); | |
677 | } | |
678 | gesn_event_header->len = cpu_to_be16(used_len | |
679 | - sizeof(*gesn_event_header)); | |
680 | ide_atapi_cmd_reply(s, used_len, max_len); | |
681 | } | |
682 | ||
a60cf7e7 KW |
683 | static void cmd_request_sense(IDEState *s, uint8_t *buf) |
684 | { | |
685 | int max_len = buf[4]; | |
686 | ||
687 | memset(buf, 0, 18); | |
688 | buf[0] = 0x70 | (1 << 7); | |
689 | buf[2] = s->sense_key; | |
690 | buf[7] = 10; | |
691 | buf[12] = s->asc; | |
692 | ||
67cc61e4 PB |
693 | if (s->sense_key == UNIT_ATTENTION) { |
694 | s->sense_key = NO_SENSE; | |
a60cf7e7 KW |
695 | } |
696 | ||
697 | ide_atapi_cmd_reply(s, 18, max_len); | |
698 | } | |
699 | ||
700 | static void cmd_inquiry(IDEState *s, uint8_t *buf) | |
701 | { | |
9a502563 | 702 | uint8_t page_code = buf[2]; |
a60cf7e7 KW |
703 | int max_len = buf[4]; |
704 | ||
9a502563 JS |
705 | unsigned idx = 0; |
706 | unsigned size_idx; | |
707 | unsigned preamble_len; | |
708 | ||
709 | /* If the EVPD (Enable Vital Product Data) bit is set in byte 1, | |
710 | * we are being asked for a specific page of info indicated by byte 2. */ | |
711 | if (buf[1] & 0x01) { | |
712 | preamble_len = 4; | |
713 | size_idx = 3; | |
714 | ||
715 | buf[idx++] = 0x05; /* CD-ROM */ | |
716 | buf[idx++] = page_code; /* Page Code */ | |
717 | buf[idx++] = 0x00; /* reserved */ | |
718 | idx++; /* length (set later) */ | |
719 | ||
720 | switch (page_code) { | |
721 | case 0x00: | |
722 | /* Supported Pages: List of supported VPD responses. */ | |
723 | buf[idx++] = 0x00; /* 0x00: Supported Pages, and: */ | |
724 | buf[idx++] = 0x83; /* 0x83: Device Identification. */ | |
725 | break; | |
726 | ||
727 | case 0x83: | |
728 | /* Device Identification. Each entry is optional, but the entries | |
729 | * included here are modeled after libata's VPD responses. | |
730 | * If the response is given, at least one entry must be present. */ | |
731 | ||
732 | /* Entry 1: Serial */ | |
733 | if (idx + 24 > max_len) { | |
734 | /* Not enough room for even the first entry: */ | |
735 | /* 4 byte header + 20 byte string */ | |
736 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, | |
737 | ASC_DATA_PHASE_ERROR); | |
738 | return; | |
739 | } | |
740 | buf[idx++] = 0x02; /* Ascii */ | |
741 | buf[idx++] = 0x00; /* Vendor Specific */ | |
742 | buf[idx++] = 0x00; | |
743 | buf[idx++] = 20; /* Remaining length */ | |
744 | padstr8(buf + idx, 20, s->drive_serial_str); | |
745 | idx += 20; | |
746 | ||
747 | /* Entry 2: Drive Model and Serial */ | |
748 | if (idx + 72 > max_len) { | |
749 | /* 4 (header) + 8 (vendor) + 60 (model & serial) */ | |
750 | goto out; | |
751 | } | |
752 | buf[idx++] = 0x02; /* Ascii */ | |
753 | buf[idx++] = 0x01; /* T10 Vendor */ | |
754 | buf[idx++] = 0x00; | |
755 | buf[idx++] = 68; | |
756 | padstr8(buf + idx, 8, "ATA"); /* Generic T10 vendor */ | |
757 | idx += 8; | |
758 | padstr8(buf + idx, 40, s->drive_model_str); | |
759 | idx += 40; | |
760 | padstr8(buf + idx, 20, s->drive_serial_str); | |
761 | idx += 20; | |
762 | ||
763 | /* Entry 3: WWN */ | |
764 | if (s->wwn && (idx + 12 <= max_len)) { | |
765 | /* 4 byte header + 8 byte wwn */ | |
766 | buf[idx++] = 0x01; /* Binary */ | |
767 | buf[idx++] = 0x03; /* NAA */ | |
768 | buf[idx++] = 0x00; | |
769 | buf[idx++] = 0x08; | |
770 | stq_be_p(&buf[idx], s->wwn); | |
771 | idx += 8; | |
772 | } | |
773 | break; | |
774 | ||
775 | default: | |
776 | /* SPC-3, revision 23 sec. 6.4 */ | |
777 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, | |
778 | ASC_INV_FIELD_IN_CMD_PACKET); | |
779 | return; | |
780 | } | |
781 | } else { | |
782 | preamble_len = 5; | |
783 | size_idx = 4; | |
784 | ||
785 | buf[0] = 0x05; /* CD-ROM */ | |
786 | buf[1] = 0x80; /* removable */ | |
787 | buf[2] = 0x00; /* ISO */ | |
788 | buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */ | |
789 | /* buf[size_idx] set below. */ | |
790 | buf[5] = 0; /* reserved */ | |
791 | buf[6] = 0; /* reserved */ | |
792 | buf[7] = 0; /* reserved */ | |
793 | padstr8(buf + 8, 8, "QEMU"); | |
794 | padstr8(buf + 16, 16, "QEMU DVD-ROM"); | |
795 | padstr8(buf + 32, 4, s->version); | |
796 | idx = 36; | |
797 | } | |
798 | ||
799 | out: | |
800 | buf[size_idx] = idx - preamble_len; | |
801 | ide_atapi_cmd_reply(s, idx, max_len); | |
a60cf7e7 KW |
802 | } |
803 | ||
804 | static void cmd_get_configuration(IDEState *s, uint8_t *buf) | |
805 | { | |
806 | uint32_t len; | |
807 | uint8_t index = 0; | |
808 | int max_len; | |
809 | ||
810 | /* only feature 0 is supported */ | |
811 | if (buf[2] != 0 || buf[3] != 0) { | |
67cc61e4 | 812 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
a60cf7e7 KW |
813 | ASC_INV_FIELD_IN_CMD_PACKET); |
814 | return; | |
815 | } | |
816 | ||
817 | /* XXX: could result in alignment problems in some architectures */ | |
614ab7d1 | 818 | max_len = lduw_be_p(buf + 7); |
a60cf7e7 KW |
819 | |
820 | /* | |
821 | * XXX: avoid overflow for io_buffer if max_len is bigger than | |
822 | * the size of that buffer (dimensioned to max number of | |
823 | * sectors to transfer at once) | |
824 | * | |
825 | * Only a problem if the feature/profiles grow. | |
826 | */ | |
a71f2d22 | 827 | if (max_len > BDRV_SECTOR_SIZE) { |
a60cf7e7 | 828 | /* XXX: assume 1 sector */ |
a71f2d22 | 829 | max_len = BDRV_SECTOR_SIZE; |
a60cf7e7 KW |
830 | } |
831 | ||
832 | memset(buf, 0, max_len); | |
833 | /* | |
834 | * the number of sectors from the media tells us which profile | |
835 | * to use as current. 0 means there is no media | |
836 | */ | |
837 | if (media_is_dvd(s)) { | |
614ab7d1 | 838 | stw_be_p(buf + 6, MMC_PROFILE_DVD_ROM); |
a60cf7e7 | 839 | } else if (media_is_cd(s)) { |
614ab7d1 | 840 | stw_be_p(buf + 6, MMC_PROFILE_CD_ROM); |
a60cf7e7 KW |
841 | } |
842 | ||
843 | buf[10] = 0x02 | 0x01; /* persistent and current */ | |
844 | len = 12; /* headers: 8 + 4 */ | |
845 | len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_DVD_ROM); | |
846 | len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_CD_ROM); | |
614ab7d1 | 847 | stl_be_p(buf, len - 4); /* data length */ |
a60cf7e7 KW |
848 | |
849 | ide_atapi_cmd_reply(s, len, max_len); | |
850 | } | |
851 | ||
852 | static void cmd_mode_sense(IDEState *s, uint8_t *buf) | |
853 | { | |
854 | int action, code; | |
855 | int max_len; | |
856 | ||
614ab7d1 | 857 | max_len = lduw_be_p(buf + 7); |
a60cf7e7 KW |
858 | action = buf[2] >> 6; |
859 | code = buf[2] & 0x3f; | |
860 | ||
861 | switch(action) { | |
862 | case 0: /* current values */ | |
863 | switch(code) { | |
67cc61e4 | 864 | case MODE_PAGE_R_W_ERROR: /* error recovery */ |
614ab7d1 | 865 | stw_be_p(&buf[0], 16 - 2); |
a60cf7e7 KW |
866 | buf[2] = 0x70; |
867 | buf[3] = 0; | |
868 | buf[4] = 0; | |
869 | buf[5] = 0; | |
870 | buf[6] = 0; | |
871 | buf[7] = 0; | |
872 | ||
af0e1ea2 PB |
873 | buf[8] = MODE_PAGE_R_W_ERROR; |
874 | buf[9] = 16 - 10; | |
a60cf7e7 KW |
875 | buf[10] = 0x00; |
876 | buf[11] = 0x05; | |
877 | buf[12] = 0x00; | |
878 | buf[13] = 0x00; | |
879 | buf[14] = 0x00; | |
880 | buf[15] = 0x00; | |
881 | ide_atapi_cmd_reply(s, 16, max_len); | |
882 | break; | |
67cc61e4 | 883 | case MODE_PAGE_AUDIO_CTL: |
614ab7d1 | 884 | stw_be_p(&buf[0], 24 - 2); |
a60cf7e7 KW |
885 | buf[2] = 0x70; |
886 | buf[3] = 0; | |
887 | buf[4] = 0; | |
888 | buf[5] = 0; | |
889 | buf[6] = 0; | |
890 | buf[7] = 0; | |
891 | ||
af0e1ea2 PB |
892 | buf[8] = MODE_PAGE_AUDIO_CTL; |
893 | buf[9] = 24 - 10; | |
a60cf7e7 KW |
894 | /* Fill with CDROM audio volume */ |
895 | buf[17] = 0; | |
896 | buf[19] = 0; | |
897 | buf[21] = 0; | |
898 | buf[23] = 0; | |
899 | ||
900 | ide_atapi_cmd_reply(s, 24, max_len); | |
901 | break; | |
67cc61e4 | 902 | case MODE_PAGE_CAPABILITIES: |
614ab7d1 | 903 | stw_be_p(&buf[0], 30 - 2); |
a60cf7e7 KW |
904 | buf[2] = 0x70; |
905 | buf[3] = 0; | |
906 | buf[4] = 0; | |
907 | buf[5] = 0; | |
908 | buf[6] = 0; | |
909 | buf[7] = 0; | |
910 | ||
af0e1ea2 | 911 | buf[8] = MODE_PAGE_CAPABILITIES; |
2c20ae11 | 912 | buf[9] = 30 - 10; |
a07c7dcd | 913 | buf[10] = 0x3b; /* read CDR/CDRW/DVDROM/DVDR/DVDRAM */ |
a60cf7e7 KW |
914 | buf[11] = 0x00; |
915 | ||
916 | /* Claim PLAY_AUDIO capability (0x01) since some Linux | |
917 | code checks for this to automount media. */ | |
918 | buf[12] = 0x71; | |
919 | buf[13] = 3 << 5; | |
920 | buf[14] = (1 << 0) | (1 << 3) | (1 << 5); | |
a0a7573b | 921 | if (s->tray_locked) { |
a07c7dcd | 922 | buf[14] |= 1 << 1; |
a0a7573b | 923 | } |
a07c7dcd | 924 | buf[15] = 0x00; /* No volume & mute control, no changer */ |
614ab7d1 | 925 | stw_be_p(&buf[16], 704); /* 4x read speed */ |
a07c7dcd | 926 | buf[18] = 0; /* Two volume levels */ |
a60cf7e7 | 927 | buf[19] = 2; |
614ab7d1 PMD |
928 | stw_be_p(&buf[20], 512); /* 512k buffer */ |
929 | stw_be_p(&buf[22], 704); /* 4x read speed current */ | |
a60cf7e7 KW |
930 | buf[24] = 0; |
931 | buf[25] = 0; | |
932 | buf[26] = 0; | |
933 | buf[27] = 0; | |
2c20ae11 PB |
934 | buf[28] = 0; |
935 | buf[29] = 0; | |
936 | ide_atapi_cmd_reply(s, 30, max_len); | |
a60cf7e7 KW |
937 | break; |
938 | default: | |
939 | goto error_cmd; | |
940 | } | |
941 | break; | |
942 | case 1: /* changeable values */ | |
943 | goto error_cmd; | |
944 | case 2: /* default values */ | |
945 | goto error_cmd; | |
946 | default: | |
947 | case 3: /* saved values */ | |
67cc61e4 | 948 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
a60cf7e7 KW |
949 | ASC_SAVING_PARAMETERS_NOT_SUPPORTED); |
950 | break; | |
951 | } | |
952 | return; | |
953 | ||
954 | error_cmd: | |
67cc61e4 | 955 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_INV_FIELD_IN_CMD_PACKET); |
a60cf7e7 KW |
956 | } |
957 | ||
958 | static void cmd_test_unit_ready(IDEState *s, uint8_t *buf) | |
959 | { | |
7a2c4b82 KW |
960 | /* Not Ready Conditions are already handled in ide_atapi_cmd(), so if we |
961 | * come here, we know that it's ready. */ | |
962 | ide_atapi_cmd_ok(s); | |
a60cf7e7 KW |
963 | } |
964 | ||
965 | static void cmd_prevent_allow_medium_removal(IDEState *s, uint8_t* buf) | |
966 | { | |
a0a7573b | 967 | s->tray_locked = buf[4] & 1; |
4be74634 | 968 | blk_lock_medium(s->blk, buf[4] & 1); |
a60cf7e7 KW |
969 | ide_atapi_cmd_ok(s); |
970 | } | |
971 | ||
972 | static void cmd_read(IDEState *s, uint8_t* buf) | |
973 | { | |
974 | int nb_sectors, lba; | |
975 | ||
976 | if (buf[0] == GPCMD_READ_10) { | |
614ab7d1 | 977 | nb_sectors = lduw_be_p(buf + 7); |
a60cf7e7 | 978 | } else { |
614ab7d1 | 979 | nb_sectors = ldl_be_p(buf + 6); |
a60cf7e7 KW |
980 | } |
981 | ||
614ab7d1 | 982 | lba = ldl_be_p(buf + 2); |
a60cf7e7 KW |
983 | if (nb_sectors == 0) { |
984 | ide_atapi_cmd_ok(s); | |
985 | return; | |
986 | } | |
987 | ||
988 | ide_atapi_cmd_read(s, lba, nb_sectors, 2048); | |
989 | } | |
990 | ||
991 | static void cmd_read_cd(IDEState *s, uint8_t* buf) | |
992 | { | |
993 | int nb_sectors, lba, transfer_request; | |
994 | ||
995 | nb_sectors = (buf[6] << 16) | (buf[7] << 8) | buf[8]; | |
614ab7d1 | 996 | lba = ldl_be_p(buf + 2); |
a60cf7e7 KW |
997 | |
998 | if (nb_sectors == 0) { | |
999 | ide_atapi_cmd_ok(s); | |
1000 | return; | |
1001 | } | |
1002 | ||
e7bd708e JS |
1003 | transfer_request = buf[9] & 0xf8; |
1004 | if (transfer_request == 0x00) { | |
a60cf7e7 KW |
1005 | /* nothing */ |
1006 | ide_atapi_cmd_ok(s); | |
e7bd708e JS |
1007 | return; |
1008 | } | |
1009 | ||
1010 | /* Check validity of BCL before transferring data */ | |
1011 | if (!validate_bcl(s)) { | |
1012 | return; | |
1013 | } | |
1014 | ||
1015 | switch (transfer_request) { | |
a60cf7e7 KW |
1016 | case 0x10: |
1017 | /* normal read */ | |
1018 | ide_atapi_cmd_read(s, lba, nb_sectors, 2048); | |
1019 | break; | |
1020 | case 0xf8: | |
1021 | /* read all data */ | |
1022 | ide_atapi_cmd_read(s, lba, nb_sectors, 2352); | |
1023 | break; | |
1024 | default: | |
67cc61e4 | 1025 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
a60cf7e7 KW |
1026 | ASC_INV_FIELD_IN_CMD_PACKET); |
1027 | break; | |
1028 | } | |
1029 | } | |
1030 | ||
1031 | static void cmd_seek(IDEState *s, uint8_t* buf) | |
1032 | { | |
1033 | unsigned int lba; | |
e119bcac | 1034 | uint64_t total_sectors = s->nb_sectors >> 2; |
a60cf7e7 | 1035 | |
614ab7d1 | 1036 | lba = ldl_be_p(buf + 2); |
a60cf7e7 | 1037 | if (lba >= total_sectors) { |
67cc61e4 | 1038 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_LOGICAL_BLOCK_OOR); |
a60cf7e7 KW |
1039 | return; |
1040 | } | |
1041 | ||
1042 | ide_atapi_cmd_ok(s); | |
1043 | } | |
1044 | ||
1045 | static void cmd_start_stop_unit(IDEState *s, uint8_t* buf) | |
1046 | { | |
fdec4404 | 1047 | int sense; |
f0776564 MA |
1048 | bool start = buf[4] & 1; |
1049 | bool loej = buf[4] & 2; /* load on start, eject on !start */ | |
ce560dcf RS |
1050 | int pwrcnd = buf[4] & 0xf0; |
1051 | ||
1052 | if (pwrcnd) { | |
1053 | /* eject/load only happens for power condition == 0 */ | |
03441c3a | 1054 | ide_atapi_cmd_ok(s); |
ce560dcf RS |
1055 | return; |
1056 | } | |
a60cf7e7 | 1057 | |
f0776564 | 1058 | if (loej) { |
48f65b3f | 1059 | if (!start && !s->tray_open && s->tray_locked) { |
4be74634 | 1060 | sense = blk_is_inserted(s->blk) |
67cc61e4 | 1061 | ? NOT_READY : ILLEGAL_REQUEST; |
fdec4404 MA |
1062 | ide_atapi_cmd_error(s, sense, ASC_MEDIA_REMOVAL_PREVENTED); |
1063 | return; | |
a60cf7e7 | 1064 | } |
d88b1819 LC |
1065 | |
1066 | if (s->tray_open != !start) { | |
4be74634 | 1067 | blk_eject(s->blk, !start); |
d88b1819 LC |
1068 | s->tray_open = !start; |
1069 | } | |
dd063333 | 1070 | } |
fdec4404 MA |
1071 | |
1072 | ide_atapi_cmd_ok(s); | |
a60cf7e7 KW |
1073 | } |
1074 | ||
1075 | static void cmd_mechanism_status(IDEState *s, uint8_t* buf) | |
1076 | { | |
614ab7d1 | 1077 | int max_len = lduw_be_p(buf + 8); |
a60cf7e7 | 1078 | |
614ab7d1 | 1079 | stw_be_p(buf, 0); |
a60cf7e7 KW |
1080 | /* no current LBA */ |
1081 | buf[2] = 0; | |
1082 | buf[3] = 0; | |
1083 | buf[4] = 0; | |
1084 | buf[5] = 1; | |
614ab7d1 | 1085 | stw_be_p(buf + 6, 0); |
a60cf7e7 KW |
1086 | ide_atapi_cmd_reply(s, 8, max_len); |
1087 | } | |
1088 | ||
1089 | static void cmd_read_toc_pma_atip(IDEState *s, uint8_t* buf) | |
1090 | { | |
1091 | int format, msf, start_track, len; | |
a60cf7e7 | 1092 | int max_len; |
7a2c4b82 | 1093 | uint64_t total_sectors = s->nb_sectors >> 2; |
a60cf7e7 | 1094 | |
614ab7d1 | 1095 | max_len = lduw_be_p(buf + 7); |
a60cf7e7 KW |
1096 | format = buf[9] >> 6; |
1097 | msf = (buf[1] >> 1) & 1; | |
1098 | start_track = buf[6]; | |
1099 | ||
1100 | switch(format) { | |
1101 | case 0: | |
1102 | len = cdrom_read_toc(total_sectors, buf, msf, start_track); | |
1103 | if (len < 0) | |
1104 | goto error_cmd; | |
1105 | ide_atapi_cmd_reply(s, len, max_len); | |
1106 | break; | |
1107 | case 1: | |
1108 | /* multi session : only a single session defined */ | |
1109 | memset(buf, 0, 12); | |
1110 | buf[1] = 0x0a; | |
1111 | buf[2] = 0x01; | |
1112 | buf[3] = 0x01; | |
1113 | ide_atapi_cmd_reply(s, 12, max_len); | |
1114 | break; | |
1115 | case 2: | |
1116 | len = cdrom_read_toc_raw(total_sectors, buf, msf, start_track); | |
1117 | if (len < 0) | |
1118 | goto error_cmd; | |
1119 | ide_atapi_cmd_reply(s, len, max_len); | |
1120 | break; | |
1121 | default: | |
1122 | error_cmd: | |
67cc61e4 | 1123 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
a60cf7e7 KW |
1124 | ASC_INV_FIELD_IN_CMD_PACKET); |
1125 | } | |
1126 | } | |
1127 | ||
1128 | static void cmd_read_cdvd_capacity(IDEState *s, uint8_t* buf) | |
1129 | { | |
e119bcac | 1130 | uint64_t total_sectors = s->nb_sectors >> 2; |
a60cf7e7 | 1131 | |
a60cf7e7 | 1132 | /* NOTE: it is really the number of sectors minus 1 */ |
614ab7d1 PMD |
1133 | stl_be_p(buf, total_sectors - 1); |
1134 | stl_be_p(buf + 4, 2048); | |
a60cf7e7 KW |
1135 | ide_atapi_cmd_reply(s, 8, 8); |
1136 | } | |
1137 | ||
55042b95 PB |
1138 | static void cmd_read_disc_information(IDEState *s, uint8_t* buf) |
1139 | { | |
1140 | uint8_t type = buf[1] & 7; | |
614ab7d1 | 1141 | uint32_t max_len = lduw_be_p(buf + 7); |
55042b95 PB |
1142 | |
1143 | /* Types 1/2 are only defined for Blu-Ray. */ | |
1144 | if (type != 0) { | |
1145 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, | |
1146 | ASC_INV_FIELD_IN_CMD_PACKET); | |
1147 | return; | |
1148 | } | |
1149 | ||
1150 | memset(buf, 0, 34); | |
1151 | buf[1] = 32; | |
1152 | buf[2] = 0xe; /* last session complete, disc finalized */ | |
1153 | buf[3] = 1; /* first track on disc */ | |
1154 | buf[4] = 1; /* # of sessions */ | |
1155 | buf[5] = 1; /* first track of last session */ | |
1156 | buf[6] = 1; /* last track of last session */ | |
1157 | buf[7] = 0x20; /* unrestricted use */ | |
1158 | buf[8] = 0x00; /* CD-ROM or DVD-ROM */ | |
1159 | /* 9-10-11: most significant byte corresponding bytes 4-5-6 */ | |
1160 | /* 12-23: not meaningful for CD-ROM or DVD-ROM */ | |
1161 | /* 24-31: disc bar code */ | |
1162 | /* 32: disc application code */ | |
1163 | /* 33: number of OPC tables */ | |
1164 | ||
1165 | ide_atapi_cmd_reply(s, 34, max_len); | |
1166 | } | |
1167 | ||
a60cf7e7 KW |
1168 | static void cmd_read_dvd_structure(IDEState *s, uint8_t* buf) |
1169 | { | |
1170 | int max_len; | |
1171 | int media = buf[1]; | |
1172 | int format = buf[7]; | |
1173 | int ret; | |
1174 | ||
614ab7d1 | 1175 | max_len = lduw_be_p(buf + 8); |
a60cf7e7 KW |
1176 | |
1177 | if (format < 0xff) { | |
1178 | if (media_is_cd(s)) { | |
67cc61e4 | 1179 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
a60cf7e7 KW |
1180 | ASC_INCOMPATIBLE_FORMAT); |
1181 | return; | |
1182 | } else if (!media_present(s)) { | |
67cc61e4 | 1183 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
a60cf7e7 KW |
1184 | ASC_INV_FIELD_IN_CMD_PACKET); |
1185 | return; | |
1186 | } | |
1187 | } | |
1188 | ||
a71f2d22 PMD |
1189 | memset(buf, 0, max_len > IDE_DMA_BUF_SECTORS * BDRV_SECTOR_SIZE + 4 ? |
1190 | IDE_DMA_BUF_SECTORS * BDRV_SECTOR_SIZE + 4 : max_len); | |
a60cf7e7 KW |
1191 | |
1192 | switch (format) { | |
1193 | case 0x00 ... 0x7f: | |
1194 | case 0xff: | |
1195 | if (media == 0) { | |
1196 | ret = ide_dvd_read_structure(s, format, buf, buf); | |
1197 | ||
1198 | if (ret < 0) { | |
67cc61e4 | 1199 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, -ret); |
a60cf7e7 KW |
1200 | } else { |
1201 | ide_atapi_cmd_reply(s, ret, max_len); | |
1202 | } | |
1203 | ||
1204 | break; | |
1205 | } | |
1206 | /* TODO: BD support, fall through for now */ | |
1207 | ||
1208 | /* Generic disk structures */ | |
1209 | case 0x80: /* TODO: AACS volume identifier */ | |
1210 | case 0x81: /* TODO: AACS media serial number */ | |
1211 | case 0x82: /* TODO: AACS media identifier */ | |
1212 | case 0x83: /* TODO: AACS media key block */ | |
1213 | case 0x90: /* TODO: List of recognized format layers */ | |
1214 | case 0xc0: /* TODO: Write protection status */ | |
1215 | default: | |
67cc61e4 | 1216 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, |
a60cf7e7 KW |
1217 | ASC_INV_FIELD_IN_CMD_PACKET); |
1218 | break; | |
1219 | } | |
1220 | } | |
1221 | ||
1222 | static void cmd_set_speed(IDEState *s, uint8_t* buf) | |
1223 | { | |
1224 | ide_atapi_cmd_ok(s); | |
1225 | } | |
1226 | ||
e1a064f9 KW |
1227 | enum { |
1228 | /* | |
1229 | * Only commands flagged as ALLOW_UA are allowed to run under a | |
1230 | * unit attention condition. (See MMC-5, section 4.1.6.1) | |
1231 | */ | |
1232 | ALLOW_UA = 0x01, | |
7a2c4b82 KW |
1233 | |
1234 | /* | |
1235 | * Commands flagged with CHECK_READY can only execute if a medium is present. | |
1236 | * Otherwise they report the Not Ready Condition. (See MMC-5, section | |
1237 | * 4.1.8) | |
1238 | */ | |
1239 | CHECK_READY = 0x02, | |
9ef2e93f JS |
1240 | |
1241 | /* | |
1242 | * Commands flagged with NONDATA do not in any circumstances return | |
1243 | * any data via ide_atapi_cmd_reply. These commands are exempt from | |
1244 | * the normal byte_count_limit constraints. | |
1245 | * See ATA8-ACS3 "7.21.5 Byte Count Limit" | |
1246 | */ | |
1247 | NONDATA = 0x04, | |
e7bd708e JS |
1248 | |
1249 | /* | |
1250 | * CONDDATA implies a command that transfers data only conditionally based | |
1251 | * on the presence of suboptions. It should be exempt from the BCL check at | |
1252 | * command validation time, but it needs to be checked at the command | |
1253 | * handler level instead. | |
1254 | */ | |
1255 | CONDDATA = 0x08, | |
e1a064f9 KW |
1256 | }; |
1257 | ||
f36aa12d | 1258 | static const struct AtapiCmd { |
e1a064f9 KW |
1259 | void (*handler)(IDEState *s, uint8_t *buf); |
1260 | int flags; | |
1261 | } atapi_cmd_table[0x100] = { | |
9ef2e93f | 1262 | [ 0x00 ] = { cmd_test_unit_ready, CHECK_READY | NONDATA }, |
e1a064f9 KW |
1263 | [ 0x03 ] = { cmd_request_sense, ALLOW_UA }, |
1264 | [ 0x12 ] = { cmd_inquiry, ALLOW_UA }, | |
9ef2e93f JS |
1265 | [ 0x1b ] = { cmd_start_stop_unit, NONDATA }, /* [1] */ |
1266 | [ 0x1e ] = { cmd_prevent_allow_medium_removal, NONDATA }, | |
7a2c4b82 | 1267 | [ 0x25 ] = { cmd_read_cdvd_capacity, CHECK_READY }, |
a1aff5bf | 1268 | [ 0x28 ] = { cmd_read, /* (10) */ CHECK_READY }, |
9ef2e93f | 1269 | [ 0x2b ] = { cmd_seek, CHECK_READY | NONDATA }, |
7a2c4b82 | 1270 | [ 0x43 ] = { cmd_read_toc_pma_atip, CHECK_READY }, |
e1a064f9 KW |
1271 | [ 0x46 ] = { cmd_get_configuration, ALLOW_UA }, |
1272 | [ 0x4a ] = { cmd_get_event_status_notification, ALLOW_UA }, | |
55042b95 | 1273 | [ 0x51 ] = { cmd_read_disc_information, CHECK_READY }, |
e1a064f9 | 1274 | [ 0x5a ] = { cmd_mode_sense, /* (10) */ 0 }, |
a1aff5bf MA |
1275 | [ 0xa8 ] = { cmd_read, /* (12) */ CHECK_READY }, |
1276 | [ 0xad ] = { cmd_read_dvd_structure, CHECK_READY }, | |
9ef2e93f | 1277 | [ 0xbb ] = { cmd_set_speed, NONDATA }, |
e1a064f9 | 1278 | [ 0xbd ] = { cmd_mechanism_status, 0 }, |
e7bd708e | 1279 | [ 0xbe ] = { cmd_read_cd, CHECK_READY | CONDDATA }, |
a1aff5bf | 1280 | /* [1] handler detects and reports not ready condition itself */ |
e1a064f9 KW |
1281 | }; |
1282 | ||
33231e0e KW |
1283 | void ide_atapi_cmd(IDEState *s) |
1284 | { | |
f36aa12d JS |
1285 | uint8_t *buf = s->io_buffer; |
1286 | const struct AtapiCmd *cmd = &atapi_cmd_table[s->io_buffer[0]]; | |
33231e0e | 1287 | |
82a13ff8 JS |
1288 | trace_ide_atapi_cmd(s, s->io_buffer[0]); |
1289 | ||
1290 | if (trace_event_get_state_backends(TRACE_IDE_ATAPI_CMD_PACKET)) { | |
1291 | /* Each pretty-printed byte needs two bytes and a space; */ | |
1292 | char *ppacket = g_malloc(ATAPI_PACKET_SIZE * 3 + 1); | |
33231e0e | 1293 | int i; |
82a13ff8 JS |
1294 | for (i = 0; i < ATAPI_PACKET_SIZE; i++) { |
1295 | sprintf(ppacket + (i * 3), "%02x ", buf[i]); | |
33231e0e | 1296 | } |
82a13ff8 JS |
1297 | trace_ide_atapi_cmd_packet(s, s->lcyl | (s->hcyl << 8), ppacket); |
1298 | g_free(ppacket); | |
33231e0e | 1299 | } |
f36aa12d | 1300 | |
33231e0e | 1301 | /* |
e1a064f9 KW |
1302 | * If there's a UNIT_ATTENTION condition pending, only command flagged with |
1303 | * ALLOW_UA are allowed to complete. with other commands getting a CHECK | |
1304 | * condition response unless a higher priority status, defined by the drive | |
33231e0e KW |
1305 | * here, is pending. |
1306 | */ | |
f36aa12d | 1307 | if (s->sense_key == UNIT_ATTENTION && !(cmd->flags & ALLOW_UA)) { |
33231e0e KW |
1308 | ide_atapi_cmd_check_status(s); |
1309 | return; | |
1310 | } | |
4a737d14 AS |
1311 | /* |
1312 | * When a CD gets changed, we have to report an ejected state and | |
1313 | * then a loaded state to guests so that they detect tray | |
1314 | * open/close and media change events. Guests that do not use | |
1315 | * GET_EVENT_STATUS_NOTIFICATION to detect such tray open/close | |
1316 | * states rely on this behavior. | |
1317 | */ | |
f36aa12d | 1318 | if (!(cmd->flags & ALLOW_UA) && |
4be74634 | 1319 | !s->tray_open && blk_is_inserted(s->blk) && s->cdrom_changed) { |
0c6f08b0 PH |
1320 | |
1321 | if (s->cdrom_changed == 1) { | |
1322 | ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT); | |
1323 | s->cdrom_changed = 2; | |
1324 | } else { | |
1325 | ide_atapi_cmd_error(s, UNIT_ATTENTION, ASC_MEDIUM_MAY_HAVE_CHANGED); | |
1326 | s->cdrom_changed = 0; | |
1327 | } | |
33231e0e | 1328 | |
33231e0e KW |
1329 | return; |
1330 | } | |
e1a064f9 | 1331 | |
7a2c4b82 | 1332 | /* Report a Not Ready condition if appropriate for the command */ |
f36aa12d | 1333 | if ((cmd->flags & CHECK_READY) && |
4be74634 | 1334 | (!media_present(s) || !blk_is_inserted(s->blk))) |
7a2c4b82 | 1335 | { |
67cc61e4 | 1336 | ide_atapi_cmd_error(s, NOT_READY, ASC_MEDIUM_NOT_PRESENT); |
7a2c4b82 KW |
1337 | return; |
1338 | } | |
1339 | ||
e7bd708e | 1340 | /* Commands that don't transfer DATA permit the byte_count_limit to be 0. |
9ef2e93f JS |
1341 | * If this is a data-transferring PIO command and BCL is 0, |
1342 | * we abort at the /ATA/ level, not the ATAPI level. | |
1343 | * See ATA8 ACS3 section 7.17.6.49 and 7.21.5 */ | |
e7bd708e JS |
1344 | if (cmd->handler && !(cmd->flags & (NONDATA | CONDDATA))) { |
1345 | if (!validate_bcl(s)) { | |
9ef2e93f JS |
1346 | return; |
1347 | } | |
1348 | } | |
1349 | ||
e1a064f9 | 1350 | /* Execute the command */ |
f36aa12d JS |
1351 | if (cmd->handler) { |
1352 | cmd->handler(s, buf); | |
e1a064f9 | 1353 | return; |
33231e0e | 1354 | } |
e1a064f9 | 1355 | |
67cc61e4 | 1356 | ide_atapi_cmd_error(s, ILLEGAL_REQUEST, ASC_ILLEGAL_OPCODE); |
33231e0e | 1357 | } |