]> git.proxmox.com Git - qemu.git/blame - hw/ide/core.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ide: Improve error messages
[qemu.git] / hw / ide / core.c
CommitLineData
5391d806 1/*
38cdea7c 2 * QEMU IDE disk and CD/DVD-ROM Emulator
5fafdf24 3 *
5391d806 4 * Copyright (c) 2003 Fabrice Bellard
201a51fc 5 * Copyright (c) 2006 Openedhand Ltd.
5fafdf24 6 *
5391d806
FB		 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 */
59f2a787
GH		 25#include <hw/hw.h>
26#include <hw/pc.h>
27#include <hw/pci.h>
43b443b6 28#include <hw/scsi.h>
87ecb68b
PB		 29#include "qemu-timer.h"
30#include "sysemu.h"
1fb8648d 31#include "dma.h"
59f2a787
GH		 32
33#include <hw/ide/internal.h>
e8b54394 34
6450a334
BS		 35#define IDE_PAGE_SIZE 4096
36
117e1e82 37static const int smart_attributes[][5] = {
e8b54394
BW		 38 /* id, flags, val, wrst, thrsh */
39 { 0x01, 0x03, 0x64, 0x64, 0x06}, /* raw read */
40 { 0x03, 0x03, 0x64, 0x64, 0x46}, /* spin up */
41 { 0x04, 0x02, 0x64, 0x64, 0x14}, /* start stop count */
42 { 0x05, 0x03, 0x64, 0x64, 0x36}, /* remapped sectors */
43 { 0x00, 0x00, 0x00, 0x00, 0x00}
44};
45
8114e9e8
TS		 46/* XXX: DVDs that could fit on a CD will be reported as a CD */
47static inline int media_present(IDEState *s)
48{
49 return (s->nb_sectors > 0);
50}
51
52static inline int media_is_dvd(IDEState *s)
53{
54 return (media_present(s) && s->nb_sectors > CD_MAX_SECTORS);
55}
56
57static inline int media_is_cd(IDEState *s)
58{
59 return (media_present(s) && s->nb_sectors <= CD_MAX_SECTORS);
60}
61
8ccad811 62static void ide_dma_start(IDEState *s, BlockDriverCompletionFunc *dma_cb);
ce4b6522 63static void ide_dma_restart(IDEState *s, int is_read);
5f12ab4b 64static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);
ce4b6522 65static int ide_handle_rw_error(IDEState *s, int error, int op);
98087450 66
5391d806
FB		 67static void padstr(char *str, const char *src, int len)
68{
69 int i, v;
70 for(i = 0; i < len; i++) {
71 if (*src)
72 v = *src++;
73 else
74 v = ' ';
69b34976 75 str[i^1] = v;
5391d806
FB		 76 }
77}
78
bd0d90b2
FB		 79static void padstr8(uint8_t *buf, int buf_size, const char *src)
80{
81 int i;
82 for(i = 0; i < buf_size; i++) {
83 if (*src)
84 buf[i] = *src++;
85 else
86 buf[i] = ' ';
87 }
88}
89
67b915a5
FB		 90static void put_le16(uint16_t *p, unsigned int v)
91{
0c4ad8dc 92 *p = cpu_to_le16(v);
67b915a5
FB		 93}
94
5391d806
FB		 95static void ide_identify(IDEState *s)
96{
97 uint16_t *p;
98 unsigned int oldsize;
57dac7ef 99 IDEDevice *dev;
5391d806 100
94458802
FB		 101 if (s->identify_set) {
102 memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
103 return;
104 }
105
5391d806
FB		 106 memset(s->io_buffer, 0, 512);
107 p = (uint16_t *)s->io_buffer;
67b915a5 108 put_le16(p + 0, 0x0040);
5fafdf24 109 put_le16(p + 1, s->cylinders);
67b915a5
FB		 110 put_le16(p + 3, s->heads);
111 put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
112 put_le16(p + 5, 512); /* XXX: retired, remove ? */
5fafdf24 113 put_le16(p + 6, s->sectors);
fa879c64 114 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
67b915a5
FB		 115 put_le16(p + 20, 3); /* XXX: retired, remove ? */
116 put_le16(p + 21, 512); /* cache size in sectors */
117 put_le16(p + 22, 4); /* ecc bytes */
47c06340 118 padstr((char *)(p + 23), s->version, 8); /* firmware version */
60fe76f3 119 padstr((char *)(p + 27), "QEMU HARDDISK", 40); /* model */
3b46e624 120#if MAX_MULT_SECTORS > 1
67b915a5 121 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
5391d806 122#endif
67b915a5 123 put_le16(p + 48, 1); /* dword I/O */
94458802 124 put_le16(p + 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
67b915a5
FB		 125 put_le16(p + 51, 0x200); /* PIO transfer cycle */
126 put_le16(p + 52, 0x200); /* DMA transfer cycle */
94458802 127 put_le16(p + 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
67b915a5
FB		 128 put_le16(p + 54, s->cylinders);
129 put_le16(p + 55, s->heads);
130 put_le16(p + 56, s->sectors);
5391d806 131 oldsize = s->cylinders * s->heads * s->sectors;
67b915a5
FB		 132 put_le16(p + 57, oldsize);
133 put_le16(p + 58, oldsize >> 16);
5391d806 134 if (s->mult_sectors)
67b915a5
FB		 135 put_le16(p + 59, 0x100 | s->mult_sectors);
136 put_le16(p + 60, s->nb_sectors);
137 put_le16(p + 61, s->nb_sectors >> 16);
d1b5c20d 138 put_le16(p + 62, 0x07); /* single word dma0-2 supported */
94458802
FB		 139 put_le16(p + 63, 0x07); /* mdma0-2 supported */
140 put_le16(p + 65, 120);
141 put_le16(p + 66, 120);
142 put_le16(p + 67, 120);
143 put_le16(p + 68, 120);
144 put_le16(p + 80, 0xf0); /* ata3 -> ata6 supported */
145 put_le16(p + 81, 0x16); /* conforms to ata5 */
e8b54394
BW		 146 /* 14=NOP supported, 0=SMART supported */
147 put_le16(p + 82, (1 << 14) | 1);
c2ff060f
FB		 148 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
149 put_le16(p + 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
e8b54394
BW		 150 /* 14=set to 1, 1=SMART self test, 0=SMART error logging */
151 put_le16(p + 84, (1 << 14) | 0);
e900a7b7
CH		 152 /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
153 if (bdrv_enable_write_cache(s->bs))
154 put_le16(p + 85, (1 << 14) | (1 << 5) | 1);
155 else
156 put_le16(p + 85, (1 << 14) | 1);
c2ff060f
FB		 157 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
158 put_le16(p + 86, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
e8b54394
BW		 159 /* 14=set to 1, 1=smart self test, 0=smart error logging */
160 put_le16(p + 87, (1 << 14) | 0);
94458802
FB		 161 put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
162 put_le16(p + 93, 1 | (1 << 14) | 0x2000);
c2ff060f
FB		 163 put_le16(p + 100, s->nb_sectors);
164 put_le16(p + 101, s->nb_sectors >> 16);
165 put_le16(p + 102, s->nb_sectors >> 32);
166 put_le16(p + 103, s->nb_sectors >> 48);
57dac7ef
MA		 167 dev = s->unit ? s->bus->slave : s->bus->master;
168 if (dev && dev->conf.physical_block_size)
169 put_le16(p + 106, 0x6000 | get_physical_block_exp(&dev->conf));
94458802
FB		 170
171 memcpy(s->identify_data, p, sizeof(s->identify_data));
172 s->identify_set = 1;
5391d806
FB		 173}
174
175static void ide_atapi_identify(IDEState *s)
176{
177 uint16_t *p;
178
94458802
FB		 179 if (s->identify_set) {
180 memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
181 return;
182 }
183
5391d806
FB		 184 memset(s->io_buffer, 0, 512);
185 p = (uint16_t *)s->io_buffer;
186 /* Removable CDROM, 50us response, 12 byte packets */
67b915a5 187 put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
fa879c64 188 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
67b915a5
FB		 189 put_le16(p + 20, 3); /* buffer type */
190 put_le16(p + 21, 512); /* cache size in sectors */
191 put_le16(p + 22, 4); /* ecc bytes */
47c06340 192 padstr((char *)(p + 23), s->version, 8); /* firmware version */
38cdea7c 193 padstr((char *)(p + 27), "QEMU DVD-ROM", 40); /* model */
67b915a5 194 put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
8ccad811
FB		 195#ifdef USE_DMA_CDROM
196 put_le16(p + 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
197 put_le16(p + 53, 7); /* words 64-70, 54-58, 88 valid */
d1b5c20d 198 put_le16(p + 62, 7); /* single word dma0-2 supported */
8ccad811
FB		 199 put_le16(p + 63, 7); /* mdma0-2 supported */
200 put_le16(p + 64, 0x3f); /* PIO modes supported */
201#else
67b915a5
FB		 202 put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
203 put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
204 put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
205 put_le16(p + 64, 1); /* PIO modes */
8ccad811 206#endif
67b915a5
FB		 207 put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
208 put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
209 put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
210 put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
94458802 211
67b915a5
FB		 212 put_le16(p + 71, 30); /* in ns */
213 put_le16(p + 72, 30); /* in ns */
5391d806 214
67b915a5 215 put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
8ccad811
FB		 216#ifdef USE_DMA_CDROM
217 put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
218#endif
94458802
FB		 219 memcpy(s->identify_data, p, sizeof(s->identify_data));
220 s->identify_set = 1;
5391d806
FB		 221}
222
201a51fc
AZ		 223static void ide_cfata_identify(IDEState *s)
224{
225 uint16_t *p;
226 uint32_t cur_sec;
201a51fc
AZ		 227
228 p = (uint16_t *) s->identify_data;
229 if (s->identify_set)
230 goto fill_buffer;
231
232 memset(p, 0, sizeof(s->identify_data));
233
234 cur_sec = s->cylinders * s->heads * s->sectors;
235
236 put_le16(p + 0, 0x848a); /* CF Storage Card signature */
237 put_le16(p + 1, s->cylinders); /* Default cylinders */
238 put_le16(p + 3, s->heads); /* Default heads */
239 put_le16(p + 6, s->sectors); /* Default sectors per track */
240 put_le16(p + 7, s->nb_sectors >> 16); /* Sectors per card */
241 put_le16(p + 8, s->nb_sectors); /* Sectors per card */
fa879c64 242 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
201a51fc 243 put_le16(p + 22, 0x0004); /* ECC bytes */
47c06340 244 padstr((char *) (p + 23), s->version, 8); /* Firmware Revision */
60fe76f3 245 padstr((char *) (p + 27), "QEMU MICRODRIVE", 40);/* Model number */
201a51fc
AZ		 246#if MAX_MULT_SECTORS > 1
247 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
248#else
249 put_le16(p + 47, 0x0000);
250#endif
251 put_le16(p + 49, 0x0f00); /* Capabilities */
252 put_le16(p + 51, 0x0002); /* PIO cycle timing mode */
253 put_le16(p + 52, 0x0001); /* DMA cycle timing mode */
254 put_le16(p + 53, 0x0003); /* Translation params valid */
255 put_le16(p + 54, s->cylinders); /* Current cylinders */
256 put_le16(p + 55, s->heads); /* Current heads */
257 put_le16(p + 56, s->sectors); /* Current sectors */
258 put_le16(p + 57, cur_sec); /* Current capacity */
259 put_le16(p + 58, cur_sec >> 16); /* Current capacity */
260 if (s->mult_sectors) /* Multiple sector setting */
261 put_le16(p + 59, 0x100 | s->mult_sectors);
262 put_le16(p + 60, s->nb_sectors); /* Total LBA sectors */
263 put_le16(p + 61, s->nb_sectors >> 16); /* Total LBA sectors */
264 put_le16(p + 63, 0x0203); /* Multiword DMA capability */
265 put_le16(p + 64, 0x0001); /* Flow Control PIO support */
266 put_le16(p + 65, 0x0096); /* Min. Multiword DMA cycle */
267 put_le16(p + 66, 0x0096); /* Rec. Multiword DMA cycle */
268 put_le16(p + 68, 0x00b4); /* Min. PIO cycle time */
269 put_le16(p + 82, 0x400c); /* Command Set supported */
270 put_le16(p + 83, 0x7068); /* Command Set supported */
271 put_le16(p + 84, 0x4000); /* Features supported */
272 put_le16(p + 85, 0x000c); /* Command Set enabled */
273 put_le16(p + 86, 0x7044); /* Command Set enabled */
274 put_le16(p + 87, 0x4000); /* Features enabled */
275 put_le16(p + 91, 0x4060); /* Current APM level */
276 put_le16(p + 129, 0x0002); /* Current features option */
277 put_le16(p + 130, 0x0005); /* Reassigned sectors */
278 put_le16(p + 131, 0x0001); /* Initial power mode */
279 put_le16(p + 132, 0x0000); /* User signature */
280 put_le16(p + 160, 0x8100); /* Power requirement */
281 put_le16(p + 161, 0x8001); /* CF command set */
282
283 s->identify_set = 1;
284
285fill_buffer:
286 memcpy(s->io_buffer, p, sizeof(s->identify_data));
287}
288
5391d806
FB		 289static void ide_set_signature(IDEState *s)
290{
291 s->select &= 0xf0; /* clear head */
292 /* put signature */
293 s->nsector = 1;
294 s->sector = 1;
295 if (s->is_cdrom) {
296 s->lcyl = 0x14;
297 s->hcyl = 0xeb;
298 } else if (s->bs) {
299 s->lcyl = 0;
300 s->hcyl = 0;
301 } else {
302 s->lcyl = 0xff;
303 s->hcyl = 0xff;
304 }
305}
306
307static inline void ide_abort_command(IDEState *s)
308{
309 s->status = READY_STAT | ERR_STAT;
310 s->error = ABRT_ERR;
311}
312
5604e090
AZ		 313static inline void ide_dma_submit_check(IDEState *s,
314 BlockDriverCompletionFunc *dma_cb, BMDMAState *bm)
315{
316 if (bm->aiocb)
317 return;
318 dma_cb(bm, -1);
319}
320
5391d806 321/* prepare data transfer and tell what to do after */
5fafdf24 322static void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
5391d806
FB		 323 EndTransferFunc *end_transfer_func)
324{
325 s->end_transfer_func = end_transfer_func;
326 s->data_ptr = buf;
327 s->data_end = buf + size;
7603d156
TS		 328 if (!(s->status & ERR_STAT))
329 s->status |= DRQ_STAT;
5391d806
FB		 330}
331
332static void ide_transfer_stop(IDEState *s)
333{
334 s->end_transfer_func = ide_transfer_stop;
335 s->data_ptr = s->io_buffer;
336 s->data_end = s->io_buffer;
337 s->status &= ~DRQ_STAT;
338}
339
356721ae 340int64_t ide_get_sector(IDEState *s)
5391d806
FB		 341{
342 int64_t sector_num;
343 if (s->select & 0x40) {
344 /* lba */
c2ff060f
FB		 345 if (!s->lba48) {
346 sector_num = ((s->select & 0x0f) << 24) | (s->hcyl << 16) |
347 (s->lcyl << 8) | s->sector;
348 } else {
349 sector_num = ((int64_t)s->hob_hcyl << 40) |
350 ((int64_t) s->hob_lcyl << 32) |
351 ((int64_t) s->hob_sector << 24) |
352 ((int64_t) s->hcyl << 16) |
353 ((int64_t) s->lcyl << 8) | s->sector;
354 }
5391d806
FB		 355 } else {
356 sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
c2ff060f 357 (s->select & 0x0f) * s->sectors + (s->sector - 1);
5391d806
FB		 358 }
359 return sector_num;
360}
361
356721ae 362void ide_set_sector(IDEState *s, int64_t sector_num)
5391d806
FB		 363{
364 unsigned int cyl, r;
365 if (s->select & 0x40) {
c2ff060f
FB		 366 if (!s->lba48) {
367 s->select = (s->select & 0xf0) | (sector_num >> 24);
368 s->hcyl = (sector_num >> 16);
369 s->lcyl = (sector_num >> 8);
370 s->sector = (sector_num);
371 } else {
372 s->sector = sector_num;
373 s->lcyl = sector_num >> 8;
374 s->hcyl = sector_num >> 16;
375 s->hob_sector = sector_num >> 24;
376 s->hob_lcyl = sector_num >> 32;
377 s->hob_hcyl = sector_num >> 40;
378 }
5391d806
FB		 379 } else {
380 cyl = sector_num / (s->heads * s->sectors);
381 r = sector_num % (s->heads * s->sectors);
382 s->hcyl = cyl >> 8;
383 s->lcyl = cyl;
1b8eb456 384 s->select = (s->select & 0xf0) | ((r / s->sectors) & 0x0f);
5391d806
FB		 385 s->sector = (r % s->sectors) + 1;
386 }
387}
388
e162cfb0
AZ		 389static void ide_rw_error(IDEState *s) {
390 ide_abort_command(s);
9cdd03a7 391 ide_set_irq(s->bus);
e162cfb0
AZ		 392}
393
5391d806
FB		 394static void ide_sector_read(IDEState *s)
395{
396 int64_t sector_num;
397 int ret, n;
398
399 s->status = READY_STAT | SEEK_STAT;
a136e5a8 400 s->error = 0; /* not needed by IDE spec, but needed by Windows */
5391d806
FB		 401 sector_num = ide_get_sector(s);
402 n = s->nsector;
403 if (n == 0) {
404 /* no more sector to read from disk */
405 ide_transfer_stop(s);
406 } else {
407#if defined(DEBUG_IDE)
18c5f8ea 408 printf("read sector=%" PRId64 "\n", sector_num);
5391d806
FB		 409#endif
410 if (n > s->req_nb_sectors)
411 n = s->req_nb_sectors;
412 ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
e162cfb0 413 if (ret != 0) {
ce4b6522
KW		 414 if (ide_handle_rw_error(s, -ret,
415 BM_STATUS_PIO_RETRY | BM_STATUS_RETRY_READ))
416 {
417 return;
418 }
e162cfb0 419 }
5391d806 420 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_read);
9cdd03a7 421 ide_set_irq(s->bus);
5391d806
FB		 422 ide_set_sector(s, sector_num + n);
423 s->nsector -= n;
424 }
425}
426
7aea4412
AL		 427
428/* return 0 if buffer completed */
429static int dma_buf_prepare(BMDMAState *bm, int is_write)
430{
bcbdc4d3 431 IDEState *s = bmdma_active_if(bm);
7aea4412
AL		 432 struct {
433 uint32_t addr;
434 uint32_t size;
435 } prd;
436 int l, len;
7aea4412 437
6450a334 438 qemu_sglist_init(&s->sg, s->nsector / (IDE_PAGE_SIZE / 512) + 1);
7aea4412
AL		 439 s->io_buffer_size = 0;
440 for(;;) {
441 if (bm->cur_prd_len == 0) {
442 /* end of table (with a fail safe of one page) */
443 if (bm->cur_prd_last ||
6450a334 444 (bm->cur_addr - bm->addr) >= IDE_PAGE_SIZE)
7aea4412
AL		 445 return s->io_buffer_size != 0;
446 cpu_physical_memory_read(bm->cur_addr, (uint8_t *)&prd, 8);
447 bm->cur_addr += 8;
448 prd.addr = le32_to_cpu(prd.addr);
449 prd.size = le32_to_cpu(prd.size);
450 len = prd.size & 0xfffe;
451 if (len == 0)
452 len = 0x10000;
453 bm->cur_prd_len = len;
454 bm->cur_prd_addr = prd.addr;
455 bm->cur_prd_last = (prd.size & 0x80000000);
456 }
457 l = bm->cur_prd_len;
458 if (l > 0) {
1fb8648d
AL		 459 qemu_sglist_add(&s->sg, bm->cur_prd_addr, l);
460 bm->cur_prd_addr += l;
461 bm->cur_prd_len -= l;
462 s->io_buffer_size += l;
7aea4412
AL		 463 }
464 }
465 return 1;
466}
467
468static void dma_buf_commit(IDEState *s, int is_write)
469{
1fb8648d 470 qemu_sglist_destroy(&s->sg);
7aea4412
AL		 471}
472
356721ae 473void ide_dma_error(IDEState *s)
e162cfb0
AZ		 474{
475 ide_transfer_stop(s);
476 s->error = ABRT_ERR;
477 s->status = READY_STAT | ERR_STAT;
9cdd03a7 478 ide_set_irq(s->bus);
e162cfb0
AZ		 479}
480
ce4b6522 481static int ide_handle_rw_error(IDEState *s, int error, int op)
428c5705 482{
ce4b6522 483 int is_read = (op & BM_STATUS_RETRY_READ);
abd7f68d 484 BlockErrorAction action = bdrv_get_on_error(s->bs, is_read);
428c5705 485
7ad7e3c3
LC		 486 if (action == BLOCK_ERR_IGNORE) {
487 bdrv_mon_event(s->bs, BDRV_ACTION_IGNORE, is_read);
428c5705 488 return 0;
7ad7e3c3 489 }
428c5705
AL		 490
491 if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
492 || action == BLOCK_ERR_STOP_ANY) {
bcbdc4d3
GH		 493 s->bus->bmdma->unit = s->unit;
494 s->bus->bmdma->status |= op;
7ad7e3c3 495 bdrv_mon_event(s->bs, BDRV_ACTION_STOP, is_read);
554a310b 496 vm_stop(0);
428c5705 497 } else {
ce4b6522 498 if (op & BM_STATUS_DMA_RETRY) {
7aea4412 499 dma_buf_commit(s, 0);
428c5705 500 ide_dma_error(s);
7aea4412 501 } else {
428c5705 502 ide_rw_error(s);
7aea4412 503 }
7ad7e3c3 504 bdrv_mon_event(s->bs, BDRV_ACTION_REPORT, is_read);
428c5705
AL		 505 }
506
507 return 1;
508}
509
8ccad811
FB		 510/* return 0 if buffer completed */
511static int dma_buf_rw(BMDMAState *bm, int is_write)
98087450 512{
bcbdc4d3 513 IDEState *s = bmdma_active_if(bm);
8ccad811
FB		 514 struct {
515 uint32_t addr;
516 uint32_t size;
517 } prd;
518 int l, len;
98087450 519
8ccad811
FB		 520 for(;;) {
521 l = s->io_buffer_size - s->io_buffer_index;
5fafdf24 522 if (l <= 0)
8ccad811
FB		 523 break;
524 if (bm->cur_prd_len == 0) {
525 /* end of table (with a fail safe of one page) */
526 if (bm->cur_prd_last ||
6450a334 527 (bm->cur_addr - bm->addr) >= IDE_PAGE_SIZE)
8ccad811
FB		 528 return 0;
529 cpu_physical_memory_read(bm->cur_addr, (uint8_t *)&prd, 8);
530 bm->cur_addr += 8;
531 prd.addr = le32_to_cpu(prd.addr);
532 prd.size = le32_to_cpu(prd.size);
533 len = prd.size & 0xfffe;
534 if (len == 0)
535 len = 0x10000;
536 bm->cur_prd_len = len;
537 bm->cur_prd_addr = prd.addr;
538 bm->cur_prd_last = (prd.size & 0x80000000);
539 }
540 if (l > bm->cur_prd_len)
541 l = bm->cur_prd_len;
542 if (l > 0) {
543 if (is_write) {
5fafdf24 544 cpu_physical_memory_write(bm->cur_prd_addr,
8ccad811
FB		 545 s->io_buffer + s->io_buffer_index, l);
546 } else {
5fafdf24 547 cpu_physical_memory_read(bm->cur_prd_addr,
8ccad811
FB		 548 s->io_buffer + s->io_buffer_index, l);
549 }
550 bm->cur_prd_addr += l;
551 bm->cur_prd_len -= l;
552 s->io_buffer_index += l;
98087450 553 }
98087450 554 }
8ccad811
FB		 555 return 1;
556}
557
8ccad811
FB		 558static void ide_read_dma_cb(void *opaque, int ret)
559{
560 BMDMAState *bm = opaque;
bcbdc4d3 561 IDEState *s = bmdma_active_if(bm);
8ccad811
FB		 562 int n;
563 int64_t sector_num;
564
e162cfb0 565 if (ret < 0) {
ce4b6522
KW		 566 if (ide_handle_rw_error(s, -ret,
567 BM_STATUS_DMA_RETRY | BM_STATUS_RETRY_READ))
568 {
569 return;
570 }
e162cfb0
AZ		 571 }
572
8ccad811
FB		 573 n = s->io_buffer_size >> 9;
574 sector_num = ide_get_sector(s);
575 if (n > 0) {
7aea4412 576 dma_buf_commit(s, 1);
8ccad811
FB		 577 sector_num += n;
578 ide_set_sector(s, sector_num);
579 s->nsector -= n;
8ccad811
FB		 580 }
581
582 /* end of transfer ? */
583 if (s->nsector == 0) {
98087450 584 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 585 ide_set_irq(s->bus);
8ccad811
FB		 586 eot:
587 bm->status &= ~BM_STATUS_DMAING;
588 bm->status |= BM_STATUS_INT;
589 bm->dma_cb = NULL;
bcbdc4d3 590 bm->unit = -1;
8ccad811
FB		 591 bm->aiocb = NULL;
592 return;
98087450 593 }
8ccad811
FB		 594
595 /* launch next transfer */
596 n = s->nsector;
8ccad811
FB		 597 s->io_buffer_index = 0;
598 s->io_buffer_size = n * 512;
7aea4412
AL		 599 if (dma_buf_prepare(bm, 1) == 0)
600 goto eot;
8ccad811 601#ifdef DEBUG_AIO
5df23f53 602 printf("aio_read: sector_num=%" PRId64 " n=%d\n", sector_num, n);
8ccad811 603#endif
1fb8648d 604 bm->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num, ide_read_dma_cb, bm);
5604e090 605 ide_dma_submit_check(s, ide_read_dma_cb, bm);
98087450
FB		 606}
607
608static void ide_sector_read_dma(IDEState *s)
609{
8ccad811 610 s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
98087450
FB		 611 s->io_buffer_index = 0;
612 s->io_buffer_size = 0;
e3007e66 613 s->is_read = 1;
98087450
FB		 614 ide_dma_start(s, ide_read_dma_cb);
615}
616
a09db21f
FB		 617static void ide_sector_write_timer_cb(void *opaque)
618{
619 IDEState *s = opaque;
9cdd03a7 620 ide_set_irq(s->bus);
a09db21f
FB		 621}
622
5391d806
FB		 623static void ide_sector_write(IDEState *s)
624{
625 int64_t sector_num;
31c2a146 626 int ret, n, n1;
5391d806
FB		 627
628 s->status = READY_STAT | SEEK_STAT;
629 sector_num = ide_get_sector(s);
630#if defined(DEBUG_IDE)
18c5f8ea 631 printf("write sector=%" PRId64 "\n", sector_num);
5391d806
FB		 632#endif
633 n = s->nsector;
634 if (n > s->req_nb_sectors)
635 n = s->req_nb_sectors;
31c2a146 636 ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
428c5705 637
e162cfb0 638 if (ret != 0) {
ce4b6522 639 if (ide_handle_rw_error(s, -ret, BM_STATUS_PIO_RETRY))
428c5705 640 return;
e162cfb0
AZ		 641 }
642
5391d806
FB		 643 s->nsector -= n;
644 if (s->nsector == 0) {
292eef5a 645 /* no more sectors to write */
5391d806
FB		 646 ide_transfer_stop(s);
647 } else {
648 n1 = s->nsector;
649 if (n1 > s->req_nb_sectors)
650 n1 = s->req_nb_sectors;
651 ide_transfer_start(s, s->io_buffer, 512 * n1, ide_sector_write);
652 }
653 ide_set_sector(s, sector_num + n);
3b46e624 654
31c2a146
TS		 655 if (win2k_install_hack && ((++s->irq_count % 16) == 0)) {
656 /* It seems there is a bug in the Windows 2000 installer HDD
657 IDE driver which fills the disk with empty logs when the
658 IDE write IRQ comes too early. This hack tries to correct
659 that at the expense of slower write performances. Use this
660 option _only_ to install Windows 2000. You must disable it
661 for normal use. */
f7736b91 662 qemu_mod_timer(s->sector_write_timer,
6ee093c9 663 qemu_get_clock(vm_clock) + (get_ticks_per_sec() / 1000));
f7736b91 664 } else {
9cdd03a7 665 ide_set_irq(s->bus);
31c2a146 666 }
5391d806
FB		 667}
668
213189ab 669static void ide_dma_restart_bh(void *opaque)
428c5705
AL		 670{
671 BMDMAState *bm = opaque;
ce4b6522 672 int is_read;
213189ab
MA		 673
674 qemu_bh_delete(bm->bh);
675 bm->bh = NULL;
676
ce4b6522
KW		 677 is_read = !!(bm->status & BM_STATUS_RETRY_READ);
678
428c5705 679 if (bm->status & BM_STATUS_DMA_RETRY) {
ce4b6522
KW		 680 bm->status &= ~(BM_STATUS_DMA_RETRY | BM_STATUS_RETRY_READ);
681 ide_dma_restart(bmdma_active_if(bm), is_read);
428c5705 682 } else if (bm->status & BM_STATUS_PIO_RETRY) {
ce4b6522
KW		 683 bm->status &= ~(BM_STATUS_PIO_RETRY | BM_STATUS_RETRY_READ);
684 if (is_read) {
685 ide_sector_read(bmdma_active_if(bm));
686 } else {
687 ide_sector_write(bmdma_active_if(bm));
688 }
428c5705
AL		 689 }
690}
691
356721ae 692void ide_dma_restart_cb(void *opaque, int running, int reason)
213189ab
MA		 693{
694 BMDMAState *bm = opaque;
695
696 if (!running)
697 return;
698
699 if (!bm->bh) {
700 bm->bh = qemu_bh_new(ide_dma_restart_bh, bm);
701 qemu_bh_schedule(bm->bh);
702 }
703}
704
8ccad811 705static void ide_write_dma_cb(void *opaque, int ret)
98087450 706{
8ccad811 707 BMDMAState *bm = opaque;
bcbdc4d3 708 IDEState *s = bmdma_active_if(bm);
8ccad811 709 int n;
98087450
FB		 710 int64_t sector_num;
711
e162cfb0 712 if (ret < 0) {
ce4b6522 713 if (ide_handle_rw_error(s, -ret, BM_STATUS_DMA_RETRY))
428c5705 714 return;
e162cfb0
AZ		 715 }
716
8ccad811
FB		 717 n = s->io_buffer_size >> 9;
718 sector_num = ide_get_sector(s);
719 if (n > 0) {
7aea4412 720 dma_buf_commit(s, 0);
8ccad811
FB		 721 sector_num += n;
722 ide_set_sector(s, sector_num);
723 s->nsector -= n;
98087450 724 }
98087450 725
8ccad811
FB		 726 /* end of transfer ? */
727 if (s->nsector == 0) {
728 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 729 ide_set_irq(s->bus);
8ccad811
FB		 730 eot:
731 bm->status &= ~BM_STATUS_DMAING;
732 bm->status |= BM_STATUS_INT;
733 bm->dma_cb = NULL;
bcbdc4d3 734 bm->unit = -1;
8ccad811
FB		 735 bm->aiocb = NULL;
736 return;
737 }
738
98087450 739 n = s->nsector;
98087450 740 s->io_buffer_size = n * 512;
7aea4412
AL		 741 /* launch next transfer */
742 if (dma_buf_prepare(bm, 0) == 0)
8ccad811
FB		 743 goto eot;
744#ifdef DEBUG_AIO
5df23f53 745 printf("aio_write: sector_num=%" PRId64 " n=%d\n", sector_num, n);
8ccad811 746#endif
1fb8648d 747 bm->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num, ide_write_dma_cb, bm);
5604e090 748 ide_dma_submit_check(s, ide_write_dma_cb, bm);
8ccad811
FB		 749}
750
751static void ide_sector_write_dma(IDEState *s)
752{
753 s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
754 s->io_buffer_index = 0;
755 s->io_buffer_size = 0;
e3007e66 756 s->is_read = 0;
98087450
FB		 757 ide_dma_start(s, ide_write_dma_cb);
758}
759
356721ae 760void ide_atapi_cmd_ok(IDEState *s)
5391d806
FB		 761{
762 s->error = 0;
41a2b959 763 s->status = READY_STAT | SEEK_STAT;
5391d806 764 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
9cdd03a7 765 ide_set_irq(s->bus);
5391d806
FB		 766}
767
356721ae 768void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc)
5391d806
FB		 769{
770#ifdef DEBUG_IDE_ATAPI
771 printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key, asc);
772#endif
773 s->error = sense_key << 4;
774 s->status = READY_STAT | ERR_STAT;
775 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
776 s->sense_key = sense_key;
777 s->asc = asc;
9cdd03a7 778 ide_set_irq(s->bus);
5391d806
FB		 779}
780
9118e7f0
AL		 781static void ide_atapi_cmd_check_status(IDEState *s)
782{
783#ifdef DEBUG_IDE_ATAPI
784 printf("atapi_cmd_check_status\n");
785#endif
786 s->error = MC_ERR | (SENSE_UNIT_ATTENTION << 4);
787 s->status = ERR_STAT;
788 s->nsector = 0;
9cdd03a7 789 ide_set_irq(s->bus);
9118e7f0
AL		 790}
791
b0484ae4
CH		 792static void ide_flush_cb(void *opaque, int ret)
793{
794 IDEState *s = opaque;
795
796 /* XXX: how do we signal I/O errors here? */
797
798 s->status = READY_STAT | SEEK_STAT;
799 ide_set_irq(s->bus);
800}
801
5391d806
FB		 802static inline void cpu_to_ube16(uint8_t *buf, int val)
803{
804 buf[0] = val >> 8;
9e622b15 805 buf[1] = val & 0xff;
5391d806
FB		 806}
807
808static inline void cpu_to_ube32(uint8_t *buf, unsigned int val)
809{
810 buf[0] = val >> 24;
811 buf[1] = val >> 16;
812 buf[2] = val >> 8;
9e622b15 813 buf[3] = val & 0xff;
5391d806
FB		 814}
815
816static inline int ube16_to_cpu(const uint8_t *buf)
817{
818 return (buf[0] << 8) | buf[1];
819}
820
821static inline int ube32_to_cpu(const uint8_t *buf)
822{
823 return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
824}
825
98087450
FB		 826static void lba_to_msf(uint8_t *buf, int lba)
827{
828 lba += 150;
829 buf[0] = (lba / 75) / 60;
830 buf[1] = (lba / 75) % 60;
831 buf[2] = lba % 75;
832}
833
8ccad811
FB		 834static void cd_data_to_raw(uint8_t *buf, int lba)
835{
836 /* sync bytes */
837 buf[0] = 0x00;
838 memset(buf + 1, 0xff, 10);
839 buf[11] = 0x00;
840 buf += 12;
841 /* MSF */
842 lba_to_msf(buf, lba);
843 buf[3] = 0x01; /* mode 1 data */
844 buf += 4;
845 /* data */
846 buf += 2048;
847 /* XXX: ECC not computed */
848 memset(buf, 0, 288);
849}
850
5fafdf24 851static int cd_read_sector(BlockDriverState *bs, int lba, uint8_t *buf,
98087450
FB		 852 int sector_size)
853{
66c6ef76
FB		 854 int ret;
855
98087450
FB		 856 switch(sector_size) {
857 case 2048:
66c6ef76 858 ret = bdrv_read(bs, (int64_t)lba << 2, buf, 4);
98087450
FB		 859 break;
860 case 2352:
66c6ef76
FB		 861 ret = bdrv_read(bs, (int64_t)lba << 2, buf + 16, 4);
862 if (ret < 0)
863 return ret;
8ccad811 864 cd_data_to_raw(buf, lba);
98087450
FB		 865 break;
866 default:
66c6ef76 867 ret = -EIO;
98087450
FB		 868 break;
869 }
66c6ef76
FB		 870 return ret;
871}
872
356721ae 873void ide_atapi_io_error(IDEState *s, int ret)
66c6ef76
FB		 874{
875 /* XXX: handle more errors */
876 if (ret == -ENOMEDIUM) {
5fafdf24 877 ide_atapi_cmd_error(s, SENSE_NOT_READY,
66c6ef76
FB		 878 ASC_MEDIUM_NOT_PRESENT);
879 } else {
5fafdf24 880 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
66c6ef76
FB		 881 ASC_LOGICAL_BLOCK_OOR);
882 }
98087450
FB		 883}
884
5391d806
FB		 885/* The whole ATAPI transfer logic is handled in this function */
886static void ide_atapi_cmd_reply_end(IDEState *s)
887{
66c6ef76 888 int byte_count_limit, size, ret;
5391d806 889#ifdef DEBUG_IDE_ATAPI
5fafdf24 890 printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
5391d806
FB		 891 s->packet_transfer_size,
892 s->elementary_transfer_size,
893 s->io_buffer_index);
894#endif
895 if (s->packet_transfer_size <= 0) {
896 /* end of transfer */
897 ide_transfer_stop(s);
41a2b959 898 s->status = READY_STAT | SEEK_STAT;
5391d806 899 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
9cdd03a7 900 ide_set_irq(s->bus);
5391d806
FB		 901#ifdef DEBUG_IDE_ATAPI
902 printf("status=0x%x\n", s->status);
903#endif
904 } else {
905 /* see if a new sector must be read */
98087450 906 if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
66c6ef76
FB		 907 ret = cd_read_sector(s->bs, s->lba, s->io_buffer, s->cd_sector_size);
908 if (ret < 0) {
909 ide_transfer_stop(s);
910 ide_atapi_io_error(s, ret);
911 return;
912 }
5391d806
FB		 913 s->lba++;
914 s->io_buffer_index = 0;
915 }
916 if (s->elementary_transfer_size > 0) {
917 /* there are some data left to transmit in this elementary
918 transfer */
98087450 919 size = s->cd_sector_size - s->io_buffer_index;
5391d806
FB		 920 if (size > s->elementary_transfer_size)
921 size = s->elementary_transfer_size;
5fafdf24 922 ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
5391d806
FB		 923 size, ide_atapi_cmd_reply_end);
924 s->packet_transfer_size -= size;
925 s->elementary_transfer_size -= size;
926 s->io_buffer_index += size;
927 } else {
928 /* a new transfer is needed */
929 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
930 byte_count_limit = s->lcyl | (s->hcyl << 8);
931#ifdef DEBUG_IDE_ATAPI
932 printf("byte_count_limit=%d\n", byte_count_limit);
933#endif
934 if (byte_count_limit == 0xffff)
935 byte_count_limit--;
936 size = s->packet_transfer_size;
937 if (size > byte_count_limit) {
938 /* byte count limit must be even if this case */
939 if (byte_count_limit & 1)
940 byte_count_limit--;
941 size = byte_count_limit;
5391d806 942 }
a136e5a8
FB		 943 s->lcyl = size;
944 s->hcyl = size >> 8;
5391d806
FB		 945 s->elementary_transfer_size = size;
946 /* we cannot transmit more than one sector at a time */
947 if (s->lba != -1) {
98087450
FB		 948 if (size > (s->cd_sector_size - s->io_buffer_index))
949 size = (s->cd_sector_size - s->io_buffer_index);
5391d806 950 }
5fafdf24 951 ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
5391d806
FB		 952 size, ide_atapi_cmd_reply_end);
953 s->packet_transfer_size -= size;
954 s->elementary_transfer_size -= size;
955 s->io_buffer_index += size;
9cdd03a7 956 ide_set_irq(s->bus);
5391d806
FB		 957#ifdef DEBUG_IDE_ATAPI
958 printf("status=0x%x\n", s->status);
959#endif
960 }
961 }
962}
963
964/* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
965static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
966{
967 if (size > max_size)
968 size = max_size;
969 s->lba = -1; /* no sector read */
970 s->packet_transfer_size = size;
5f12ab4b 971 s->io_buffer_size = size; /* dma: send the reply data as one chunk */
5391d806
FB		 972 s->elementary_transfer_size = 0;
973 s->io_buffer_index = 0;
974
5f12ab4b 975 if (s->atapi_dma) {
41a2b959 976 s->status = READY_STAT | SEEK_STAT | DRQ_STAT;
5f12ab4b
TS		 977 ide_dma_start(s, ide_atapi_cmd_read_dma_cb);
978 } else {
41a2b959 979 s->status = READY_STAT | SEEK_STAT;
5f12ab4b
TS		 980 ide_atapi_cmd_reply_end(s);
981 }
5391d806
FB		 982}
983
984/* start a CD-CDROM read command */
98087450
FB		 985static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
986 int sector_size)
5391d806 987{
5391d806 988 s->lba = lba;
98087450 989 s->packet_transfer_size = nb_sectors * sector_size;
5391d806 990 s->elementary_transfer_size = 0;
98087450
FB		 991 s->io_buffer_index = sector_size;
992 s->cd_sector_size = sector_size;
5391d806 993
41a2b959 994 s->status = READY_STAT | SEEK_STAT;
5391d806
FB		 995 ide_atapi_cmd_reply_end(s);
996}
997
98087450 998/* ATAPI DMA support */
8ccad811
FB		 999
1000/* XXX: handle read errors */
1001static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
98087450 1002{
8ccad811 1003 BMDMAState *bm = opaque;
bcbdc4d3 1004 IDEState *s = bmdma_active_if(bm);
8ccad811
FB		 1005 int data_offset, n;
1006
66c6ef76
FB		 1007 if (ret < 0) {
1008 ide_atapi_io_error(s, ret);
1009 goto eot;
1010 }
1011
8ccad811 1012 if (s->io_buffer_size > 0) {
5f12ab4b
TS		 1013 /*
1014 * For a cdrom read sector command (s->lba != -1),
1015 * adjust the lba for the next s->io_buffer_size chunk
1016 * and dma the current chunk.
1017 * For a command != read (s->lba == -1), just transfer
1018 * the reply data.
1019 */
1020 if (s->lba != -1) {
1021 if (s->cd_sector_size == 2352) {
1022 n = 1;
1023 cd_data_to_raw(s->io_buffer, s->lba);
1024 } else {
1025 n = s->io_buffer_size >> 11;
1026 }
1027 s->lba += n;
1028 }
8ccad811 1029 s->packet_transfer_size -= s->io_buffer_size;
8ccad811
FB		 1030 if (dma_buf_rw(bm, 1) == 0)
1031 goto eot;
98087450 1032 }
8ccad811 1033
98087450 1034 if (s->packet_transfer_size <= 0) {
41a2b959 1035 s->status = READY_STAT | SEEK_STAT;
98087450 1036 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
9cdd03a7 1037 ide_set_irq(s->bus);
8ccad811
FB		 1038 eot:
1039 bm->status &= ~BM_STATUS_DMAING;
1040 bm->status |= BM_STATUS_INT;
1041 bm->dma_cb = NULL;
bcbdc4d3 1042 bm->unit = -1;
8ccad811
FB		 1043 bm->aiocb = NULL;
1044 return;
1045 }
3b46e624 1046
8ccad811
FB		 1047 s->io_buffer_index = 0;
1048 if (s->cd_sector_size == 2352) {
1049 n = 1;
1050 s->io_buffer_size = s->cd_sector_size;
1051 data_offset = 16;
1052 } else {
1053 n = s->packet_transfer_size >> 11;
1d8cde5b
AJ		 1054 if (n > (IDE_DMA_BUF_SECTORS / 4))
1055 n = (IDE_DMA_BUF_SECTORS / 4);
8ccad811
FB		 1056 s->io_buffer_size = n * 2048;
1057 data_offset = 0;
98087450 1058 }
8ccad811
FB		 1059#ifdef DEBUG_AIO
1060 printf("aio_read_cd: lba=%u n=%d\n", s->lba, n);
1061#endif
3f4cb3d3 1062 bm->iov.iov_base = (void *)(s->io_buffer + data_offset);
c87c0672
AL		 1063 bm->iov.iov_len = n * 4 * 512;
1064 qemu_iovec_init_external(&bm->qiov, &bm->iov, 1);
1065 bm->aiocb = bdrv_aio_readv(s->bs, (int64_t)s->lba << 2, &bm->qiov,
1066 n * 4, ide_atapi_cmd_read_dma_cb, bm);
66c6ef76
FB		 1067 if (!bm->aiocb) {
1068 /* Note: media not present is the most likely case */
5fafdf24 1069 ide_atapi_cmd_error(s, SENSE_NOT_READY,
66c6ef76
FB		 1070 ASC_MEDIUM_NOT_PRESENT);
1071 goto eot;
1072 }
98087450
FB		 1073}
1074
1075/* start a CD-CDROM read command with DMA */
1076/* XXX: test if DMA is available */
1077static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors,
1078 int sector_size)
1079{
1080 s->lba = lba;
1081 s->packet_transfer_size = nb_sectors * sector_size;
8ccad811
FB		 1082 s->io_buffer_index = 0;
1083 s->io_buffer_size = 0;
98087450
FB		 1084 s->cd_sector_size = sector_size;
1085
8ccad811 1086 /* XXX: check if BUSY_STAT should be set */
41a2b959 1087 s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
98087450
FB		 1088 ide_dma_start(s, ide_atapi_cmd_read_dma_cb);
1089}
1090
5fafdf24 1091static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors,
98087450
FB		 1092 int sector_size)
1093{
1094#ifdef DEBUG_IDE_ATAPI
5f12ab4b
TS		 1095 printf("read %s: LBA=%d nb_sectors=%d\n", s->atapi_dma ? "dma" : "pio",
1096 lba, nb_sectors);
98087450
FB		 1097#endif
1098 if (s->atapi_dma) {
1099 ide_atapi_cmd_read_dma(s, lba, nb_sectors, sector_size);
1100 } else {
1101 ide_atapi_cmd_read_pio(s, lba, nb_sectors, sector_size);
1102 }
1103}
1104
38cdea7c
AZ		 1105static inline uint8_t ide_atapi_set_profile(uint8_t *buf, uint8_t *index,
1106 uint16_t profile)
1107{
1108 uint8_t *buf_profile = buf + 12; /* start of profiles */
1109
1110 buf_profile += ((*index) * 4); /* start of indexed profile */
1111 cpu_to_ube16 (buf_profile, profile);
1112 buf_profile[2] = ((buf_profile[0] == buf[6]) && (buf_profile[1] == buf[7]));
1113
1114 /* each profile adds 4 bytes to the response */
1115 (*index)++;
1116 buf[11] += 4; /* Additional Length */
1117
1118 return 4;
1119}
1120
8114e9e8
TS		 1121static int ide_dvd_read_structure(IDEState *s, int format,
1122 const uint8_t *packet, uint8_t *buf)
1123{
1124 switch (format) {
1125 case 0x0: /* Physical format information */
1126 {
1127 int layer = packet[6];
1128 uint64_t total_sectors;
1129
1130 if (layer != 0)
1131 return -ASC_INV_FIELD_IN_CMD_PACKET;
1132
1133 bdrv_get_geometry(s->bs, &total_sectors);
1134 total_sectors >>= 2;
1135 if (total_sectors == 0)
1136 return -ASC_MEDIUM_NOT_PRESENT;
1137
1138 buf[4] = 1; /* DVD-ROM, part version 1 */
1139 buf[5] = 0xf; /* 120mm disc, minimum rate unspecified */
1140 buf[6] = 1; /* one layer, read-only (per MMC-2 spec) */
1141 buf[7] = 0; /* default densities */
1142
1143 /* FIXME: 0x30000 per spec? */
1144 cpu_to_ube32(buf + 8, 0); /* start sector */
1145 cpu_to_ube32(buf + 12, total_sectors - 1); /* end sector */
1146 cpu_to_ube32(buf + 16, total_sectors - 1); /* l0 end sector */
1147
1148 /* Size of buffer, not including 2 byte size field */
1149 cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
1150
1151 /* 2k data + 4 byte header */
1152 return (2048 + 4);
1153 }
1154
1155 case 0x01: /* DVD copyright information */
1156 buf[4] = 0; /* no copyright data */
1157 buf[5] = 0; /* no region restrictions */
1158
1159 /* Size of buffer, not including 2 byte size field */
1160 cpu_to_be16wu((uint16_t *)buf, 4 + 2);
1161
1162 /* 4 byte header + 4 byte data */
1163 return (4 + 4);
1164
1165 case 0x03: /* BCA information - invalid field for no BCA info */
1166 return -ASC_INV_FIELD_IN_CMD_PACKET;
1167
1168 case 0x04: /* DVD disc manufacturing information */
1169 /* Size of buffer, not including 2 byte size field */
1170 cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
1171
1172 /* 2k data + 4 byte header */
1173 return (2048 + 4);
1174
1175 case 0xff:
1176 /*
1177 * This lists all the command capabilities above. Add new ones
1178 * in order and update the length and buffer return values.
1179 */
1180
1181 buf[4] = 0x00; /* Physical format */
1182 buf[5] = 0x40; /* Not writable, is readable */
1183 cpu_to_be16wu((uint16_t *)(buf + 6), 2048 + 4);
1184
1185 buf[8] = 0x01; /* Copyright info */
1186 buf[9] = 0x40; /* Not writable, is readable */
1187 cpu_to_be16wu((uint16_t *)(buf + 10), 4 + 4);
1188
1189 buf[12] = 0x03; /* BCA info */
1190 buf[13] = 0x40; /* Not writable, is readable */
1191 cpu_to_be16wu((uint16_t *)(buf + 14), 188 + 4);
1192
1193 buf[16] = 0x04; /* Manufacturing info */
1194 buf[17] = 0x40; /* Not writable, is readable */
1195 cpu_to_be16wu((uint16_t *)(buf + 18), 2048 + 4);
1196
1197 /* Size of buffer, not including 2 byte size field */
1198 cpu_to_be16wu((uint16_t *)buf, 16 + 2);
1199
1200 /* data written + 4 byte header */
1201 return (16 + 4);
1202
1203 default: /* TODO: formats beyond DVD-ROM requires */
1204 return -ASC_INV_FIELD_IN_CMD_PACKET;
1205 }
1206}
1207
5391d806
FB		 1208static void ide_atapi_cmd(IDEState *s)
1209{
1210 const uint8_t *packet;
1211 uint8_t *buf;
1212 int max_len;
1213
1214 packet = s->io_buffer;
1215 buf = s->io_buffer;
1216#ifdef DEBUG_IDE_ATAPI
1217 {
1218 int i;
1219 printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8));
1220 for(i = 0; i < ATAPI_PACKET_SIZE; i++) {
1221 printf(" %02x", packet[i]);
1222 }
1223 printf("\n");
1224 }
1225#endif
9118e7f0
AL		 1226 /* If there's a UNIT_ATTENTION condition pending, only
1227 REQUEST_SENSE and INQUIRY commands are allowed to complete. */
1228 if (s->sense_key == SENSE_UNIT_ATTENTION &&
1229 s->io_buffer[0] != GPCMD_REQUEST_SENSE &&
1230 s->io_buffer[0] != GPCMD_INQUIRY) {
1231 ide_atapi_cmd_check_status(s);
1232 return;
1233 }
5391d806
FB		 1234 switch(s->io_buffer[0]) {
1235 case GPCMD_TEST_UNIT_READY:
93c8cfd9 1236 if (bdrv_is_inserted(s->bs) && !s->cdrom_changed) {
5391d806
FB		 1237 ide_atapi_cmd_ok(s);
1238 } else {
93c8cfd9 1239 s->cdrom_changed = 0;
5fafdf24 1240 ide_atapi_cmd_error(s, SENSE_NOT_READY,
5391d806
FB		 1241 ASC_MEDIUM_NOT_PRESENT);
1242 }
1243 break;
d14049ea 1244 case GPCMD_MODE_SENSE_6:
5391d806
FB		 1245 case GPCMD_MODE_SENSE_10:
1246 {
1247 int action, code;
d14049ea
TS		 1248 if (packet[0] == GPCMD_MODE_SENSE_10)
1249 max_len = ube16_to_cpu(packet + 7);
1250 else
1251 max_len = packet[4];
5391d806
FB		 1252 action = packet[2] >> 6;
1253 code = packet[2] & 0x3f;
1254 switch(action) {
1255 case 0: /* current values */
1256 switch(code) {
a70089ce 1257 case GPMODE_R_W_ERROR_PAGE: /* error recovery */
5391d806
FB		 1258 cpu_to_ube16(&buf[0], 16 + 6);
1259 buf[2] = 0x70;
1260 buf[3] = 0;
1261 buf[4] = 0;
1262 buf[5] = 0;
1263 buf[6] = 0;
1264 buf[7] = 0;
1265
1266 buf[8] = 0x01;
1267 buf[9] = 0x06;
1268 buf[10] = 0x00;
1269 buf[11] = 0x05;
1270 buf[12] = 0x00;
1271 buf[13] = 0x00;
1272 buf[14] = 0x00;
1273 buf[15] = 0x00;
1274 ide_atapi_cmd_reply(s, 16, max_len);
1275 break;
fe0d6123
TLSC		 1276 case GPMODE_AUDIO_CTL_PAGE:
1277 cpu_to_ube16(&buf[0], 24 + 6);
1278 buf[2] = 0x70;
1279 buf[3] = 0;
1280 buf[4] = 0;
1281 buf[5] = 0;
1282 buf[6] = 0;
1283 buf[7] = 0;
1284
1285 /* Fill with CDROM audio volume */
1286 buf[17] = 0;
1287 buf[19] = 0;
1288 buf[21] = 0;
1289 buf[23] = 0;
1290
1291 ide_atapi_cmd_reply(s, 24, max_len);
1292 break;
a70089ce 1293 case GPMODE_CAPABILITIES_PAGE:
5391d806
FB		 1294 cpu_to_ube16(&buf[0], 28 + 6);
1295 buf[2] = 0x70;
1296 buf[3] = 0;
1297 buf[4] = 0;
1298 buf[5] = 0;
1299 buf[6] = 0;
1300 buf[7] = 0;
1301
1302 buf[8] = 0x2a;
1303 buf[9] = 0x12;
0d4a05a1 1304 buf[10] = 0x00;
5391d806 1305 buf[11] = 0x00;
3b46e624 1306
d5b4eb40
AL		 1307 /* Claim PLAY_AUDIO capability (0x01) since some Linux
1308 code checks for this to automount media. */
1309 buf[12] = 0x71;
5391d806
FB		 1310 buf[13] = 3 << 5;
1311 buf[14] = (1 << 0) | (1 << 3) | (1 << 5);
caed8802 1312 if (bdrv_is_locked(s->bs))
5391d806
FB		 1313 buf[6] |= 1 << 1;
1314 buf[15] = 0x00;
1315 cpu_to_ube16(&buf[16], 706);
1316 buf[18] = 0;
1317 buf[19] = 2;
1318 cpu_to_ube16(&buf[20], 512);
1319 cpu_to_ube16(&buf[22], 706);
1320 buf[24] = 0;
1321 buf[25] = 0;
1322 buf[26] = 0;
1323 buf[27] = 0;
1324 ide_atapi_cmd_reply(s, 28, max_len);
1325 break;
1326 default:
1327 goto error_cmd;
1328 }
1329 break;
1330 case 1: /* changeable values */
1331 goto error_cmd;
1332 case 2: /* default values */
1333 goto error_cmd;
1334 default:
1335 case 3: /* saved values */
5fafdf24 1336 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
5391d806
FB		 1337 ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
1338 break;
1339 }
1340 }
1341 break;
1342 case GPCMD_REQUEST_SENSE:
1343 max_len = packet[4];
1344 memset(buf, 0, 18);
1345 buf[0] = 0x70 | (1 << 7);
1346 buf[2] = s->sense_key;
1347 buf[7] = 10;
1348 buf[12] = s->asc;
9118e7f0
AL		 1349 if (s->sense_key == SENSE_UNIT_ATTENTION)
1350 s->sense_key = SENSE_NONE;
5391d806
FB		 1351 ide_atapi_cmd_reply(s, 18, max_len);
1352 break;
1353 case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
caed8802
FB		 1354 if (bdrv_is_inserted(s->bs)) {
1355 bdrv_set_locked(s->bs, packet[4] & 1);
5391d806
FB		 1356 ide_atapi_cmd_ok(s);
1357 } else {
5fafdf24 1358 ide_atapi_cmd_error(s, SENSE_NOT_READY,
5391d806
FB		 1359 ASC_MEDIUM_NOT_PRESENT);
1360 }
1361 break;
1362 case GPCMD_READ_10:
1363 case GPCMD_READ_12:
1364 {
1365 int nb_sectors, lba;
1366
5391d806
FB		 1367 if (packet[0] == GPCMD_READ_10)
1368 nb_sectors = ube16_to_cpu(packet + 7);
1369 else
1370 nb_sectors = ube32_to_cpu(packet + 6);
1371 lba = ube32_to_cpu(packet + 2);
1372 if (nb_sectors == 0) {
1373 ide_atapi_cmd_ok(s);
1374 break;
1375 }
98087450
FB		 1376 ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
1377 }
1378 break;
1379 case GPCMD_READ_CD:
1380 {
1381 int nb_sectors, lba, transfer_request;
1382
98087450
FB		 1383 nb_sectors = (packet[6] << 16) | (packet[7] << 8) | packet[8];
1384 lba = ube32_to_cpu(packet + 2);
1385 if (nb_sectors == 0) {
1386 ide_atapi_cmd_ok(s);
1387 break;
1388 }
98087450
FB		 1389 transfer_request = packet[9];
1390 switch(transfer_request & 0xf8) {
1391 case 0x00:
1392 /* nothing */
1393 ide_atapi_cmd_ok(s);
1394 break;
1395 case 0x10:
1396 /* normal read */
1397 ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
1398 break;
1399 case 0xf8:
1400 /* read all data */
1401 ide_atapi_cmd_read(s, lba, nb_sectors, 2352);
1402 break;
1403 default:
5fafdf24 1404 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
98087450
FB		 1405 ASC_INV_FIELD_IN_CMD_PACKET);
1406 break;
1407 }
5391d806
FB		 1408 }
1409 break;
1410 case GPCMD_SEEK:
1411 {
96b8f136
TS		 1412 unsigned int lba;
1413 uint64_t total_sectors;
66c6ef76
FB		 1414
1415 bdrv_get_geometry(s->bs, &total_sectors);
1416 total_sectors >>= 2;
96b8f136 1417 if (total_sectors == 0) {
5fafdf24 1418 ide_atapi_cmd_error(s, SENSE_NOT_READY,
5391d806
FB		 1419 ASC_MEDIUM_NOT_PRESENT);
1420 break;
1421 }
1422 lba = ube32_to_cpu(packet + 2);
66c6ef76 1423 if (lba >= total_sectors) {
5fafdf24 1424 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
5391d806
FB		 1425 ASC_LOGICAL_BLOCK_OOR);
1426 break;
1427 }
1428 ide_atapi_cmd_ok(s);
1429 }
1430 break;
1431 case GPCMD_START_STOP_UNIT:
1432 {
aea2a33c 1433 int start, eject, err = 0;
5391d806
FB		 1434 start = packet[4] & 1;
1435 eject = (packet[4] >> 1) & 1;
3b46e624 1436
aea2a33c
MM		 1437 if (eject) {
1438 err = bdrv_eject(s->bs, !start);
1439 }
1440
1441 switch (err) {
1442 case 0:
1443 ide_atapi_cmd_ok(s);
1444 break;
1445 case -EBUSY:
1446 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1447 ASC_MEDIA_REMOVAL_PREVENTED);
1448 break;
1449 default:
1450 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1451 ASC_MEDIUM_NOT_PRESENT);
1452 break;
caed8802 1453 }
5391d806
FB		 1454 }
1455 break;
1456 case GPCMD_MECHANISM_STATUS:
1457 {
1458 max_len = ube16_to_cpu(packet + 8);
1459 cpu_to_ube16(buf, 0);
1460 /* no current LBA */
1461 buf[2] = 0;
1462 buf[3] = 0;
1463 buf[4] = 0;
1464 buf[5] = 1;
1465 cpu_to_ube16(buf + 6, 0);
1466 ide_atapi_cmd_reply(s, 8, max_len);
1467 }
1468 break;
1469 case GPCMD_READ_TOC_PMA_ATIP:
1470 {
1471 int format, msf, start_track, len;
96b8f136 1472 uint64_t total_sectors;
5391d806 1473
66c6ef76
FB		 1474 bdrv_get_geometry(s->bs, &total_sectors);
1475 total_sectors >>= 2;
96b8f136 1476 if (total_sectors == 0) {
5fafdf24 1477 ide_atapi_cmd_error(s, SENSE_NOT_READY,
5391d806
FB		 1478 ASC_MEDIUM_NOT_PRESENT);
1479 break;
1480 }
1481 max_len = ube16_to_cpu(packet + 7);
1482 format = packet[9] >> 6;
1483 msf = (packet[1] >> 1) & 1;
1484 start_track = packet[6];
1485 switch(format) {
1486 case 0:
66c6ef76 1487 len = cdrom_read_toc(total_sectors, buf, msf, start_track);
5391d806
FB		 1488 if (len < 0)
1489 goto error_cmd;
1490 ide_atapi_cmd_reply(s, len, max_len);
1491 break;
1492 case 1:
1493 /* multi session : only a single session defined */
1494 memset(buf, 0, 12);
1495 buf[1] = 0x0a;
1496 buf[2] = 0x01;
1497 buf[3] = 0x01;
1498 ide_atapi_cmd_reply(s, 12, max_len);
1499 break;
98087450 1500 case 2:
66c6ef76 1501 len = cdrom_read_toc_raw(total_sectors, buf, msf, start_track);
98087450
FB		 1502 if (len < 0)
1503 goto error_cmd;
1504 ide_atapi_cmd_reply(s, len, max_len);
1505 break;
5391d806 1506 default:
7f777bf3 1507 error_cmd:
5fafdf24 1508 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
7f777bf3
FB		 1509 ASC_INV_FIELD_IN_CMD_PACKET);
1510 break;
5391d806
FB		 1511 }
1512 }
1513 break;
1514 case GPCMD_READ_CDVD_CAPACITY:
66c6ef76 1515 {
96b8f136 1516 uint64_t total_sectors;
66c6ef76
FB		 1517
1518 bdrv_get_geometry(s->bs, &total_sectors);
1519 total_sectors >>= 2;
96b8f136 1520 if (total_sectors == 0) {
5fafdf24 1521 ide_atapi_cmd_error(s, SENSE_NOT_READY,
66c6ef76
FB		 1522 ASC_MEDIUM_NOT_PRESENT);
1523 break;
1524 }
1525 /* NOTE: it is really the number of sectors minus 1 */
1526 cpu_to_ube32(buf, total_sectors - 1);
1527 cpu_to_ube32(buf + 4, 2048);
1528 ide_atapi_cmd_reply(s, 8, 8);
5391d806 1529 }
5391d806 1530 break;
d14049ea
TS		 1531 case GPCMD_READ_DVD_STRUCTURE:
1532 {
1533 int media = packet[1];
8114e9e8
TS		 1534 int format = packet[7];
1535 int ret;
d14049ea 1536
8114e9e8 1537 max_len = ube16_to_cpu(packet + 8);
d14049ea 1538
8114e9e8
TS		 1539 if (format < 0xff) {
1540 if (media_is_cd(s)) {
1541 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1542 ASC_INCOMPATIBLE_FORMAT);
1543 break;
1544 } else if (!media_present(s)) {
1545 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1546 ASC_INV_FIELD_IN_CMD_PACKET);
1547 break;
1548 }
1549 }
d14049ea 1550
8114e9e8
TS		 1551 memset(buf, 0, max_len > IDE_DMA_BUF_SECTORS * 512 + 4 ?
1552 IDE_DMA_BUF_SECTORS * 512 + 4 : max_len);
d14049ea 1553
8114e9e8
TS		 1554 switch (format) {
1555 case 0x00 ... 0x7f:
1556 case 0xff:
1557 if (media == 0) {
1558 ret = ide_dvd_read_structure(s, format, packet, buf);
d14049ea 1559
8114e9e8
TS		 1560 if (ret < 0)
1561 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST, -ret);
1562 else
1563 ide_atapi_cmd_reply(s, ret, max_len);
d14049ea 1564
8114e9e8
TS		 1565 break;
1566 }
1567 /* TODO: BD support, fall through for now */
1568
1569 /* Generic disk structures */
1570 case 0x80: /* TODO: AACS volume identifier */
1571 case 0x81: /* TODO: AACS media serial number */
1572 case 0x82: /* TODO: AACS media identifier */
1573 case 0x83: /* TODO: AACS media key block */
1574 case 0x90: /* TODO: List of recognized format layers */
1575 case 0xc0: /* TODO: Write protection status */
d14049ea
TS		 1576 default:
1577 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1578 ASC_INV_FIELD_IN_CMD_PACKET);
1579 break;
1580 }
1581 }
1582 break;
1583 case GPCMD_SET_SPEED:
1584 ide_atapi_cmd_ok(s);
1585 break;
bd0d90b2
FB		 1586 case GPCMD_INQUIRY:
1587 max_len = packet[4];
1588 buf[0] = 0x05; /* CD-ROM */
1589 buf[1] = 0x80; /* removable */
1590 buf[2] = 0x00; /* ISO */
1591 buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
aa1f17c1 1592 buf[4] = 31; /* additional length */
bd0d90b2
FB		 1593 buf[5] = 0; /* reserved */
1594 buf[6] = 0; /* reserved */
1595 buf[7] = 0; /* reserved */
1596 padstr8(buf + 8, 8, "QEMU");
38cdea7c 1597 padstr8(buf + 16, 16, "QEMU DVD-ROM");
47c06340 1598 padstr8(buf + 32, 4, s->version);
bd0d90b2
FB		 1599 ide_atapi_cmd_reply(s, 36, max_len);
1600 break;
d14049ea
TS		 1601 case GPCMD_GET_CONFIGURATION:
1602 {
38cdea7c 1603 uint32_t len;
091d055b 1604 uint8_t index = 0;
d14049ea
TS		 1605
1606 /* only feature 0 is supported */
1607 if (packet[2] != 0 || packet[3] != 0) {
1608 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1609 ASC_INV_FIELD_IN_CMD_PACKET);
1610 break;
1611 }
38cdea7c
AZ		 1612
1613 /* XXX: could result in alignment problems in some architectures */
1614 max_len = ube16_to_cpu(packet + 7);
091d055b 1615
38cdea7c 1616 /*
091d055b
AZ		 1617 * XXX: avoid overflow for io_buffer if max_len is bigger than
1618 * the size of that buffer (dimensioned to max number of
1619 * sectors to transfer at once)
38cdea7c 1620 *
091d055b 1621 * Only a problem if the feature/profiles grow.
38cdea7c
AZ		 1622 */
1623 if (max_len > 512) /* XXX: assume 1 sector */
1624 max_len = 512;
1625
1626 memset(buf, 0, max_len);
1627 /*
1628 * the number of sectors from the media tells us which profile
1629 * to use as current. 0 means there is no media
38cdea7c 1630 */
8114e9e8
TS		 1631 if (media_is_dvd(s))
1632 cpu_to_ube16(buf + 6, MMC_PROFILE_DVD_ROM);
1633 else if (media_is_cd(s))
1634 cpu_to_ube16(buf + 6, MMC_PROFILE_CD_ROM);
38cdea7c 1635
091d055b
AZ		 1636 buf[10] = 0x02 | 0x01; /* persistent and current */
1637 len = 12; /* headers: 8 + 4 */
1638 len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_DVD_ROM);
1639 len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_CD_ROM);
38cdea7c
AZ		 1640 cpu_to_ube32(buf, len - 4); /* data length */
1641
1642 ide_atapi_cmd_reply(s, len, max_len);
d14049ea
TS		 1643 break;
1644 }
5391d806 1645 default:
5fafdf24 1646 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
7f777bf3 1647 ASC_ILLEGAL_OPCODE);
5391d806
FB		 1648 break;
1649 }
1650}
1651
201a51fc
AZ		 1652static void ide_cfata_metadata_inquiry(IDEState *s)
1653{
1654 uint16_t *p;
1655 uint32_t spd;
1656
1657 p = (uint16_t *) s->io_buffer;
1658 memset(p, 0, 0x200);
1659 spd = ((s->mdata_size - 1) >> 9) + 1;
1660
1661 put_le16(p + 0, 0x0001); /* Data format revision */
1662 put_le16(p + 1, 0x0000); /* Media property: silicon */
1663 put_le16(p + 2, s->media_changed); /* Media status */
1664 put_le16(p + 3, s->mdata_size & 0xffff); /* Capacity in bytes (low) */
1665 put_le16(p + 4, s->mdata_size >> 16); /* Capacity in bytes (high) */
1666 put_le16(p + 5, spd & 0xffff); /* Sectors per device (low) */
1667 put_le16(p + 6, spd >> 16); /* Sectors per device (high) */
1668}
1669
1670static void ide_cfata_metadata_read(IDEState *s)
1671{
1672 uint16_t *p;
1673
1674 if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
1675 s->status = ERR_STAT;
1676 s->error = ABRT_ERR;
1677 return;
1678 }
1679
1680 p = (uint16_t *) s->io_buffer;
1681 memset(p, 0, 0x200);
1682
1683 put_le16(p + 0, s->media_changed); /* Media status */
1684 memcpy(p + 1, s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
1685 MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
1686 s->nsector << 9), 0x200 - 2));
1687}
1688
1689static void ide_cfata_metadata_write(IDEState *s)
1690{
1691 if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
1692 s->status = ERR_STAT;
1693 s->error = ABRT_ERR;
1694 return;
1695 }
1696
1697 s->media_changed = 0;
1698
1699 memcpy(s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
1700 s->io_buffer + 2,
1701 MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
1702 s->nsector << 9), 0x200 - 2));
1703}
1704
bd491d6a
TS		 1705/* called when the inserted state of the media has changed */
1706static void cdrom_change_cb(void *opaque)
1707{
1708 IDEState *s = opaque;
96b8f136 1709 uint64_t nb_sectors;
bd491d6a 1710
bd491d6a
TS		 1711 bdrv_get_geometry(s->bs, &nb_sectors);
1712 s->nb_sectors = nb_sectors;
9118e7f0
AL		 1713
1714 s->sense_key = SENSE_UNIT_ATTENTION;
1715 s->asc = ASC_MEDIUM_MAY_HAVE_CHANGED;
93c8cfd9 1716 s->cdrom_changed = 1;
9cdd03a7 1717 ide_set_irq(s->bus);
bd491d6a
TS		 1718}
1719
c2ff060f
FB		 1720static void ide_cmd_lba48_transform(IDEState *s, int lba48)
1721{
1722 s->lba48 = lba48;
1723
1724 /* handle the 'magic' 0 nsector count conversion here. to avoid
1725 * fiddling with the rest of the read logic, we just store the
1726 * full sector count in ->nsector and ignore ->hob_nsector from now
1727 */
1728 if (!s->lba48) {
1729 if (!s->nsector)
1730 s->nsector = 256;
1731 } else {
1732 if (!s->nsector && !s->hob_nsector)
1733 s->nsector = 65536;
1734 else {
1735 int lo = s->nsector;
1736 int hi = s->hob_nsector;
1737
1738 s->nsector = (hi << 8) | lo;
1739 }
1740 }
1741}
1742
bcbdc4d3 1743static void ide_clear_hob(IDEBus *bus)
c2ff060f
FB		 1744{
1745 /* any write clears HOB high bit of device control register */
bcbdc4d3
GH		 1746 bus->ifs[0].select &= ~(1 << 7);
1747 bus->ifs[1].select &= ~(1 << 7);
c2ff060f
FB		 1748}
1749
356721ae 1750void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
caed8802 1751{
bcbdc4d3 1752 IDEBus *bus = opaque;
c45c3d00 1753 IDEState *s;
bcbdc4d3 1754 int n;
c2ff060f 1755 int lba48 = 0;
5391d806
FB		 1756
1757#ifdef DEBUG_IDE
1758 printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
1759#endif
c2ff060f 1760
5391d806 1761 addr &= 7;
fcdd25ab
AL		 1762
1763 /* ignore writes to command block while busy with previous command */
bcbdc4d3 1764 if (addr != 7 && (idebus_active_if(bus)->status & (BUSY_STAT|DRQ_STAT)))
fcdd25ab
AL		 1765 return;
1766
5391d806
FB		 1767 switch(addr) {
1768 case 0:
1769 break;
1770 case 1:
bcbdc4d3 1771 ide_clear_hob(bus);
c45c3d00 1772 /* NOTE: data is written to the two drives */
bcbdc4d3
GH		 1773 bus->ifs[0].hob_feature = bus->ifs[0].feature;
1774 bus->ifs[1].hob_feature = bus->ifs[1].feature;
1775 bus->ifs[0].feature = val;
1776 bus->ifs[1].feature = val;
5391d806
FB		 1777 break;
1778 case 2:
bcbdc4d3
GH		 1779 ide_clear_hob(bus);
1780 bus->ifs[0].hob_nsector = bus->ifs[0].nsector;
1781 bus->ifs[1].hob_nsector = bus->ifs[1].nsector;
1782 bus->ifs[0].nsector = val;
1783 bus->ifs[1].nsector = val;
5391d806
FB		 1784 break;
1785 case 3:
bcbdc4d3
GH		 1786 ide_clear_hob(bus);
1787 bus->ifs[0].hob_sector = bus->ifs[0].sector;
1788 bus->ifs[1].hob_sector = bus->ifs[1].sector;
1789 bus->ifs[0].sector = val;
1790 bus->ifs[1].sector = val;
5391d806
FB		 1791 break;
1792 case 4:
bcbdc4d3
GH		 1793 ide_clear_hob(bus);
1794 bus->ifs[0].hob_lcyl = bus->ifs[0].lcyl;
1795 bus->ifs[1].hob_lcyl = bus->ifs[1].lcyl;
1796 bus->ifs[0].lcyl = val;
1797 bus->ifs[1].lcyl = val;
5391d806
FB		 1798 break;
1799 case 5:
bcbdc4d3
GH		 1800 ide_clear_hob(bus);
1801 bus->ifs[0].hob_hcyl = bus->ifs[0].hcyl;
1802 bus->ifs[1].hob_hcyl = bus->ifs[1].hcyl;
1803 bus->ifs[0].hcyl = val;
1804 bus->ifs[1].hcyl = val;
5391d806
FB		 1805 break;
1806 case 6:
c2ff060f 1807 /* FIXME: HOB readback uses bit 7 */
bcbdc4d3
GH		 1808 bus->ifs[0].select = (val & ~0x10) | 0xa0;
1809 bus->ifs[1].select = (val | 0x10) | 0xa0;
5391d806 1810 /* select drive */
bcbdc4d3 1811 bus->unit = (val >> 4) & 1;
5391d806
FB		 1812 break;
1813 default:
1814 case 7:
1815 /* command */
1816#if defined(DEBUG_IDE)
1817 printf("ide: CMD=%02x\n", val);
1818#endif
bcbdc4d3 1819 s = idebus_active_if(bus);
66201e2d 1820 /* ignore commands to non existant slave */
bcbdc4d3 1821 if (s != bus->ifs && !s->bs)
66201e2d 1822 break;
c2ff060f 1823
fcdd25ab
AL		 1824 /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
1825 if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET)
1826 break;
1827
5391d806
FB		 1828 switch(val) {
1829 case WIN_IDENTIFY:
1830 if (s->bs && !s->is_cdrom) {
201a51fc
AZ		 1831 if (!s->is_cf)
1832 ide_identify(s);
1833 else
1834 ide_cfata_identify(s);
2a282056 1835 s->status = READY_STAT | SEEK_STAT;
5391d806
FB		 1836 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1837 } else {
1838 if (s->is_cdrom) {
1839 ide_set_signature(s);
1840 }
1841 ide_abort_command(s);
1842 }
9cdd03a7 1843 ide_set_irq(s->bus);
5391d806
FB		 1844 break;
1845 case WIN_SPECIFY:
1846 case WIN_RECAL:
a136e5a8 1847 s->error = 0;
769bec72 1848 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 1849 ide_set_irq(s->bus);
5391d806
FB		 1850 break;
1851 case WIN_SETMULT:
201a51fc
AZ		 1852 if (s->is_cf && s->nsector == 0) {
1853 /* Disable Read and Write Multiple */
1854 s->mult_sectors = 0;
41a2b959 1855 s->status = READY_STAT | SEEK_STAT;
201a51fc 1856 } else if ((s->nsector & 0xff) != 0 &&
39dfc926
TS		 1857 ((s->nsector & 0xff) > MAX_MULT_SECTORS ||
1858 (s->nsector & (s->nsector - 1)) != 0)) {
5391d806
FB		 1859 ide_abort_command(s);
1860 } else {
292eef5a 1861 s->mult_sectors = s->nsector & 0xff;
41a2b959 1862 s->status = READY_STAT | SEEK_STAT;
5391d806 1863 }
9cdd03a7 1864 ide_set_irq(s->bus);
5391d806 1865 break;
c2ff060f
FB		 1866 case WIN_VERIFY_EXT:
1867 lba48 = 1;
4ce900b4
FB		 1868 case WIN_VERIFY:
1869 case WIN_VERIFY_ONCE:
1870 /* do sector number check ? */
c2ff060f 1871 ide_cmd_lba48_transform(s, lba48);
41a2b959 1872 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 1873 ide_set_irq(s->bus);
4ce900b4 1874 break;
c2ff060f
FB		 1875 case WIN_READ_EXT:
1876 lba48 = 1;
5391d806
FB		 1877 case WIN_READ:
1878 case WIN_READ_ONCE:
5fafdf24 1879 if (!s->bs)
6b136f9e 1880 goto abort_cmd;
c2ff060f 1881 ide_cmd_lba48_transform(s, lba48);
5391d806
FB		 1882 s->req_nb_sectors = 1;
1883 ide_sector_read(s);
1884 break;
c2ff060f
FB		 1885 case WIN_WRITE_EXT:
1886 lba48 = 1;
5391d806
FB		 1887 case WIN_WRITE:
1888 case WIN_WRITE_ONCE:
201a51fc
AZ		 1889 case CFA_WRITE_SECT_WO_ERASE:
1890 case WIN_WRITE_VERIFY:
c2ff060f 1891 ide_cmd_lba48_transform(s, lba48);
a136e5a8 1892 s->error = 0;
f66723fa 1893 s->status = SEEK_STAT | READY_STAT;
5391d806
FB		 1894 s->req_nb_sectors = 1;
1895 ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
201a51fc 1896 s->media_changed = 1;
5391d806 1897 break;
c2ff060f
FB		 1898 case WIN_MULTREAD_EXT:
1899 lba48 = 1;
5391d806
FB		 1900 case WIN_MULTREAD:
1901 if (!s->mult_sectors)
1902 goto abort_cmd;
c2ff060f 1903 ide_cmd_lba48_transform(s, lba48);
5391d806
FB		 1904 s->req_nb_sectors = s->mult_sectors;
1905 ide_sector_read(s);
1906 break;
c2ff060f
FB		 1907 case WIN_MULTWRITE_EXT:
1908 lba48 = 1;
5391d806 1909 case WIN_MULTWRITE:
201a51fc 1910 case CFA_WRITE_MULTI_WO_ERASE:
5391d806
FB		 1911 if (!s->mult_sectors)
1912 goto abort_cmd;
c2ff060f 1913 ide_cmd_lba48_transform(s, lba48);
a136e5a8 1914 s->error = 0;
f66723fa 1915 s->status = SEEK_STAT | READY_STAT;
5391d806
FB		 1916 s->req_nb_sectors = s->mult_sectors;
1917 n = s->nsector;
1918 if (n > s->req_nb_sectors)
1919 n = s->req_nb_sectors;
1920 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
201a51fc 1921 s->media_changed = 1;
5391d806 1922 break;
c2ff060f
FB		 1923 case WIN_READDMA_EXT:
1924 lba48 = 1;
98087450
FB		 1925 case WIN_READDMA:
1926 case WIN_READDMA_ONCE:
5fafdf24 1927 if (!s->bs)
98087450 1928 goto abort_cmd;
c2ff060f 1929 ide_cmd_lba48_transform(s, lba48);
98087450
FB		 1930 ide_sector_read_dma(s);
1931 break;
c2ff060f
FB		 1932 case WIN_WRITEDMA_EXT:
1933 lba48 = 1;
98087450
FB		 1934 case WIN_WRITEDMA:
1935 case WIN_WRITEDMA_ONCE:
5fafdf24 1936 if (!s->bs)
98087450 1937 goto abort_cmd;
c2ff060f 1938 ide_cmd_lba48_transform(s, lba48);
98087450 1939 ide_sector_write_dma(s);
201a51fc 1940 s->media_changed = 1;
98087450 1941 break;
c2ff060f
FB		 1942 case WIN_READ_NATIVE_MAX_EXT:
1943 lba48 = 1;
5391d806 1944 case WIN_READ_NATIVE_MAX:
c2ff060f 1945 ide_cmd_lba48_transform(s, lba48);
5391d806 1946 ide_set_sector(s, s->nb_sectors - 1);
41a2b959 1947 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 1948 ide_set_irq(s->bus);
5391d806 1949 break;
a136e5a8 1950 case WIN_CHECKPOWERMODE1:
201a51fc 1951 case WIN_CHECKPOWERMODE2:
a136e5a8 1952 s->nsector = 0xff; /* device active or idle */
41a2b959 1953 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 1954 ide_set_irq(s->bus);
a136e5a8 1955 break;
34e538ae
FB		 1956 case WIN_SETFEATURES:
1957 if (!s->bs)
1958 goto abort_cmd;
1959 /* XXX: valid for CDROM ? */
1960 switch(s->feature) {
e1f63470
TS		 1961 case 0xcc: /* reverting to power-on defaults enable */
1962 case 0x66: /* reverting to power-on defaults disable */
34e538ae
FB		 1963 case 0x02: /* write cache enable */
1964 case 0x82: /* write cache disable */
1965 case 0xaa: /* read look-ahead enable */
1966 case 0x55: /* read look-ahead disable */
201a51fc
AZ		 1967 case 0x05: /* set advanced power management mode */
1968 case 0x85: /* disable advanced power management mode */
1969 case 0x69: /* NOP */
1970 case 0x67: /* NOP */
1971 case 0x96: /* NOP */
1972 case 0x9a: /* NOP */
c3e88d8c
TS		 1973 case 0x42: /* enable Automatic Acoustic Mode */
1974 case 0xc2: /* disable Automatic Acoustic Mode */
e0fe67aa 1975 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 1976 ide_set_irq(s->bus);
34e538ae 1977 break;
94458802
FB		 1978 case 0x03: { /* set transfer mode */
1979 uint8_t val = s->nsector & 0x07;
96c35ceb 1980 uint16_t *identify_data = (uint16_t *)s->identify_data;
94458802
FB		 1981
1982 switch (s->nsector >> 3) {
1983 case 0x00: /* pio default */
1984 case 0x01: /* pio mode */
96c35ceb
JQ		 1985 put_le16(identify_data + 62,0x07);
1986 put_le16(identify_data + 63,0x07);
1987 put_le16(identify_data + 88,0x3f);
d1b5c20d
TS		 1988 break;
1989 case 0x02: /* sigle word dma mode*/
96c35ceb
JQ		 1990 put_le16(identify_data + 62,0x07 | (1 << (val + 8)));
1991 put_le16(identify_data + 63,0x07);
1992 put_le16(identify_data + 88,0x3f);
94458802
FB		 1993 break;
1994 case 0x04: /* mdma mode */
96c35ceb
JQ		 1995 put_le16(identify_data + 62,0x07);
1996 put_le16(identify_data + 63,0x07 | (1 << (val + 8)));
1997 put_le16(identify_data + 88,0x3f);
94458802
FB		 1998 break;
1999 case 0x08: /* udma mode */
96c35ceb
JQ		 2000 put_le16(identify_data + 62,0x07);
2001 put_le16(identify_data + 63,0x07);
2002 put_le16(identify_data + 88,0x3f | (1 << (val + 8)));
94458802
FB		 2003 break;
2004 default:
2005 goto abort_cmd;
2006 }
2007 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2008 ide_set_irq(s->bus);
94458802
FB		 2009 break;
2010 }
34e538ae
FB		 2011 default:
2012 goto abort_cmd;
2013 }
2014 break;
c2ff060f
FB		 2015 case WIN_FLUSH_CACHE:
2016 case WIN_FLUSH_CACHE_EXT:
7a6cba61 2017 if (s->bs)
b0484ae4
CH		 2018 bdrv_aio_flush(s->bs, ide_flush_cb, s);
2019 else
2020 ide_flush_cb(s, 0);
7a6cba61 2021 break;
c3e88d8c
TS		 2022 case WIN_STANDBY:
2023 case WIN_STANDBY2:
2024 case WIN_STANDBYNOW1:
201a51fc 2025 case WIN_STANDBYNOW2:
c451ee71 2026 case WIN_IDLEIMMEDIATE:
201a51fc
AZ		 2027 case CFA_IDLEIMMEDIATE:
2028 case WIN_SETIDLE1:
2029 case WIN_SETIDLE2:
c3e88d8c
TS		 2030 case WIN_SLEEPNOW1:
2031 case WIN_SLEEPNOW2:
2032 s->status = READY_STAT;
9cdd03a7 2033 ide_set_irq(s->bus);
a7dfe172 2034 break;
4fbfcd6d
AJ		 2035 case WIN_SEEK:
2036 if(s->is_cdrom)
2037 goto abort_cmd;
2038 /* XXX: Check that seek is within bounds */
2039 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2040 ide_set_irq(s->bus);
4fbfcd6d 2041 break;
5391d806
FB		 2042 /* ATAPI commands */
2043 case WIN_PIDENTIFY:
2044 if (s->is_cdrom) {
2045 ide_atapi_identify(s);
1298fe63 2046 s->status = READY_STAT | SEEK_STAT;
5391d806
FB		 2047 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
2048 } else {
2049 ide_abort_command(s);
2050 }
9cdd03a7 2051 ide_set_irq(s->bus);
5391d806 2052 break;
c451ee71
FB		 2053 case WIN_DIAGNOSE:
2054 ide_set_signature(s);
33256a25
AL		 2055 if (s->is_cdrom)
2056 s->status = 0; /* ATAPI spec (v6) section 9.10 defines packet
2057 * devices to return a clear status register
2058 * with READY_STAT *not* set. */
2059 else
2060 s->status = READY_STAT | SEEK_STAT;
2061 s->error = 0x01; /* Device 0 passed, Device 1 passed or not
2062 * present.
2063 */
9cdd03a7 2064 ide_set_irq(s->bus);
c451ee71 2065 break;
5391d806
FB		 2066 case WIN_SRST:
2067 if (!s->is_cdrom)
2068 goto abort_cmd;
2069 ide_set_signature(s);
6b136f9e 2070 s->status = 0x00; /* NOTE: READY is _not_ set */
5391d806
FB		 2071 s->error = 0x01;
2072 break;
2073 case WIN_PACKETCMD:
2074 if (!s->is_cdrom)
2075 goto abort_cmd;
98087450
FB		 2076 /* overlapping commands not supported */
2077 if (s->feature & 0x02)
5391d806 2078 goto abort_cmd;
41a2b959 2079 s->status = READY_STAT | SEEK_STAT;
98087450 2080 s->atapi_dma = s->feature & 1;
5391d806 2081 s->nsector = 1;
5fafdf24 2082 ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
5391d806
FB		 2083 ide_atapi_cmd);
2084 break;
201a51fc
AZ		 2085 /* CF-ATA commands */
2086 case CFA_REQ_EXT_ERROR_CODE:
2087 if (!s->is_cf)
2088 goto abort_cmd;
2089 s->error = 0x09; /* miscellaneous error */
41a2b959 2090 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2091 ide_set_irq(s->bus);
201a51fc
AZ		 2092 break;
2093 case CFA_ERASE_SECTORS:
2094 case CFA_WEAR_LEVEL:
2095 if (!s->is_cf)
2096 goto abort_cmd;
2097 if (val == CFA_WEAR_LEVEL)
2098 s->nsector = 0;
2099 if (val == CFA_ERASE_SECTORS)
2100 s->media_changed = 1;
2101 s->error = 0x00;
41a2b959 2102 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2103 ide_set_irq(s->bus);
201a51fc
AZ		 2104 break;
2105 case CFA_TRANSLATE_SECTOR:
2106 if (!s->is_cf)
2107 goto abort_cmd;
2108 s->error = 0x00;
41a2b959 2109 s->status = READY_STAT | SEEK_STAT;
201a51fc
AZ		 2110 memset(s->io_buffer, 0, 0x200);
2111 s->io_buffer[0x00] = s->hcyl; /* Cyl MSB */
2112 s->io_buffer[0x01] = s->lcyl; /* Cyl LSB */
2113 s->io_buffer[0x02] = s->select; /* Head */
2114 s->io_buffer[0x03] = s->sector; /* Sector */
2115 s->io_buffer[0x04] = ide_get_sector(s) >> 16; /* LBA MSB */
2116 s->io_buffer[0x05] = ide_get_sector(s) >> 8; /* LBA */
2117 s->io_buffer[0x06] = ide_get_sector(s) >> 0; /* LBA LSB */
2118 s->io_buffer[0x13] = 0x00; /* Erase flag */
2119 s->io_buffer[0x18] = 0x00; /* Hot count */
2120 s->io_buffer[0x19] = 0x00; /* Hot count */
2121 s->io_buffer[0x1a] = 0x01; /* Hot count */
2122 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
9cdd03a7 2123 ide_set_irq(s->bus);
201a51fc
AZ		 2124 break;
2125 case CFA_ACCESS_METADATA_STORAGE:
2126 if (!s->is_cf)
2127 goto abort_cmd;
2128 switch (s->feature) {
2129 case 0x02: /* Inquiry Metadata Storage */
2130 ide_cfata_metadata_inquiry(s);
2131 break;
2132 case 0x03: /* Read Metadata Storage */
2133 ide_cfata_metadata_read(s);
2134 break;
2135 case 0x04: /* Write Metadata Storage */
2136 ide_cfata_metadata_write(s);
2137 break;
2138 default:
2139 goto abort_cmd;
2140 }
2141 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2142 s->status = 0x00; /* NOTE: READY is _not_ set */
9cdd03a7 2143 ide_set_irq(s->bus);
201a51fc
AZ		 2144 break;
2145 case IBM_SENSE_CONDITION:
2146 if (!s->is_cf)
2147 goto abort_cmd;
2148 switch (s->feature) {
2149 case 0x01: /* sense temperature in device */
2150 s->nsector = 0x50; /* +20 C */
2151 break;
2152 default:
2153 goto abort_cmd;
2154 }
41a2b959 2155 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2156 ide_set_irq(s->bus);
201a51fc 2157 break;
e8b54394
BW		 2158
2159 case WIN_SMART:
2160 if (s->is_cdrom)
2161 goto abort_cmd;
2162 if (s->hcyl != 0xc2 || s->lcyl != 0x4f)
2163 goto abort_cmd;
2164 if (!s->smart_enabled && s->feature != SMART_ENABLE)
2165 goto abort_cmd;
2166 switch (s->feature) {
2167 case SMART_DISABLE:
2168 s->smart_enabled = 0;
2169 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2170 ide_set_irq(s->bus);
e8b54394
BW		 2171 break;
2172 case SMART_ENABLE:
2173 s->smart_enabled = 1;
2174 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2175 ide_set_irq(s->bus);
e8b54394
BW		 2176 break;
2177 case SMART_ATTR_AUTOSAVE:
2178 switch (s->sector) {
2179 case 0x00:
2180 s->smart_autosave = 0;
2181 break;
2182 case 0xf1:
2183 s->smart_autosave = 1;
2184 break;
2185 default:
2186 goto abort_cmd;
2187 }
2188 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2189 ide_set_irq(s->bus);
e8b54394
BW		 2190 break;
2191 case SMART_STATUS:
2192 if (!s->smart_errors) {
2193 s->hcyl = 0xc2;
2194 s->lcyl = 0x4f;
2195 } else {
2196 s->hcyl = 0x2c;
2197 s->lcyl = 0xf4;
2198 }
2199 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2200 ide_set_irq(s->bus);
e8b54394
BW		 2201 break;
2202 case SMART_READ_THRESH:
2203 memset(s->io_buffer, 0, 0x200);
2204 s->io_buffer[0] = 0x01; /* smart struct version */
2205 for (n=0; n<30; n++) {
2206 if (smart_attributes[n][0] == 0)
2207 break;
2208 s->io_buffer[2+0+(n*12)] = smart_attributes[n][0];
2209 s->io_buffer[2+1+(n*12)] = smart_attributes[n][4];
2210 }
2211 for (n=0; n<511; n++) /* checksum */
2212 s->io_buffer[511] += s->io_buffer[n];
2213 s->io_buffer[511] = 0x100 - s->io_buffer[511];
2214 s->status = READY_STAT | SEEK_STAT;
2215 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
9cdd03a7 2216 ide_set_irq(s->bus);
e8b54394
BW		 2217 break;
2218 case SMART_READ_DATA:
2219 memset(s->io_buffer, 0, 0x200);
2220 s->io_buffer[0] = 0x01; /* smart struct version */
2221 for (n=0; n<30; n++) {
2222 if (smart_attributes[n][0] == 0)
2223 break;
2224 s->io_buffer[2+0+(n*12)] = smart_attributes[n][0];
2225 s->io_buffer[2+1+(n*12)] = smart_attributes[n][1];
2226 s->io_buffer[2+3+(n*12)] = smart_attributes[n][2];
2227 s->io_buffer[2+4+(n*12)] = smart_attributes[n][3];
2228 }
2229 s->io_buffer[362] = 0x02 | (s->smart_autosave?0x80:0x00);
2230 if (s->smart_selftest_count == 0) {
2231 s->io_buffer[363] = 0;
2232 } else {
2233 s->io_buffer[363] =
2234 s->smart_selftest_data[3 +
2235 (s->smart_selftest_count - 1) *
2236 24];
2237 }
2238 s->io_buffer[364] = 0x20;
2239 s->io_buffer[365] = 0x01;
2240 /* offline data collection capacity: execute + self-test*/
2241 s->io_buffer[367] = (1<<4 | 1<<3 | 1);
2242 s->io_buffer[368] = 0x03; /* smart capability (1) */
2243 s->io_buffer[369] = 0x00; /* smart capability (2) */
2244 s->io_buffer[370] = 0x01; /* error logging supported */
2245 s->io_buffer[372] = 0x02; /* minutes for poll short test */
2246 s->io_buffer[373] = 0x36; /* minutes for poll ext test */
2247 s->io_buffer[374] = 0x01; /* minutes for poll conveyance */
2248
2249 for (n=0; n<511; n++)
2250 s->io_buffer[511] += s->io_buffer[n];
2251 s->io_buffer[511] = 0x100 - s->io_buffer[511];
2252 s->status = READY_STAT | SEEK_STAT;
2253 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
9cdd03a7 2254 ide_set_irq(s->bus);
e8b54394
BW		 2255 break;
2256 case SMART_READ_LOG:
2257 switch (s->sector) {
2258 case 0x01: /* summary smart error log */
2259 memset(s->io_buffer, 0, 0x200);
2260 s->io_buffer[0] = 0x01;
2261 s->io_buffer[1] = 0x00; /* no error entries */
2262 s->io_buffer[452] = s->smart_errors & 0xff;
2263 s->io_buffer[453] = (s->smart_errors & 0xff00) >> 8;
2264
2265 for (n=0; n<511; n++)
2266 s->io_buffer[511] += s->io_buffer[n];
2267 s->io_buffer[511] = 0x100 - s->io_buffer[511];
2268 break;
2269 case 0x06: /* smart self test log */
2270 memset(s->io_buffer, 0, 0x200);
2271 s->io_buffer[0] = 0x01;
2272 if (s->smart_selftest_count == 0) {
2273 s->io_buffer[508] = 0;
2274 } else {
2275 s->io_buffer[508] = s->smart_selftest_count;
2276 for (n=2; n<506; n++)
2277 s->io_buffer[n] = s->smart_selftest_data[n];
2278 }
2279 for (n=0; n<511; n++)
2280 s->io_buffer[511] += s->io_buffer[n];
2281 s->io_buffer[511] = 0x100 - s->io_buffer[511];
2282 break;
2283 default:
2284 goto abort_cmd;
2285 }
2286 s->status = READY_STAT | SEEK_STAT;
2287 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
9cdd03a7 2288 ide_set_irq(s->bus);
e8b54394
BW		 2289 break;
2290 case SMART_EXECUTE_OFFLINE:
2291 switch (s->sector) {
2292 case 0: /* off-line routine */
2293 case 1: /* short self test */
2294 case 2: /* extended self test */
2295 s->smart_selftest_count++;
2296 if(s->smart_selftest_count > 21)
2297 s->smart_selftest_count = 0;
2298 n = 2 + (s->smart_selftest_count - 1) * 24;
2299 s->smart_selftest_data[n] = s->sector;
2300 s->smart_selftest_data[n+1] = 0x00; /* OK and finished */
2301 s->smart_selftest_data[n+2] = 0x34; /* hour count lsb */
2302 s->smart_selftest_data[n+3] = 0x12; /* hour count msb */
2303 s->status = READY_STAT | SEEK_STAT;
9cdd03a7 2304 ide_set_irq(s->bus);
e8b54394
BW		 2305 break;
2306 default:
2307 goto abort_cmd;
2308 }
2309 break;
2310 default:
2311 goto abort_cmd;
2312 }
2313 break;
5391d806
FB		 2314 default:
2315 abort_cmd:
2316 ide_abort_command(s);
9cdd03a7 2317 ide_set_irq(s->bus);
5391d806
FB		 2318 break;
2319 }
2320 }
2321}
2322
356721ae 2323uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
5391d806 2324{
bcbdc4d3
GH		 2325 IDEBus *bus = opaque;
2326 IDEState *s = idebus_active_if(bus);
5391d806 2327 uint32_t addr;
c2ff060f 2328 int ret, hob;
5391d806
FB		 2329
2330 addr = addr1 & 7;
c2ff060f
FB		 2331 /* FIXME: HOB readback uses bit 7, but it's always set right now */
2332 //hob = s->select & (1 << 7);
2333 hob = 0;
5391d806
FB		 2334 switch(addr) {
2335 case 0:
2336 ret = 0xff;
2337 break;
2338 case 1:
bcbdc4d3
GH		 2339 if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
2340 (s != bus->ifs && !s->bs))
c45c3d00 2341 ret = 0;
c2ff060f 2342 else if (!hob)
c45c3d00 2343 ret = s->error;
c2ff060f
FB		 2344 else
2345 ret = s->hob_feature;
5391d806
FB		 2346 break;
2347 case 2:
bcbdc4d3 2348 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
c45c3d00 2349 ret = 0;
c2ff060f 2350 else if (!hob)
c45c3d00 2351 ret = s->nsector & 0xff;
c2ff060f
FB		 2352 else
2353 ret = s->hob_nsector;
5391d806
FB		 2354 break;
2355 case 3:
bcbdc4d3 2356 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
c45c3d00 2357 ret = 0;
c2ff060f 2358 else if (!hob)
c45c3d00 2359 ret = s->sector;
c2ff060f
FB		 2360 else
2361 ret = s->hob_sector;
5391d806
FB		 2362 break;
2363 case 4:
bcbdc4d3 2364 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
c45c3d00 2365 ret = 0;
c2ff060f 2366 else if (!hob)
c45c3d00 2367 ret = s->lcyl;
c2ff060f
FB		 2368 else
2369 ret = s->hob_lcyl;
5391d806
FB		 2370 break;
2371 case 5:
bcbdc4d3 2372 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
c45c3d00 2373 ret = 0;
c2ff060f 2374 else if (!hob)
c45c3d00 2375 ret = s->hcyl;
c2ff060f
FB		 2376 else
2377 ret = s->hob_hcyl;
5391d806
FB		 2378 break;
2379 case 6:
bcbdc4d3 2380 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
c45c3d00
FB		 2381 ret = 0;
2382 else
7ae98627 2383 ret = s->select;
5391d806
FB		 2384 break;
2385 default:
2386 case 7:
bcbdc4d3
GH		 2387 if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
2388 (s != bus->ifs && !s->bs))
c45c3d00
FB		 2389 ret = 0;
2390 else
2391 ret = s->status;
9cdd03a7 2392 qemu_irq_lower(bus->irq);
5391d806
FB		 2393 break;
2394 }
2395#ifdef DEBUG_IDE
2396 printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
2397#endif
2398 return ret;
2399}
2400
356721ae 2401uint32_t ide_status_read(void *opaque, uint32_t addr)
5391d806 2402{
bcbdc4d3
GH		 2403 IDEBus *bus = opaque;
2404 IDEState *s = idebus_active_if(bus);
5391d806 2405 int ret;
7ae98627 2406
bcbdc4d3
GH		 2407 if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
2408 (s != bus->ifs && !s->bs))
7ae98627
FB		 2409 ret = 0;
2410 else
2411 ret = s->status;
5391d806
FB		 2412#ifdef DEBUG_IDE
2413 printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
2414#endif
2415 return ret;
2416}
2417
356721ae 2418void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
5391d806 2419{
bcbdc4d3 2420 IDEBus *bus = opaque;
5391d806
FB		 2421 IDEState *s;
2422 int i;
2423
2424#ifdef DEBUG_IDE
2425 printf("ide: write control addr=0x%x val=%02x\n", addr, val);
2426#endif
2427 /* common for both drives */
9cdd03a7 2428 if (!(bus->cmd & IDE_CMD_RESET) &&
5391d806
FB		 2429 (val & IDE_CMD_RESET)) {
2430 /* reset low to high */
2431 for(i = 0;i < 2; i++) {
bcbdc4d3 2432 s = &bus->ifs[i];
5391d806
FB		 2433 s->status = BUSY_STAT | SEEK_STAT;
2434 s->error = 0x01;
2435 }
9cdd03a7 2436 } else if ((bus->cmd & IDE_CMD_RESET) &&
5391d806
FB		 2437 !(val & IDE_CMD_RESET)) {
2438 /* high to low */
2439 for(i = 0;i < 2; i++) {
bcbdc4d3 2440 s = &bus->ifs[i];
6b136f9e
FB		 2441 if (s->is_cdrom)
2442 s->status = 0x00; /* NOTE: READY is _not_ set */
2443 else
56bf1d37 2444 s->status = READY_STAT | SEEK_STAT;
5391d806
FB		 2445 ide_set_signature(s);
2446 }
2447 }
2448
9cdd03a7 2449 bus->cmd = val;
5391d806
FB		 2450}
2451
356721ae 2452void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
5391d806 2453{
bcbdc4d3
GH		 2454 IDEBus *bus = opaque;
2455 IDEState *s = idebus_active_if(bus);
5391d806
FB		 2456 uint8_t *p;
2457
fcdd25ab
AL		 2458 /* PIO data access allowed only when DRQ bit is set */
2459 if (!(s->status & DRQ_STAT))
2460 return;
2461
5391d806 2462 p = s->data_ptr;
0c4ad8dc 2463 *(uint16_t *)p = le16_to_cpu(val);
5391d806
FB		 2464 p += 2;
2465 s->data_ptr = p;
2466 if (p >= s->data_end)
2467 s->end_transfer_func(s);
2468}
2469
356721ae 2470uint32_t ide_data_readw(void *opaque, uint32_t addr)
5391d806 2471{
bcbdc4d3
GH		 2472 IDEBus *bus = opaque;
2473 IDEState *s = idebus_active_if(bus);
5391d806
FB		 2474 uint8_t *p;
2475 int ret;
fcdd25ab
AL		 2476
2477 /* PIO data access allowed only when DRQ bit is set */
2478 if (!(s->status & DRQ_STAT))
2479 return 0;
2480
5391d806 2481 p = s->data_ptr;
0c4ad8dc 2482 ret = cpu_to_le16(*(uint16_t *)p);
5391d806
FB		 2483 p += 2;
2484 s->data_ptr = p;
2485 if (p >= s->data_end)
2486 s->end_transfer_func(s);
2487 return ret;
2488}
2489
356721ae 2490void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
5391d806 2491{
bcbdc4d3
GH		 2492 IDEBus *bus = opaque;
2493 IDEState *s = idebus_active_if(bus);
5391d806
FB		 2494 uint8_t *p;
2495
fcdd25ab
AL		 2496 /* PIO data access allowed only when DRQ bit is set */
2497 if (!(s->status & DRQ_STAT))
2498 return;
2499
5391d806 2500 p = s->data_ptr;
0c4ad8dc 2501 *(uint32_t *)p = le32_to_cpu(val);
5391d806
FB		 2502 p += 4;
2503 s->data_ptr = p;
2504 if (p >= s->data_end)
2505 s->end_transfer_func(s);
2506}
2507
356721ae 2508uint32_t ide_data_readl(void *opaque, uint32_t addr)
5391d806 2509{
bcbdc4d3
GH		 2510 IDEBus *bus = opaque;
2511 IDEState *s = idebus_active_if(bus);
5391d806
FB		 2512 uint8_t *p;
2513 int ret;
3b46e624 2514
fcdd25ab
AL		 2515 /* PIO data access allowed only when DRQ bit is set */
2516 if (!(s->status & DRQ_STAT))
2517 return 0;
2518
5391d806 2519 p = s->data_ptr;
0c4ad8dc 2520 ret = cpu_to_le32(*(uint32_t *)p);
5391d806
FB		 2521 p += 4;
2522 s->data_ptr = p;
2523 if (p >= s->data_end)
2524 s->end_transfer_func(s);
2525 return ret;
2526}
2527
a7dfe172
FB		 2528static void ide_dummy_transfer_stop(IDEState *s)
2529{
2530 s->data_ptr = s->io_buffer;
2531 s->data_end = s->io_buffer;
2532 s->io_buffer[0] = 0xff;
2533 s->io_buffer[1] = 0xff;
2534 s->io_buffer[2] = 0xff;
2535 s->io_buffer[3] = 0xff;
2536}
2537
4a643563 2538static void ide_reset(IDEState *s)
5391d806 2539{
4a643563
BS		 2540#ifdef DEBUG_IDE
2541 printf("ide: reset\n");
2542#endif
201a51fc
AZ		 2543 if (s->is_cf)
2544 s->mult_sectors = 0;
2545 else
2546 s->mult_sectors = MAX_MULT_SECTORS;
4a643563
BS		 2547 /* ide regs */
2548 s->feature = 0;
2549 s->error = 0;
2550 s->nsector = 0;
2551 s->sector = 0;
2552 s->lcyl = 0;
2553 s->hcyl = 0;
2554
2555 /* lba48 */
2556 s->hob_feature = 0;
2557 s->hob_sector = 0;
2558 s->hob_nsector = 0;
2559 s->hob_lcyl = 0;
2560 s->hob_hcyl = 0;
2561
5391d806 2562 s->select = 0xa0;
41a2b959 2563 s->status = READY_STAT | SEEK_STAT;
4a643563
BS		 2564
2565 s->lba48 = 0;
2566
2567 /* ATAPI specific */
2568 s->sense_key = 0;
2569 s->asc = 0;
2570 s->cdrom_changed = 0;
2571 s->packet_transfer_size = 0;
2572 s->elementary_transfer_size = 0;
2573 s->io_buffer_index = 0;
2574 s->cd_sector_size = 0;
2575 s->atapi_dma = 0;
2576 /* ATA DMA state */
2577 s->io_buffer_size = 0;
2578 s->req_nb_sectors = 0;
2579
5391d806 2580 ide_set_signature(s);
a7dfe172
FB		 2581 /* init the transfer handler so that 0xffff is returned on data
2582 accesses */
2583 s->end_transfer_func = ide_dummy_transfer_stop;
2584 ide_dummy_transfer_stop(s);
201a51fc 2585 s->media_changed = 0;
5391d806
FB		 2586}
2587
4a643563
BS		 2588void ide_bus_reset(IDEBus *bus)
2589{
2590 bus->unit = 0;
2591 bus->cmd = 0;
2592 ide_reset(&bus->ifs[0]);
2593 ide_reset(&bus->ifs[1]);
2594 ide_clear_hob(bus);
2595}
2596
f8b6cc00 2597void ide_init_drive(IDEState *s, BlockDriverState *bs,
6ced55a5 2598 const char *version, const char *serial)
88804180
GH		 2599{
2600 int cylinders, heads, secs;
2601 uint64_t nb_sectors;
2602
f8b6cc00
MA		 2603 s->bs = bs;
2604 bdrv_get_geometry(bs, &nb_sectors);
2605 bdrv_guess_geometry(bs, &cylinders, &heads, &secs);
870111c8
MA		 2606 s->cylinders = cylinders;
2607 s->heads = heads;
2608 s->sectors = secs;
2609 s->nb_sectors = nb_sectors;
2610 /* The SMART values should be preserved across power cycles
2611 but they aren't. */
2612 s->smart_enabled = 1;
2613 s->smart_autosave = 1;
2614 s->smart_errors = 0;
2615 s->smart_selftest_count = 0;
f8b6cc00 2616 if (bdrv_get_type_hint(bs) == BDRV_TYPE_CDROM) {
870111c8 2617 s->is_cdrom = 1;
f8b6cc00 2618 bdrv_set_change_cb(bs, cdrom_change_cb, s);
88804180 2619 }
f8b6cc00 2620 if (serial) {
6ced55a5
MA		 2621 strncpy(s->drive_serial_str, serial, sizeof(s->drive_serial_str));
2622 } else {
88804180
GH		 2623 snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),
2624 "QM%05d", s->drive_serial);
870111c8 2625 }
47c06340
GH		 2626 if (version) {
2627 pstrcpy(s->version, sizeof(s->version), version);
2628 } else {
2629 pstrcpy(s->version, sizeof(s->version), QEMU_VERSION);
2630 }
88804180 2631 ide_reset(s);
7d0d6950 2632 bdrv_set_removable(bs, s->is_cdrom);
88804180
GH		 2633}
2634
57234ee4 2635static void ide_init1(IDEBus *bus, int unit)
d459da0e
MA		 2636{
2637 static int drive_serial = 1;
2638 IDEState *s = &bus->ifs[unit];
2639
2640 s->bus = bus;
2641 s->unit = unit;
2642 s->drive_serial = drive_serial++;
2643 s->io_buffer = qemu_blockalign(s->bs, IDE_DMA_BUF_SECTORS*512 + 4);
2644 s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
2645 s->smart_selftest_data = qemu_blockalign(s->bs, 512);
2646 s->sector_write_timer = qemu_new_timer(vm_clock,
2647 ide_sector_write_timer_cb, s);
57234ee4
MA		 2648}
2649
2650void ide_init2(IDEBus *bus, qemu_irq irq)
2651{
2652 int i;
2653
2654 for(i = 0; i < 2; i++) {
2655 ide_init1(bus, i);
2656 ide_reset(&bus->ifs[i]);
870111c8 2657 }
57234ee4 2658 bus->irq = irq;
d459da0e
MA		 2659}
2660
57234ee4
MA		 2661/* TODO convert users to qdev and remove */
2662void ide_init2_with_non_qdev_drives(IDEBus *bus, DriveInfo *hd0,
2663 DriveInfo *hd1, qemu_irq irq)
5391d806 2664{
88804180 2665 int i;
57234ee4 2666 DriveInfo *dinfo;
5391d806 2667
caed8802 2668 for(i = 0; i < 2; i++) {
57234ee4
MA		 2669 dinfo = i == 0 ? hd0 : hd1;
2670 ide_init1(bus, i);
2671 if (dinfo) {
f8b6cc00
MA		 2672 ide_init_drive(&bus->ifs[i], dinfo->bdrv, NULL,
2673 *dinfo->serial ? dinfo->serial : NULL);
57234ee4
MA		 2674 } else {
2675 ide_reset(&bus->ifs[i]);
2676 }
5391d806 2677 }
9cdd03a7 2678 bus->irq = irq;
69b91039
FB		 2679}
2680
356721ae 2681void ide_init_ioport(IDEBus *bus, int iobase, int iobase2)
69b91039 2682{
bcbdc4d3
GH		 2683 register_ioport_write(iobase, 8, 1, ide_ioport_write, bus);
2684 register_ioport_read(iobase, 8, 1, ide_ioport_read, bus);
caed8802 2685 if (iobase2) {
bcbdc4d3
GH		 2686 register_ioport_read(iobase2, 1, 1, ide_status_read, bus);
2687 register_ioport_write(iobase2, 1, 1, ide_cmd_write, bus);
5391d806 2688 }
3b46e624 2689
caed8802 2690 /* data ports */
bcbdc4d3
GH		 2691 register_ioport_write(iobase, 2, 2, ide_data_writew, bus);
2692 register_ioport_read(iobase, 2, 2, ide_data_readw, bus);
2693 register_ioport_write(iobase, 4, 4, ide_data_writel, bus);
2694 register_ioport_read(iobase, 4, 4, ide_data_readl, bus);
5391d806 2695}
69b91039 2696
37159f13 2697static bool is_identify_set(void *opaque, int version_id)
aa941b94 2698{
37159f13
JQ		 2699 IDEState *s = opaque;
2700
2701 return s->identify_set != 0;
2702}
2703
ed487bb1
MT		 2704static EndTransferFunc* transfer_end_table[] = {
2705 ide_sector_read,
2706 ide_sector_write,
2707 ide_transfer_stop,
2708 ide_atapi_cmd_reply_end,
2709 ide_atapi_cmd,
2710};
2711
2712static int transfer_end_table_idx(EndTransferFunc *fn)
2713{
2714 int i;
2715
2716 for (i = 0; i < ARRAY_SIZE(transfer_end_table); i++)
2717 if (transfer_end_table[i] == fn)
2718 return i;
2719
2720 return -1;
2721}
2722
37159f13 2723static int ide_drive_post_load(void *opaque, int version_id)
aa941b94 2724{
37159f13
JQ		 2725 IDEState *s = opaque;
2726
2727 if (version_id < 3) {
93c8cfd9 2728 if (s->sense_key == SENSE_UNIT_ATTENTION &&
37159f13 2729 s->asc == ASC_MEDIUM_MAY_HAVE_CHANGED) {
93c8cfd9 2730 s->cdrom_changed = 1;
37159f13 2731 }
93c8cfd9 2732 }
ed487bb1
MT		 2733
2734 if (s->cur_io_buffer_len) {
2735 s->end_transfer_func = transfer_end_table[s->end_transfer_fn_idx];
2736 s->data_ptr = s->io_buffer + s->cur_io_buffer_offset;
2737 s->data_end = s->data_ptr + s->cur_io_buffer_len;
2738 }
2739
37159f13 2740 return 0;
aa941b94
AZ		 2741}
2742
ed487bb1
MT		 2743static void ide_drive_pre_save(void *opaque)
2744{
2745 IDEState *s = opaque;
4fc8d671 2746 int idx;
ed487bb1
MT		 2747
2748 s->cur_io_buffer_len = 0;
2749
2750 if (!(s->status & DRQ_STAT))
2751 return;
2752
2753 s->cur_io_buffer_offset = s->data_ptr - s->io_buffer;
2754 s->cur_io_buffer_len = s->data_end - s->data_ptr;
2755
4fc8d671
BS		 2756 idx = transfer_end_table_idx(s->end_transfer_func);
2757 if (idx == -1) {
ed487bb1
MT		 2758 fprintf(stderr, "%s: invalid end_transfer_func for DRQ_STAT\n",
2759 __func__);
2760 s->end_transfer_fn_idx = 2;
4fc8d671
BS		 2761 } else {
2762 s->end_transfer_fn_idx = idx;
ed487bb1
MT		 2763 }
2764}
2765
37159f13
JQ		 2766const VMStateDescription vmstate_ide_drive = {
2767 .name = "ide_drive",
ed487bb1 2768 .version_id = 4,
37159f13
JQ		 2769 .minimum_version_id = 0,
2770 .minimum_version_id_old = 0,
ed487bb1 2771 .pre_save = ide_drive_pre_save,
37159f13
JQ		 2772 .post_load = ide_drive_post_load,
2773 .fields = (VMStateField []) {
2774 VMSTATE_INT32(mult_sectors, IDEState),
2775 VMSTATE_INT32(identify_set, IDEState),
2776 VMSTATE_BUFFER_TEST(identify_data, IDEState, is_identify_set),
2777 VMSTATE_UINT8(feature, IDEState),
2778 VMSTATE_UINT8(error, IDEState),
2779 VMSTATE_UINT32(nsector, IDEState),
2780 VMSTATE_UINT8(sector, IDEState),
2781 VMSTATE_UINT8(lcyl, IDEState),
2782 VMSTATE_UINT8(hcyl, IDEState),
2783 VMSTATE_UINT8(hob_feature, IDEState),
2784 VMSTATE_UINT8(hob_sector, IDEState),
2785 VMSTATE_UINT8(hob_nsector, IDEState),
2786 VMSTATE_UINT8(hob_lcyl, IDEState),
2787 VMSTATE_UINT8(hob_hcyl, IDEState),
2788 VMSTATE_UINT8(select, IDEState),
2789 VMSTATE_UINT8(status, IDEState),
2790 VMSTATE_UINT8(lba48, IDEState),
2791 VMSTATE_UINT8(sense_key, IDEState),
2792 VMSTATE_UINT8(asc, IDEState),
2793 VMSTATE_UINT8_V(cdrom_changed, IDEState, 3),
ed487bb1
MT		 2794 VMSTATE_INT32_V(req_nb_sectors, IDEState, 4),
2795 VMSTATE_VARRAY_INT32(io_buffer, IDEState, io_buffer_total_len, 4,
2796 vmstate_info_uint8, uint8_t),
2797 VMSTATE_INT32_V(cur_io_buffer_offset, IDEState, 4),
2798 VMSTATE_INT32_V(cur_io_buffer_len, IDEState, 4),
2799 VMSTATE_UINT8_V(end_transfer_fn_idx, IDEState, 4),
2800 VMSTATE_INT32_V(elementary_transfer_size, IDEState, 4),
2801 VMSTATE_INT32_V(packet_transfer_size, IDEState, 4),
37159f13
JQ		 2802 VMSTATE_END_OF_LIST()
2803 }
2804};
2805
6521dc62
JQ		 2806const VMStateDescription vmstate_ide_bus = {
2807 .name = "ide_bus",
2808 .version_id = 1,
2809 .minimum_version_id = 1,
2810 .minimum_version_id_old = 1,
2811 .fields = (VMStateField []) {
2812 VMSTATE_UINT8(cmd, IDEBus),
2813 VMSTATE_UINT8(unit, IDEBus),
2814 VMSTATE_END_OF_LIST()
2815 }
2816};
2817
69b91039
FB		 2818/***********************************************************/
2819/* PCI IDE definitions */
2820
8ccad811 2821static void ide_dma_start(IDEState *s, BlockDriverCompletionFunc *dma_cb)
98087450 2822{
bcbdc4d3 2823 BMDMAState *bm = s->bus->bmdma;
98087450
FB		 2824 if(!bm)
2825 return;
bcbdc4d3 2826 bm->unit = s->unit;
98087450 2827 bm->dma_cb = dma_cb;
8ccad811
FB		 2828 bm->cur_prd_last = 0;
2829 bm->cur_prd_addr = 0;
2830 bm->cur_prd_len = 0;
428c5705
AL		 2831 bm->sector_num = ide_get_sector(s);
2832 bm->nsector = s->nsector;
98087450 2833 if (bm->status & BM_STATUS_DMAING) {
8ccad811 2834 bm->dma_cb(bm, 0);
98087450
FB		 2835 }
2836}
2837
ce4b6522 2838static void ide_dma_restart(IDEState *s, int is_read)
428c5705 2839{
bcbdc4d3 2840 BMDMAState *bm = s->bus->bmdma;
428c5705
AL		 2841 ide_set_sector(s, bm->sector_num);
2842 s->io_buffer_index = 0;
2843 s->io_buffer_size = 0;
2844 s->nsector = bm->nsector;
2845 bm->cur_addr = bm->addr;
ce4b6522
KW		 2846
2847 if (is_read) {
2848 bm->dma_cb = ide_read_dma_cb;
2849 } else {
2850 bm->dma_cb = ide_write_dma_cb;
2851 }
2852
428c5705
AL		 2853 ide_dma_start(s, bm->dma_cb);
2854}
2855
356721ae 2856void ide_dma_cancel(BMDMAState *bm)
72c7b06c
AL		 2857{
2858 if (bm->status & BM_STATUS_DMAING) {
72c7b06c
AL		 2859 if (bm->aiocb) {
2860#ifdef DEBUG_AIO
2861 printf("aio_cancel\n");
2862#endif
2863 bdrv_aio_cancel(bm->aiocb);
2864 bm->aiocb = NULL;
2865 }
38d8dfa1
KW		 2866 bm->status &= ~BM_STATUS_DMAING;
2867 /* cancel DMA request */
2868 bm->unit = -1;
2869 bm->dma_cb = NULL;
72c7b06c
AL		 2870 }
2871}
2872
4a643563
BS		 2873void ide_dma_reset(BMDMAState *bm)
2874{
2875#ifdef DEBUG_IDE
2876 printf("ide: dma_reset\n");
2877#endif
2878 ide_dma_cancel(bm);
2879 bm->cmd = 0;
2880 bm->status = 0;
2881 bm->addr = 0;
2882 bm->cur_addr = 0;
2883 bm->cur_prd_last = 0;
2884 bm->cur_prd_addr = 0;
2885 bm->cur_prd_len = 0;
2886 bm->sector_num = 0;
2887 bm->nsector = 0;
2888}
Qemu copy for testing