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