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