?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ide: Reject ATA commands specific to drive kinds
[qemu.git] / hw / ide / core.c
blobb33f84e1afc7af842041c16cbea34859609352b1
1 /*
2 * QEMU IDE disk and CD/DVD-ROM Emulator
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 * Copyright (c) 2006 Openedhand Ltd.
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a copy
8 * of this software and associated documentation files (the "Software"), to deal
9 * in the Software without restriction, including without limitation the rights
10 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11 * copies of the Software, and to permit persons to whom the Software is
12 * furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23 * THE SOFTWARE.
24 */
25 #include <hw/hw.h>
26 #include <hw/pc.h>
27 #include <hw/pci.h>
28 #include "qemu-error.h"
29 #include "qemu-timer.h"
30 #include "sysemu.h"
31 #include "dma.h"
32 #include "blockdev.h"
33
34 #include <hw/ide/internal.h>
35
36 /* These values were based on a Seagate ST3500418AS but have been modified
37 to make more sense in QEMU */
38 static const int smart_attributes[][12] = {
39 /* id, flags, hflags, val, wrst, raw (6 bytes), threshold */
40 /* raw read error rate*/
41 { 0x01, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06},
42 /* spin up */
43 { 0x03, 0x03, 0x00, 0x64, 0x64, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
44 /* start stop count */
45 { 0x04, 0x02, 0x00, 0x64, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14},
46 /* remapped sectors */
47 { 0x05, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24},
48 /* power on hours */
49 { 0x09, 0x03, 0x00, 0x64, 0x64, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
50 /* power cycle count */
51 { 0x0c, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
52 /* airflow-temperature-celsius */
53 { 190, 0x03, 0x00, 0x45, 0x45, 0x1f, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x32},
54 /* end of list */
55 { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
56 };
57
58 static int ide_handle_rw_error(IDEState *s, int error, int op);
59 static void ide_dummy_transfer_stop(IDEState *s);
60
61 static void padstr(char *str, const char *src, int len)
62 {
63 int i, v;
64 for(i = 0; i < len; i++) {
65 if (*src)
66 v = *src++;
67 else
68 v = ' ';
69 str[i^1] = v;
70 }
71 }
72
73 static void put_le16(uint16_t *p, unsigned int v)
74 {
75 *p = cpu_to_le16(v);
76 }
77
78 static void ide_identify(IDEState *s)
79 {
80 uint16_t *p;
81 unsigned int oldsize;
82 IDEDevice *dev = s->unit ? s->bus->slave : s->bus->master;
83
84 if (s->identify_set) {
85 memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
86 return;
87 }
88
89 memset(s->io_buffer, 0, 512);
90 p = (uint16_t *)s->io_buffer;
91 put_le16(p + 0, 0x0040);
92 put_le16(p + 1, s->cylinders);
93 put_le16(p + 3, s->heads);
94 put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
95 put_le16(p + 5, 512); /* XXX: retired, remove ? */
96 put_le16(p + 6, s->sectors);
97 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
98 put_le16(p + 20, 3); /* XXX: retired, remove ? */
99 put_le16(p + 21, 512); /* cache size in sectors */
100 put_le16(p + 22, 4); /* ecc bytes */
101 padstr((char *)(p + 23), s->version, 8); /* firmware version */
102 padstr((char *)(p + 27), "QEMU HARDDISK", 40); /* model */
103 #if MAX_MULT_SECTORS > 1
104 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
105 #endif
106 put_le16(p + 48, 1); /* dword I/O */
107 put_le16(p + 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
108 put_le16(p + 51, 0x200); /* PIO transfer cycle */
109 put_le16(p + 52, 0x200); /* DMA transfer cycle */
110 put_le16(p + 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
111 put_le16(p + 54, s->cylinders);
112 put_le16(p + 55, s->heads);
113 put_le16(p + 56, s->sectors);
114 oldsize = s->cylinders * s->heads * s->sectors;
115 put_le16(p + 57, oldsize);
116 put_le16(p + 58, oldsize >> 16);
117 if (s->mult_sectors)
118 put_le16(p + 59, 0x100 | s->mult_sectors);
119 put_le16(p + 60, s->nb_sectors);
120 put_le16(p + 61, s->nb_sectors >> 16);
121 put_le16(p + 62, 0x07); /* single word dma0-2 supported */
122 put_le16(p + 63, 0x07); /* mdma0-2 supported */
123 put_le16(p + 64, 0x03); /* pio3-4 supported */
124 put_le16(p + 65, 120);
125 put_le16(p + 66, 120);
126 put_le16(p + 67, 120);
127 put_le16(p + 68, 120);
128 if (dev && dev->conf.discard_granularity) {
129 put_le16(p + 69, (1 << 14)); /* determinate TRIM behavior */
130 }
131
132 if (s->ncq_queues) {
133 put_le16(p + 75, s->ncq_queues - 1);
134 /* NCQ supported */
135 put_le16(p + 76, (1 << 8));
136 }
137
138 put_le16(p + 80, 0xf0); /* ata3 -> ata6 supported */
139 put_le16(p + 81, 0x16); /* conforms to ata5 */
140 /* 14=NOP supported, 5=WCACHE supported, 0=SMART supported */
141 put_le16(p + 82, (1 << 14) | (1 << 5) | 1);
142 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
143 put_le16(p + 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
144 /* 14=set to 1, 1=SMART self test, 0=SMART error logging */
145 put_le16(p + 84, (1 << 14) | 0);
146 /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
147 if (bdrv_enable_write_cache(s->bs))
148 put_le16(p + 85, (1 << 14) | (1 << 5) | 1);
149 else
150 put_le16(p + 85, (1 << 14) | 1);
151 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
152 put_le16(p + 86, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
153 /* 14=set to 1, 1=smart self test, 0=smart error logging */
154 put_le16(p + 87, (1 << 14) | 0);
155 put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
156 put_le16(p + 93, 1 | (1 << 14) | 0x2000);
157 put_le16(p + 100, s->nb_sectors);
158 put_le16(p + 101, s->nb_sectors >> 16);
159 put_le16(p + 102, s->nb_sectors >> 32);
160 put_le16(p + 103, s->nb_sectors >> 48);
161
162 if (dev && dev->conf.physical_block_size)
163 put_le16(p + 106, 0x6000 | get_physical_block_exp(&dev->conf));
164 if (dev && dev->conf.discard_granularity) {
165 put_le16(p + 169, 1); /* TRIM support */
166 }
167
168 memcpy(s->identify_data, p, sizeof(s->identify_data));
169 s->identify_set = 1;
170 }
171
172 static void ide_atapi_identify(IDEState *s)
173 {
174 uint16_t *p;
175
176 if (s->identify_set) {
177 memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
178 return;
179 }
180
181 memset(s->io_buffer, 0, 512);
182 p = (uint16_t *)s->io_buffer;
183 /* Removable CDROM, 50us response, 12 byte packets */
184 put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
185 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
186 put_le16(p + 20, 3); /* buffer type */
187 put_le16(p + 21, 512); /* cache size in sectors */
188 put_le16(p + 22, 4); /* ecc bytes */
189 padstr((char *)(p + 23), s->version, 8); /* firmware version */
190 padstr((char *)(p + 27), "QEMU DVD-ROM", 40); /* model */
191 put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
192 #ifdef USE_DMA_CDROM
193 put_le16(p + 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
194 put_le16(p + 53, 7); /* words 64-70, 54-58, 88 valid */
195 put_le16(p + 62, 7); /* single word dma0-2 supported */
196 put_le16(p + 63, 7); /* mdma0-2 supported */
197 #else
198 put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
199 put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
200 put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
201 #endif
202 put_le16(p + 64, 3); /* pio3-4 supported */
203 put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
204 put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
205 put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
206 put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
207
208 put_le16(p + 71, 30); /* in ns */
209 put_le16(p + 72, 30); /* in ns */
210
211 if (s->ncq_queues) {
212 put_le16(p + 75, s->ncq_queues - 1);
213 /* NCQ supported */
214 put_le16(p + 76, (1 << 8));
215 }
216
217 put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
218 #ifdef USE_DMA_CDROM
219 put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
220 #endif
221 memcpy(s->identify_data, p, sizeof(s->identify_data));
222 s->identify_set = 1;
223 }
224
225 static void ide_cfata_identify(IDEState *s)
226 {
227 uint16_t *p;
228 uint32_t cur_sec;
229
230 p = (uint16_t *) s->identify_data;
231 if (s->identify_set)
232 goto fill_buffer;
233
234 memset(p, 0, sizeof(s->identify_data));
235
236 cur_sec = s->cylinders * s->heads * s->sectors;
237
238 put_le16(p + 0, 0x848a); /* CF Storage Card signature */
239 put_le16(p + 1, s->cylinders); /* Default cylinders */
240 put_le16(p + 3, s->heads); /* Default heads */
241 put_le16(p + 6, s->sectors); /* Default sectors per track */
242 put_le16(p + 7, s->nb_sectors >> 16); /* Sectors per card */
243 put_le16(p + 8, s->nb_sectors); /* Sectors per card */
244 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
245 put_le16(p + 22, 0x0004); /* ECC bytes */
246 padstr((char *) (p + 23), s->version, 8); /* Firmware Revision */
247 padstr((char *) (p + 27), "QEMU MICRODRIVE", 40);/* Model number */
248 #if MAX_MULT_SECTORS > 1
249 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
250 #else
251 put_le16(p + 47, 0x0000);
252 #endif
253 put_le16(p + 49, 0x0f00); /* Capabilities */
254 put_le16(p + 51, 0x0002); /* PIO cycle timing mode */
255 put_le16(p + 52, 0x0001); /* DMA cycle timing mode */
256 put_le16(p + 53, 0x0003); /* Translation params valid */
257 put_le16(p + 54, s->cylinders); /* Current cylinders */
258 put_le16(p + 55, s->heads); /* Current heads */
259 put_le16(p + 56, s->sectors); /* Current sectors */
260 put_le16(p + 57, cur_sec); /* Current capacity */
261 put_le16(p + 58, cur_sec >> 16); /* Current capacity */
262 if (s->mult_sectors) /* Multiple sector setting */
263 put_le16(p + 59, 0x100 | s->mult_sectors);
264 put_le16(p + 60, s->nb_sectors); /* Total LBA sectors */
265 put_le16(p + 61, s->nb_sectors >> 16); /* Total LBA sectors */
266 put_le16(p + 63, 0x0203); /* Multiword DMA capability */
267 put_le16(p + 64, 0x0001); /* Flow Control PIO support */
268 put_le16(p + 65, 0x0096); /* Min. Multiword DMA cycle */
269 put_le16(p + 66, 0x0096); /* Rec. Multiword DMA cycle */
270 put_le16(p + 68, 0x00b4); /* Min. PIO cycle time */
271 put_le16(p + 82, 0x400c); /* Command Set supported */
272 put_le16(p + 83, 0x7068); /* Command Set supported */
273 put_le16(p + 84, 0x4000); /* Features supported */
274 put_le16(p + 85, 0x000c); /* Command Set enabled */
275 put_le16(p + 86, 0x7044); /* Command Set enabled */
276 put_le16(p + 87, 0x4000); /* Features enabled */
277 put_le16(p + 91, 0x4060); /* Current APM level */
278 put_le16(p + 129, 0x0002); /* Current features option */
279 put_le16(p + 130, 0x0005); /* Reassigned sectors */
280 put_le16(p + 131, 0x0001); /* Initial power mode */
281 put_le16(p + 132, 0x0000); /* User signature */
282 put_le16(p + 160, 0x8100); /* Power requirement */
283 put_le16(p + 161, 0x8001); /* CF command set */
284
285 s->identify_set = 1;
286
287 fill_buffer:
288 memcpy(s->io_buffer, p, sizeof(s->identify_data));
289 }
290
291 static void ide_set_signature(IDEState *s)
292 {
293 s->select &= 0xf0; /* clear head */
294 /* put signature */
295 s->nsector = 1;
296 s->sector = 1;
297 if (s->drive_kind == IDE_CD) {
298 s->lcyl = 0x14;
299 s->hcyl = 0xeb;
300 } else if (s->bs) {
301 s->lcyl = 0;
302 s->hcyl = 0;
303 } else {
304 s->lcyl = 0xff;
305 s->hcyl = 0xff;
306 }
307 }
308
309 typedef struct TrimAIOCB {
310 BlockDriverAIOCB common;
311 QEMUBH *bh;
312 int ret;
313 } TrimAIOCB;
314
315 static void trim_aio_cancel(BlockDriverAIOCB *acb)
316 {
317 TrimAIOCB *iocb = container_of(acb, TrimAIOCB, common);
318
319 qemu_bh_delete(iocb->bh);
320 iocb->bh = NULL;
321 qemu_aio_release(iocb);
322 }
323
324 static AIOPool trim_aio_pool = {
325 .aiocb_size = sizeof(TrimAIOCB),
326 .cancel = trim_aio_cancel,
327 };
328
329 static void ide_trim_bh_cb(void *opaque)
330 {
331 TrimAIOCB *iocb = opaque;
332
333 iocb->common.cb(iocb->common.opaque, iocb->ret);
334
335 qemu_bh_delete(iocb->bh);
336 iocb->bh = NULL;
337
338 qemu_aio_release(iocb);
339 }
340
341 BlockDriverAIOCB *ide_issue_trim(BlockDriverState *bs,
342 int64_t sector_num, QEMUIOVector *qiov, int nb_sectors,
343 BlockDriverCompletionFunc *cb, void *opaque)
344 {
345 TrimAIOCB *iocb;
346 int i, j, ret;
347
348 iocb = qemu_aio_get(&trim_aio_pool, bs, cb, opaque);
349 iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb);
350 iocb->ret = 0;
351
352 for (j = 0; j < qiov->niov; j++) {
353 uint64_t *buffer = qiov->iov[j].iov_base;
354
355 for (i = 0; i < qiov->iov[j].iov_len / 8; i++) {
356 /* 6-byte LBA + 2-byte range per entry */
357 uint64_t entry = le64_to_cpu(buffer[i]);
358 uint64_t sector = entry & 0x0000ffffffffffffULL;
359 uint16_t count = entry >> 48;
360
361 if (count == 0) {
362 break;
363 }
364
365 ret = bdrv_discard(bs, sector, count);
366 if (!iocb->ret) {
367 iocb->ret = ret;
368 }
369 }
370 }
371
372 qemu_bh_schedule(iocb->bh);
373
374 return &iocb->common;
375 }
376
377 static inline void ide_abort_command(IDEState *s)
378 {
379 s->status = READY_STAT | ERR_STAT;
380 s->error = ABRT_ERR;
381 }
382
383 /* prepare data transfer and tell what to do after */
384 void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
385 EndTransferFunc *end_transfer_func)
386 {
387 s->end_transfer_func = end_transfer_func;
388 s->data_ptr = buf;
389 s->data_end = buf + size;
390 if (!(s->status & ERR_STAT)) {
391 s->status |= DRQ_STAT;
392 }
393 s->bus->dma->ops->start_transfer(s->bus->dma);
394 }
395
396 void ide_transfer_stop(IDEState *s)
397 {
398 s->end_transfer_func = ide_transfer_stop;
399 s->data_ptr = s->io_buffer;
400 s->data_end = s->io_buffer;
401 s->status &= ~DRQ_STAT;
402 }
403
404 int64_t ide_get_sector(IDEState *s)
405 {
406 int64_t sector_num;
407 if (s->select & 0x40) {
408 /* lba */
409 if (!s->lba48) {
410 sector_num = ((s->select & 0x0f) << 24) | (s->hcyl << 16) |
411 (s->lcyl << 8) | s->sector;
412 } else {
413 sector_num = ((int64_t)s->hob_hcyl << 40) |
414 ((int64_t) s->hob_lcyl << 32) |
415 ((int64_t) s->hob_sector << 24) |
416 ((int64_t) s->hcyl << 16) |
417 ((int64_t) s->lcyl << 8) | s->sector;
418 }
419 } else {
420 sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
421 (s->select & 0x0f) * s->sectors + (s->sector - 1);
422 }
423 return sector_num;
424 }
425
426 void ide_set_sector(IDEState *s, int64_t sector_num)
427 {
428 unsigned int cyl, r;
429 if (s->select & 0x40) {
430 if (!s->lba48) {
431 s->select = (s->select & 0xf0) | (sector_num >> 24);
432 s->hcyl = (sector_num >> 16);
433 s->lcyl = (sector_num >> 8);
434 s->sector = (sector_num);
435 } else {
436 s->sector = sector_num;
437 s->lcyl = sector_num >> 8;
438 s->hcyl = sector_num >> 16;
439 s->hob_sector = sector_num >> 24;
440 s->hob_lcyl = sector_num >> 32;
441 s->hob_hcyl = sector_num >> 40;
442 }
443 } else {
444 cyl = sector_num / (s->heads * s->sectors);
445 r = sector_num % (s->heads * s->sectors);
446 s->hcyl = cyl >> 8;
447 s->lcyl = cyl;
448 s->select = (s->select & 0xf0) | ((r / s->sectors) & 0x0f);
449 s->sector = (r % s->sectors) + 1;
450 }
451 }
452
453 static void ide_rw_error(IDEState *s) {
454 ide_abort_command(s);
455 ide_set_irq(s->bus);
456 }
457
458 void ide_sector_read(IDEState *s)
459 {
460 int64_t sector_num;
461 int ret, n;
462
463 s->status = READY_STAT | SEEK_STAT;
464 s->error = 0; /* not needed by IDE spec, but needed by Windows */
465 sector_num = ide_get_sector(s);
466 n = s->nsector;
467 if (n == 0) {
468 /* no more sector to read from disk */
469 ide_transfer_stop(s);
470 } else {
471 #if defined(DEBUG_IDE)
472 printf("read sector=%" PRId64 "\n", sector_num);
473 #endif
474 if (n > s->req_nb_sectors)
475 n = s->req_nb_sectors;
476
477 bdrv_acct_start(s->bs, &s->acct, n * BDRV_SECTOR_SIZE, BDRV_ACCT_READ);
478 ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
479 bdrv_acct_done(s->bs, &s->acct);
480 if (ret != 0) {
481 if (ide_handle_rw_error(s, -ret,
482 BM_STATUS_PIO_RETRY | BM_STATUS_RETRY_READ))
483 {
484 return;
485 }
486 }
487 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_read);
488 ide_set_irq(s->bus);
489 ide_set_sector(s, sector_num + n);
490 s->nsector -= n;
491 }
492 }
493
494 static void dma_buf_commit(IDEState *s, int is_write)
495 {
496 qemu_sglist_destroy(&s->sg);
497 }
498
499 void ide_set_inactive(IDEState *s)
500 {
501 s->bus->dma->aiocb = NULL;
502 s->bus->dma->ops->set_inactive(s->bus->dma);
503 }
504
505 void ide_dma_error(IDEState *s)
506 {
507 ide_transfer_stop(s);
508 s->error = ABRT_ERR;
509 s->status = READY_STAT | ERR_STAT;
510 ide_set_inactive(s);
511 ide_set_irq(s->bus);
512 }
513
514 static int ide_handle_rw_error(IDEState *s, int error, int op)
515 {
516 int is_read = (op & BM_STATUS_RETRY_READ);
517 BlockErrorAction action = bdrv_get_on_error(s->bs, is_read);
518
519 if (action == BLOCK_ERR_IGNORE) {
520 bdrv_mon_event(s->bs, BDRV_ACTION_IGNORE, is_read);
521 return 0;
522 }
523
524 if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
525 || action == BLOCK_ERR_STOP_ANY) {
526 s->bus->dma->ops->set_unit(s->bus->dma, s->unit);
527 s->bus->error_status = op;
528 bdrv_mon_event(s->bs, BDRV_ACTION_STOP, is_read);
529 vm_stop(VMSTOP_DISKFULL);
530 } else {
531 if (op & BM_STATUS_DMA_RETRY) {
532 dma_buf_commit(s, 0);
533 ide_dma_error(s);
534 } else {
535 ide_rw_error(s);
536 }
537 bdrv_mon_event(s->bs, BDRV_ACTION_REPORT, is_read);
538 }
539
540 return 1;
541 }
542
543 void ide_dma_cb(void *opaque, int ret)
544 {
545 IDEState *s = opaque;
546 int n;
547 int64_t sector_num;
548
549 handle_rw_error:
550 if (ret < 0) {
551 int op = BM_STATUS_DMA_RETRY;
552
553 if (s->dma_cmd == IDE_DMA_READ)
554 op |= BM_STATUS_RETRY_READ;
555 else if (s->dma_cmd == IDE_DMA_TRIM)
556 op |= BM_STATUS_RETRY_TRIM;
557
558 if (ide_handle_rw_error(s, -ret, op)) {
559 return;
560 }
561 }
562
563 n = s->io_buffer_size >> 9;
564 sector_num = ide_get_sector(s);
565 if (n > 0) {
566 dma_buf_commit(s, ide_cmd_is_read(s));
567 sector_num += n;
568 ide_set_sector(s, sector_num);
569 s->nsector -= n;
570 }
571
572 /* end of transfer ? */
573 if (s->nsector == 0) {
574 s->status = READY_STAT | SEEK_STAT;
575 ide_set_irq(s->bus);
576 goto eot;
577 }
578
579 /* launch next transfer */
580 n = s->nsector;
581 s->io_buffer_index = 0;
582 s->io_buffer_size = n * 512;
583 if (s->bus->dma->ops->prepare_buf(s->bus->dma, ide_cmd_is_read(s)) == 0) {
584 /* The PRDs were too short. Reset the Active bit, but don't raise an
585 * interrupt. */
586 goto eot;
587 }
588
589 #ifdef DEBUG_AIO
590 printf("ide_dma_cb: sector_num=%" PRId64 " n=%d, cmd_cmd=%d\n",
591 sector_num, n, s->dma_cmd);
592 #endif
593
594 switch (s->dma_cmd) {
595 case IDE_DMA_READ:
596 s->bus->dma->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num,
597 ide_dma_cb, s);
598 break;
599 case IDE_DMA_WRITE:
600 s->bus->dma->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num,
601 ide_dma_cb, s);
602 break;
603 case IDE_DMA_TRIM:
604 s->bus->dma->aiocb = dma_bdrv_io(s->bs, &s->sg, sector_num,
605 ide_issue_trim, ide_dma_cb, s, 1);
606 break;
607 }
608
609 if (!s->bus->dma->aiocb) {
610 ret = -1;
611 goto handle_rw_error;
612 }
613 return;
614
615 eot:
616 if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) {
617 bdrv_acct_done(s->bs, &s->acct);
618 }
619 ide_set_inactive(s);
620 }
621
622 static void ide_sector_start_dma(IDEState *s, enum ide_dma_cmd dma_cmd)
623 {
624 s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
625 s->io_buffer_index = 0;
626 s->io_buffer_size = 0;
627 s->dma_cmd = dma_cmd;
628
629 switch (dma_cmd) {
630 case IDE_DMA_READ:
631 bdrv_acct_start(s->bs, &s->acct, s->nsector * BDRV_SECTOR_SIZE,
632 BDRV_ACCT_READ);
633 break;
634 case IDE_DMA_WRITE:
635 bdrv_acct_start(s->bs, &s->acct, s->nsector * BDRV_SECTOR_SIZE,
636 BDRV_ACCT_WRITE);
637 break;
638 default:
639 break;
640 }
641
642 s->bus->dma->ops->start_dma(s->bus->dma, s, ide_dma_cb);
643 }
644
645 static void ide_sector_write_timer_cb(void *opaque)
646 {
647 IDEState *s = opaque;
648 ide_set_irq(s->bus);
649 }
650
651 void ide_sector_write(IDEState *s)
652 {
653 int64_t sector_num;
654 int ret, n, n1;
655
656 s->status = READY_STAT | SEEK_STAT;
657 sector_num = ide_get_sector(s);
658 #if defined(DEBUG_IDE)
659 printf("write sector=%" PRId64 "\n", sector_num);
660 #endif
661 n = s->nsector;
662 if (n > s->req_nb_sectors)
663 n = s->req_nb_sectors;
664
665 bdrv_acct_start(s->bs, &s->acct, n * BDRV_SECTOR_SIZE, BDRV_ACCT_READ);
666 ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
667 bdrv_acct_done(s->bs, &s->acct);
668
669 if (ret != 0) {
670 if (ide_handle_rw_error(s, -ret, BM_STATUS_PIO_RETRY))
671 return;
672 }
673
674 s->nsector -= n;
675 if (s->nsector == 0) {
676 /* no more sectors to write */
677 ide_transfer_stop(s);
678 } else {
679 n1 = s->nsector;
680 if (n1 > s->req_nb_sectors)
681 n1 = s->req_nb_sectors;
682 ide_transfer_start(s, s->io_buffer, 512 * n1, ide_sector_write);
683 }
684 ide_set_sector(s, sector_num + n);
685
686 if (win2k_install_hack && ((++s->irq_count % 16) == 0)) {
687 /* It seems there is a bug in the Windows 2000 installer HDD
688 IDE driver which fills the disk with empty logs when the
689 IDE write IRQ comes too early. This hack tries to correct
690 that at the expense of slower write performances. Use this
691 option _only_ to install Windows 2000. You must disable it
692 for normal use. */
693 qemu_mod_timer(s->sector_write_timer,
694 qemu_get_clock_ns(vm_clock) + (get_ticks_per_sec() / 1000));
695 } else {
696 ide_set_irq(s->bus);
697 }
698 }
699
700 static void ide_flush_cb(void *opaque, int ret)
701 {
702 IDEState *s = opaque;
703
704 if (ret < 0) {
705 /* XXX: What sector number to set here? */
706 if (ide_handle_rw_error(s, -ret, BM_STATUS_RETRY_FLUSH)) {
707 return;
708 }
709 }
710
711 bdrv_acct_done(s->bs, &s->acct);
712 s->status = READY_STAT | SEEK_STAT;
713 ide_set_irq(s->bus);
714 }
715
716 void ide_flush_cache(IDEState *s)
717 {
718 BlockDriverAIOCB *acb;
719
720 if (s->bs == NULL) {
721 ide_flush_cb(s, 0);
722 return;
723 }
724
725 bdrv_acct_start(s->bs, &s->acct, 0, BDRV_ACCT_FLUSH);
726 acb = bdrv_aio_flush(s->bs, ide_flush_cb, s);
727 if (acb == NULL) {
728 ide_flush_cb(s, -EIO);
729 }
730 }
731
732 static void ide_cfata_metadata_inquiry(IDEState *s)
733 {
734 uint16_t *p;
735 uint32_t spd;
736
737 p = (uint16_t *) s->io_buffer;
738 memset(p, 0, 0x200);
739 spd = ((s->mdata_size - 1) >> 9) + 1;
740
741 put_le16(p + 0, 0x0001); /* Data format revision */
742 put_le16(p + 1, 0x0000); /* Media property: silicon */
743 put_le16(p + 2, s->media_changed); /* Media status */
744 put_le16(p + 3, s->mdata_size & 0xffff); /* Capacity in bytes (low) */
745 put_le16(p + 4, s->mdata_size >> 16); /* Capacity in bytes (high) */
746 put_le16(p + 5, spd & 0xffff); /* Sectors per device (low) */
747 put_le16(p + 6, spd >> 16); /* Sectors per device (high) */
748 }
749
750 static void ide_cfata_metadata_read(IDEState *s)
751 {
752 uint16_t *p;
753
754 if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
755 s->status = ERR_STAT;
756 s->error = ABRT_ERR;
757 return;
758 }
759
760 p = (uint16_t *) s->io_buffer;
761 memset(p, 0, 0x200);
762
763 put_le16(p + 0, s->media_changed); /* Media status */
764 memcpy(p + 1, s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
765 MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
766 s->nsector << 9), 0x200 - 2));
767 }
768
769 static void ide_cfata_metadata_write(IDEState *s)
770 {
771 if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
772 s->status = ERR_STAT;
773 s->error = ABRT_ERR;
774 return;
775 }
776
777 s->media_changed = 0;
778
779 memcpy(s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
780 s->io_buffer + 2,
781 MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
782 s->nsector << 9), 0x200 - 2));
783 }
784
785 /* called when the inserted state of the media has changed */
786 static void ide_cd_change_cb(void *opaque)
787 {
788 IDEState *s = opaque;
789 uint64_t nb_sectors;
790
791 bdrv_get_geometry(s->bs, &nb_sectors);
792 s->nb_sectors = nb_sectors;
793
794 /*
795 * First indicate to the guest that a CD has been removed. That's
796 * done on the next command the guest sends us.
797 *
798 * Then we set SENSE_UNIT_ATTENTION, by which the guest will
799 * detect a new CD in the drive. See ide_atapi_cmd() for details.
800 */
801 s->cdrom_changed = 1;
802 s->events.new_media = true;
803 ide_set_irq(s->bus);
804 }
805
806 static void ide_cmd_lba48_transform(IDEState *s, int lba48)
807 {
808 s->lba48 = lba48;
809
810 /* handle the 'magic' 0 nsector count conversion here. to avoid
811 * fiddling with the rest of the read logic, we just store the
812 * full sector count in ->nsector and ignore ->hob_nsector from now
813 */
814 if (!s->lba48) {
815 if (!s->nsector)
816 s->nsector = 256;
817 } else {
818 if (!s->nsector && !s->hob_nsector)
819 s->nsector = 65536;
820 else {
821 int lo = s->nsector;
822 int hi = s->hob_nsector;
823
824 s->nsector = (hi << 8) | lo;
825 }
826 }
827 }
828
829 static void ide_clear_hob(IDEBus *bus)
830 {
831 /* any write clears HOB high bit of device control register */
832 bus->ifs[0].select &= ~(1 << 7);
833 bus->ifs[1].select &= ~(1 << 7);
834 }
835
836 void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
837 {
838 IDEBus *bus = opaque;
839
840 #ifdef DEBUG_IDE
841 printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
842 #endif
843
844 addr &= 7;
845
846 /* ignore writes to command block while busy with previous command */
847 if (addr != 7 && (idebus_active_if(bus)->status & (BUSY_STAT|DRQ_STAT)))
848 return;
849
850 switch(addr) {
851 case 0:
852 break;
853 case 1:
854 ide_clear_hob(bus);
855 /* NOTE: data is written to the two drives */
856 bus->ifs[0].hob_feature = bus->ifs[0].feature;
857 bus->ifs[1].hob_feature = bus->ifs[1].feature;
858 bus->ifs[0].feature = val;
859 bus->ifs[1].feature = val;
860 break;
861 case 2:
862 ide_clear_hob(bus);
863 bus->ifs[0].hob_nsector = bus->ifs[0].nsector;
864 bus->ifs[1].hob_nsector = bus->ifs[1].nsector;
865 bus->ifs[0].nsector = val;
866 bus->ifs[1].nsector = val;
867 break;
868 case 3:
869 ide_clear_hob(bus);
870 bus->ifs[0].hob_sector = bus->ifs[0].sector;
871 bus->ifs[1].hob_sector = bus->ifs[1].sector;
872 bus->ifs[0].sector = val;
873 bus->ifs[1].sector = val;
874 break;
875 case 4:
876 ide_clear_hob(bus);
877 bus->ifs[0].hob_lcyl = bus->ifs[0].lcyl;
878 bus->ifs[1].hob_lcyl = bus->ifs[1].lcyl;
879 bus->ifs[0].lcyl = val;
880 bus->ifs[1].lcyl = val;
881 break;
882 case 5:
883 ide_clear_hob(bus);
884 bus->ifs[0].hob_hcyl = bus->ifs[0].hcyl;
885 bus->ifs[1].hob_hcyl = bus->ifs[1].hcyl;
886 bus->ifs[0].hcyl = val;
887 bus->ifs[1].hcyl = val;
888 break;
889 case 6:
890 /* FIXME: HOB readback uses bit 7 */
891 bus->ifs[0].select = (val & ~0x10) | 0xa0;
892 bus->ifs[1].select = (val | 0x10) | 0xa0;
893 /* select drive */
894 bus->unit = (val >> 4) & 1;
895 break;
896 default:
897 case 7:
898 /* command */
899 ide_exec_cmd(bus, val);
900 break;
901 }
902 }
903
904 #define HD_OK (1u << IDE_HD)
905 #define CD_OK (1u << IDE_CD)
906 #define CFA_OK (1u << IDE_CFATA)
907 #define HD_CFA_OK (HD_OK | CFA_OK)
908 #define ALL_OK (HD_OK | CD_OK | CFA_OK)
909
910 /* See ACS-2 T13/2015-D Table B.2 Command codes */
911 static const uint8_t ide_cmd_table[0x100] = {
912 /* NOP not implemented, mandatory for CD */
913 [CFA_REQ_EXT_ERROR_CODE] = CFA_OK,
914 [WIN_DSM] = ALL_OK,
915 [WIN_DEVICE_RESET] = CD_OK,
916 [WIN_RECAL] = HD_CFA_OK,
917 [WIN_READ] = ALL_OK,
918 [WIN_READ_ONCE] = ALL_OK,
919 [WIN_READ_EXT] = HD_CFA_OK,
920 [WIN_READDMA_EXT] = HD_CFA_OK,
921 [WIN_READ_NATIVE_MAX_EXT] = HD_CFA_OK,
922 [WIN_MULTREAD_EXT] = HD_CFA_OK,
923 [WIN_WRITE] = HD_CFA_OK,
924 [WIN_WRITE_ONCE] = HD_CFA_OK,
925 [WIN_WRITE_EXT] = HD_CFA_OK,
926 [WIN_WRITEDMA_EXT] = HD_CFA_OK,
927 [CFA_WRITE_SECT_WO_ERASE] = CFA_OK,
928 [WIN_MULTWRITE_EXT] = HD_CFA_OK,
929 [WIN_WRITE_VERIFY] = HD_CFA_OK,
930 [WIN_VERIFY] = HD_CFA_OK,
931 [WIN_VERIFY_ONCE] = HD_CFA_OK,
932 [WIN_VERIFY_EXT] = HD_CFA_OK,
933 [WIN_SEEK] = HD_CFA_OK,
934 [CFA_TRANSLATE_SECTOR] = CFA_OK,
935 [WIN_DIAGNOSE] = ALL_OK,
936 [WIN_SPECIFY] = HD_CFA_OK,
937 [WIN_STANDBYNOW2] = ALL_OK,
938 [WIN_IDLEIMMEDIATE2] = ALL_OK,
939 [WIN_STANDBY2] = ALL_OK,
940 [WIN_SETIDLE2] = ALL_OK,
941 [WIN_CHECKPOWERMODE2] = ALL_OK,
942 [WIN_SLEEPNOW2] = ALL_OK,
943 [WIN_PACKETCMD] = CD_OK,
944 [WIN_PIDENTIFY] = CD_OK,
945 [WIN_SMART] = HD_CFA_OK,
946 [CFA_ACCESS_METADATA_STORAGE] = CFA_OK,
947 [CFA_ERASE_SECTORS] = CFA_OK,
948 [WIN_MULTREAD] = HD_CFA_OK,
949 [WIN_MULTWRITE] = HD_CFA_OK,
950 [WIN_SETMULT] = HD_CFA_OK,
951 [WIN_READDMA] = HD_CFA_OK,
952 [WIN_READDMA_ONCE] = HD_CFA_OK,
953 [WIN_WRITEDMA] = HD_CFA_OK,
954 [WIN_WRITEDMA_ONCE] = HD_CFA_OK,
955 [CFA_WRITE_MULTI_WO_ERASE] = CFA_OK,
956 [WIN_STANDBYNOW1] = ALL_OK,
957 [WIN_IDLEIMMEDIATE] = ALL_OK,
958 [WIN_STANDBY] = ALL_OK,
959 [WIN_SETIDLE1] = ALL_OK,
960 [WIN_CHECKPOWERMODE1] = ALL_OK,
961 [WIN_SLEEPNOW1] = ALL_OK,
962 [WIN_FLUSH_CACHE] = ALL_OK,
963 [WIN_FLUSH_CACHE_EXT] = HD_CFA_OK,
964 [WIN_IDENTIFY] = ALL_OK,
965 [WIN_SETFEATURES] = ALL_OK,
966 [IBM_SENSE_CONDITION] = CFA_OK,
967 [CFA_WEAR_LEVEL] = CFA_OK,
968 [WIN_READ_NATIVE_MAX] = ALL_OK,
969 };
970
971 static bool ide_cmd_permitted(IDEState *s, uint32_t cmd)
972 {
973 return cmd < ARRAY_SIZE(ide_cmd_table)
974 && (ide_cmd_table[cmd] & (1u << s->drive_kind));
975 }
976
977 void ide_exec_cmd(IDEBus *bus, uint32_t val)
978 {
979 IDEState *s;
980 int n;
981 int lba48 = 0;
982
983 #if defined(DEBUG_IDE)
984 printf("ide: CMD=%02x\n", val);
985 #endif
986 s = idebus_active_if(bus);
987 /* ignore commands to non existant slave */
988 if (s != bus->ifs && !s->bs)
989 return;
990
991 /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
992 if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET)
993 return;
994
995 if (!ide_cmd_permitted(s, val)) {
996 goto abort_cmd;
997 }
998
999 switch(val) {
1000 case WIN_DSM:
1001 switch (s->feature) {
1002 case DSM_TRIM:
1003 if (!s->bs) {
1004 goto abort_cmd;
1005 }
1006 ide_sector_start_dma(s, IDE_DMA_TRIM);
1007 break;
1008 default:
1009 goto abort_cmd;
1010 }
1011 break;
1012 case WIN_IDENTIFY:
1013 if (s->bs && s->drive_kind != IDE_CD) {
1014 if (s->drive_kind != IDE_CFATA)
1015 ide_identify(s);
1016 else
1017 ide_cfata_identify(s);
1018 s->status = READY_STAT | SEEK_STAT;
1019 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1020 } else {
1021 if (s->drive_kind == IDE_CD) {
1022 ide_set_signature(s);
1023 }
1024 ide_abort_command(s);
1025 }
1026 ide_set_irq(s->bus);
1027 break;
1028 case WIN_SPECIFY:
1029 case WIN_RECAL:
1030 s->error = 0;
1031 s->status = READY_STAT | SEEK_STAT;
1032 ide_set_irq(s->bus);
1033 break;
1034 case WIN_SETMULT:
1035 if (s->drive_kind == IDE_CFATA && s->nsector == 0) {
1036 /* Disable Read and Write Multiple */
1037 s->mult_sectors = 0;
1038 s->status = READY_STAT | SEEK_STAT;
1039 } else if ((s->nsector & 0xff) != 0 &&
1040 ((s->nsector & 0xff) > MAX_MULT_SECTORS ||
1041 (s->nsector & (s->nsector - 1)) != 0)) {
1042 ide_abort_command(s);
1043 } else {
1044 s->mult_sectors = s->nsector & 0xff;
1045 s->status = READY_STAT | SEEK_STAT;
1046 }
1047 ide_set_irq(s->bus);
1048 break;
1049 case WIN_VERIFY_EXT:
1050 lba48 = 1;
1051 case WIN_VERIFY:
1052 case WIN_VERIFY_ONCE:
1053 /* do sector number check ? */
1054 ide_cmd_lba48_transform(s, lba48);
1055 s->status = READY_STAT | SEEK_STAT;
1056 ide_set_irq(s->bus);
1057 break;
1058 case WIN_READ_EXT:
1059 lba48 = 1;
1060 case WIN_READ:
1061 case WIN_READ_ONCE:
1062 if (s->drive_kind == IDE_CD) {
1063 ide_set_signature(s); /* odd, but ATA4 8.27.5.2 requires it */
1064 goto abort_cmd;
1065 }
1066 ide_cmd_lba48_transform(s, lba48);
1067 s->req_nb_sectors = 1;
1068 ide_sector_read(s);
1069 break;
1070 case WIN_WRITE_EXT:
1071 lba48 = 1;
1072 case WIN_WRITE:
1073 case WIN_WRITE_ONCE:
1074 case CFA_WRITE_SECT_WO_ERASE:
1075 case WIN_WRITE_VERIFY:
1076 ide_cmd_lba48_transform(s, lba48);
1077 s->error = 0;
1078 s->status = SEEK_STAT | READY_STAT;
1079 s->req_nb_sectors = 1;
1080 ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
1081 s->media_changed = 1;
1082 break;
1083 case WIN_MULTREAD_EXT:
1084 lba48 = 1;
1085 case WIN_MULTREAD:
1086 if (!s->mult_sectors)
1087 goto abort_cmd;
1088 ide_cmd_lba48_transform(s, lba48);
1089 s->req_nb_sectors = s->mult_sectors;
1090 ide_sector_read(s);
1091 break;
1092 case WIN_MULTWRITE_EXT:
1093 lba48 = 1;
1094 case WIN_MULTWRITE:
1095 case CFA_WRITE_MULTI_WO_ERASE:
1096 if (!s->mult_sectors)
1097 goto abort_cmd;
1098 ide_cmd_lba48_transform(s, lba48);
1099 s->error = 0;
1100 s->status = SEEK_STAT | READY_STAT;
1101 s->req_nb_sectors = s->mult_sectors;
1102 n = s->nsector;
1103 if (n > s->req_nb_sectors)
1104 n = s->req_nb_sectors;
1105 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
1106 s->media_changed = 1;
1107 break;
1108 case WIN_READDMA_EXT:
1109 lba48 = 1;
1110 case WIN_READDMA:
1111 case WIN_READDMA_ONCE:
1112 if (!s->bs)
1113 goto abort_cmd;
1114 ide_cmd_lba48_transform(s, lba48);
1115 ide_sector_start_dma(s, IDE_DMA_READ);
1116 break;
1117 case WIN_WRITEDMA_EXT:
1118 lba48 = 1;
1119 case WIN_WRITEDMA:
1120 case WIN_WRITEDMA_ONCE:
1121 if (!s->bs)
1122 goto abort_cmd;
1123 ide_cmd_lba48_transform(s, lba48);
1124 ide_sector_start_dma(s, IDE_DMA_WRITE);
1125 s->media_changed = 1;
1126 break;
1127 case WIN_READ_NATIVE_MAX_EXT:
1128 lba48 = 1;
1129 case WIN_READ_NATIVE_MAX:
1130 ide_cmd_lba48_transform(s, lba48);
1131 ide_set_sector(s, s->nb_sectors - 1);
1132 s->status = READY_STAT | SEEK_STAT;
1133 ide_set_irq(s->bus);
1134 break;
1135 case WIN_CHECKPOWERMODE1:
1136 case WIN_CHECKPOWERMODE2:
1137 s->error = 0;
1138 s->nsector = 0xff; /* device active or idle */
1139 s->status = READY_STAT | SEEK_STAT;
1140 ide_set_irq(s->bus);
1141 break;
1142 case WIN_SETFEATURES:
1143 if (!s->bs)
1144 goto abort_cmd;
1145 /* XXX: valid for CDROM ? */
1146 switch(s->feature) {
1147 case 0xcc: /* reverting to power-on defaults enable */
1148 case 0x66: /* reverting to power-on defaults disable */
1149 case 0x02: /* write cache enable */
1150 case 0x82: /* write cache disable */
1151 case 0xaa: /* read look-ahead enable */
1152 case 0x55: /* read look-ahead disable */
1153 case 0x05: /* set advanced power management mode */
1154 case 0x85: /* disable advanced power management mode */
1155 case 0x69: /* NOP */
1156 case 0x67: /* NOP */
1157 case 0x96: /* NOP */
1158 case 0x9a: /* NOP */
1159 case 0x42: /* enable Automatic Acoustic Mode */
1160 case 0xc2: /* disable Automatic Acoustic Mode */
1161 s->status = READY_STAT | SEEK_STAT;
1162 ide_set_irq(s->bus);
1163 break;
1164 case 0x03: { /* set transfer mode */
1165 uint8_t val = s->nsector & 0x07;
1166 uint16_t *identify_data = (uint16_t *)s->identify_data;
1167
1168 switch (s->nsector >> 3) {
1169 case 0x00: /* pio default */
1170 case 0x01: /* pio mode */
1171 put_le16(identify_data + 62,0x07);
1172 put_le16(identify_data + 63,0x07);
1173 put_le16(identify_data + 88,0x3f);
1174 break;
1175 case 0x02: /* sigle word dma mode*/
1176 put_le16(identify_data + 62,0x07 | (1 << (val + 8)));
1177 put_le16(identify_data + 63,0x07);
1178 put_le16(identify_data + 88,0x3f);
1179 break;
1180 case 0x04: /* mdma mode */
1181 put_le16(identify_data + 62,0x07);
1182 put_le16(identify_data + 63,0x07 | (1 << (val + 8)));
1183 put_le16(identify_data + 88,0x3f);
1184 break;
1185 case 0x08: /* udma mode */
1186 put_le16(identify_data + 62,0x07);
1187 put_le16(identify_data + 63,0x07);
1188 put_le16(identify_data + 88,0x3f | (1 << (val + 8)));
1189 break;
1190 default:
1191 goto abort_cmd;
1192 }
1193 s->status = READY_STAT | SEEK_STAT;
1194 ide_set_irq(s->bus);
1195 break;
1196 }
1197 default:
1198 goto abort_cmd;
1199 }
1200 break;
1201 case WIN_FLUSH_CACHE:
1202 case WIN_FLUSH_CACHE_EXT:
1203 ide_flush_cache(s);
1204 break;
1205 case WIN_STANDBY:
1206 case WIN_STANDBY2:
1207 case WIN_STANDBYNOW1:
1208 case WIN_STANDBYNOW2:
1209 case WIN_IDLEIMMEDIATE:
1210 case WIN_IDLEIMMEDIATE2:
1211 case WIN_SETIDLE1:
1212 case WIN_SETIDLE2:
1213 case WIN_SLEEPNOW1:
1214 case WIN_SLEEPNOW2:
1215 s->status = READY_STAT;
1216 ide_set_irq(s->bus);
1217 break;
1218 case WIN_SEEK:
1219 /* XXX: Check that seek is within bounds */
1220 s->status = READY_STAT | SEEK_STAT;
1221 ide_set_irq(s->bus);
1222 break;
1223 /* ATAPI commands */
1224 case WIN_PIDENTIFY:
1225 ide_atapi_identify(s);
1226 s->status = READY_STAT | SEEK_STAT;
1227 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1228 ide_set_irq(s->bus);
1229 break;
1230 case WIN_DIAGNOSE:
1231 ide_set_signature(s);
1232 if (s->drive_kind == IDE_CD)
1233 s->status = 0; /* ATAPI spec (v6) section 9.10 defines packet
1234 * devices to return a clear status register
1235 * with READY_STAT *not* set. */
1236 else
1237 s->status = READY_STAT | SEEK_STAT;
1238 s->error = 0x01; /* Device 0 passed, Device 1 passed or not
1239 * present.
1240 */
1241 ide_set_irq(s->bus);
1242 break;
1243 case WIN_DEVICE_RESET:
1244 ide_set_signature(s);
1245 s->status = 0x00; /* NOTE: READY is _not_ set */
1246 s->error = 0x01;
1247 break;
1248 case WIN_PACKETCMD:
1249 /* overlapping commands not supported */
1250 if (s->feature & 0x02)
1251 goto abort_cmd;
1252 s->status = READY_STAT | SEEK_STAT;
1253 s->atapi_dma = s->feature & 1;
1254 s->nsector = 1;
1255 ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
1256 ide_atapi_cmd);
1257 break;
1258 /* CF-ATA commands */
1259 case CFA_REQ_EXT_ERROR_CODE:
1260 s->error = 0x09; /* miscellaneous error */
1261 s->status = READY_STAT | SEEK_STAT;
1262 ide_set_irq(s->bus);
1263 break;
1264 case CFA_ERASE_SECTORS:
1265 case CFA_WEAR_LEVEL:
1266 if (val == CFA_WEAR_LEVEL)
1267 s->nsector = 0;
1268 if (val == CFA_ERASE_SECTORS)
1269 s->media_changed = 1;
1270 s->error = 0x00;
1271 s->status = READY_STAT | SEEK_STAT;
1272 ide_set_irq(s->bus);
1273 break;
1274 case CFA_TRANSLATE_SECTOR:
1275 s->error = 0x00;
1276 s->status = READY_STAT | SEEK_STAT;
1277 memset(s->io_buffer, 0, 0x200);
1278 s->io_buffer[0x00] = s->hcyl; /* Cyl MSB */
1279 s->io_buffer[0x01] = s->lcyl; /* Cyl LSB */
1280 s->io_buffer[0x02] = s->select; /* Head */
1281 s->io_buffer[0x03] = s->sector; /* Sector */
1282 s->io_buffer[0x04] = ide_get_sector(s) >> 16; /* LBA MSB */
1283 s->io_buffer[0x05] = ide_get_sector(s) >> 8; /* LBA */
1284 s->io_buffer[0x06] = ide_get_sector(s) >> 0; /* LBA LSB */
1285 s->io_buffer[0x13] = 0x00; /* Erase flag */
1286 s->io_buffer[0x18] = 0x00; /* Hot count */
1287 s->io_buffer[0x19] = 0x00; /* Hot count */
1288 s->io_buffer[0x1a] = 0x01; /* Hot count */
1289 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1290 ide_set_irq(s->bus);
1291 break;
1292 case CFA_ACCESS_METADATA_STORAGE:
1293 switch (s->feature) {
1294 case 0x02: /* Inquiry Metadata Storage */
1295 ide_cfata_metadata_inquiry(s);
1296 break;
1297 case 0x03: /* Read Metadata Storage */
1298 ide_cfata_metadata_read(s);
1299 break;
1300 case 0x04: /* Write Metadata Storage */
1301 ide_cfata_metadata_write(s);
1302 break;
1303 default:
1304 goto abort_cmd;
1305 }
1306 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1307 s->status = 0x00; /* NOTE: READY is _not_ set */
1308 ide_set_irq(s->bus);
1309 break;
1310 case IBM_SENSE_CONDITION:
1311 switch (s->feature) {
1312 case 0x01: /* sense temperature in device */
1313 s->nsector = 0x50; /* +20 C */
1314 break;
1315 default:
1316 goto abort_cmd;
1317 }
1318 s->status = READY_STAT | SEEK_STAT;
1319 ide_set_irq(s->bus);
1320 break;
1321
1322 case WIN_SMART:
1323 if (s->hcyl != 0xc2 || s->lcyl != 0x4f)
1324 goto abort_cmd;
1325 if (!s->smart_enabled && s->feature != SMART_ENABLE)
1326 goto abort_cmd;
1327 switch (s->feature) {
1328 case SMART_DISABLE:
1329 s->smart_enabled = 0;
1330 s->status = READY_STAT | SEEK_STAT;
1331 ide_set_irq(s->bus);
1332 break;
1333 case SMART_ENABLE:
1334 s->smart_enabled = 1;
1335 s->status = READY_STAT | SEEK_STAT;
1336 ide_set_irq(s->bus);
1337 break;
1338 case SMART_ATTR_AUTOSAVE:
1339 switch (s->sector) {
1340 case 0x00:
1341 s->smart_autosave = 0;
1342 break;
1343 case 0xf1:
1344 s->smart_autosave = 1;
1345 break;
1346 default:
1347 goto abort_cmd;
1348 }
1349 s->status = READY_STAT | SEEK_STAT;
1350 ide_set_irq(s->bus);
1351 break;
1352 case SMART_STATUS:
1353 if (!s->smart_errors) {
1354 s->hcyl = 0xc2;
1355 s->lcyl = 0x4f;
1356 } else {
1357 s->hcyl = 0x2c;
1358 s->lcyl = 0xf4;
1359 }
1360 s->status = READY_STAT | SEEK_STAT;
1361 ide_set_irq(s->bus);
1362 break;
1363 case SMART_READ_THRESH:
1364 memset(s->io_buffer, 0, 0x200);
1365 s->io_buffer[0] = 0x01; /* smart struct version */
1366 for (n=0; n<30; n++) {
1367 if (smart_attributes[n][0] == 0)
1368 break;
1369 s->io_buffer[2+0+(n*12)] = smart_attributes[n][0];
1370 s->io_buffer[2+1+(n*12)] = smart_attributes[n][11];
1371 }
1372 for (n=0; n<511; n++) /* checksum */
1373 s->io_buffer[511] += s->io_buffer[n];
1374 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1375 s->status = READY_STAT | SEEK_STAT;
1376 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1377 ide_set_irq(s->bus);
1378 break;
1379 case SMART_READ_DATA:
1380 memset(s->io_buffer, 0, 0x200);
1381 s->io_buffer[0] = 0x01; /* smart struct version */
1382 for (n=0; n<30; n++) {
1383 if (smart_attributes[n][0] == 0) {
1384 break;
1385 }
1386 int i;
1387 for(i = 0; i < 11; i++) {
1388 s->io_buffer[2+i+(n*12)] = smart_attributes[n][i];
1389 }
1390 }
1391 s->io_buffer[362] = 0x02 | (s->smart_autosave?0x80:0x00);
1392 if (s->smart_selftest_count == 0) {
1393 s->io_buffer[363] = 0;
1394 } else {
1395 s->io_buffer[363] =
1396 s->smart_selftest_data[3 +
1397 (s->smart_selftest_count - 1) *
1398 24];
1399 }
1400 s->io_buffer[364] = 0x20;
1401 s->io_buffer[365] = 0x01;
1402 /* offline data collection capacity: execute + self-test*/
1403 s->io_buffer[367] = (1<<4 | 1<<3 | 1);
1404 s->io_buffer[368] = 0x03; /* smart capability (1) */
1405 s->io_buffer[369] = 0x00; /* smart capability (2) */
1406 s->io_buffer[370] = 0x01; /* error logging supported */
1407 s->io_buffer[372] = 0x02; /* minutes for poll short test */
1408 s->io_buffer[373] = 0x36; /* minutes for poll ext test */
1409 s->io_buffer[374] = 0x01; /* minutes for poll conveyance */
1410
1411 for (n=0; n<511; n++)
1412 s->io_buffer[511] += s->io_buffer[n];
1413 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1414 s->status = READY_STAT | SEEK_STAT;
1415 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1416 ide_set_irq(s->bus);
1417 break;
1418 case SMART_READ_LOG:
1419 switch (s->sector) {
1420 case 0x01: /* summary smart error log */
1421 memset(s->io_buffer, 0, 0x200);
1422 s->io_buffer[0] = 0x01;
1423 s->io_buffer[1] = 0x00; /* no error entries */
1424 s->io_buffer[452] = s->smart_errors & 0xff;
1425 s->io_buffer[453] = (s->smart_errors & 0xff00) >> 8;
1426
1427 for (n=0; n<511; n++)
1428 s->io_buffer[511] += s->io_buffer[n];
1429 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1430 break;
1431 case 0x06: /* smart self test log */
1432 memset(s->io_buffer, 0, 0x200);
1433 s->io_buffer[0] = 0x01;
1434 if (s->smart_selftest_count == 0) {
1435 s->io_buffer[508] = 0;
1436 } else {
1437 s->io_buffer[508] = s->smart_selftest_count;
1438 for (n=2; n<506; n++)
1439 s->io_buffer[n] = s->smart_selftest_data[n];
1440 }
1441 for (n=0; n<511; n++)
1442 s->io_buffer[511] += s->io_buffer[n];
1443 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1444 break;
1445 default:
1446 goto abort_cmd;
1447 }
1448 s->status = READY_STAT | SEEK_STAT;
1449 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1450 ide_set_irq(s->bus);
1451 break;
1452 case SMART_EXECUTE_OFFLINE:
1453 switch (s->sector) {
1454 case 0: /* off-line routine */
1455 case 1: /* short self test */
1456 case 2: /* extended self test */
1457 s->smart_selftest_count++;
1458 if(s->smart_selftest_count > 21)
1459 s->smart_selftest_count = 0;
1460 n = 2 + (s->smart_selftest_count - 1) * 24;
1461 s->smart_selftest_data[n] = s->sector;
1462 s->smart_selftest_data[n+1] = 0x00; /* OK and finished */
1463 s->smart_selftest_data[n+2] = 0x34; /* hour count lsb */
1464 s->smart_selftest_data[n+3] = 0x12; /* hour count msb */
1465 s->status = READY_STAT | SEEK_STAT;
1466 ide_set_irq(s->bus);
1467 break;
1468 default:
1469 goto abort_cmd;
1470 }
1471 break;
1472 default:
1473 goto abort_cmd;
1474 }
1475 break;
1476 default:
1477 /* should not be reachable */
1478 abort_cmd:
1479 ide_abort_command(s);
1480 ide_set_irq(s->bus);
1481 break;
1482 }
1483 }
1484
1485 uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
1486 {
1487 IDEBus *bus = opaque;
1488 IDEState *s = idebus_active_if(bus);
1489 uint32_t addr;
1490 int ret, hob;
1491
1492 addr = addr1 & 7;
1493 /* FIXME: HOB readback uses bit 7, but it's always set right now */
1494 //hob = s->select & (1 << 7);
1495 hob = 0;
1496 switch(addr) {
1497 case 0:
1498 ret = 0xff;
1499 break;
1500 case 1:
1501 if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1502 (s != bus->ifs && !s->bs))
1503 ret = 0;
1504 else if (!hob)
1505 ret = s->error;
1506 else
1507 ret = s->hob_feature;
1508 break;
1509 case 2:
1510 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1511 ret = 0;
1512 else if (!hob)
1513 ret = s->nsector & 0xff;
1514 else
1515 ret = s->hob_nsector;
1516 break;
1517 case 3:
1518 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1519 ret = 0;
1520 else if (!hob)
1521 ret = s->sector;
1522 else
1523 ret = s->hob_sector;
1524 break;
1525 case 4:
1526 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1527 ret = 0;
1528 else if (!hob)
1529 ret = s->lcyl;
1530 else
1531 ret = s->hob_lcyl;
1532 break;
1533 case 5:
1534 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1535 ret = 0;
1536 else if (!hob)
1537 ret = s->hcyl;
1538 else
1539 ret = s->hob_hcyl;
1540 break;
1541 case 6:
1542 if (!bus->ifs[0].bs && !bus->ifs[1].bs)
1543 ret = 0;
1544 else
1545 ret = s->select;
1546 break;
1547 default:
1548 case 7:
1549 if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1550 (s != bus->ifs && !s->bs))
1551 ret = 0;
1552 else
1553 ret = s->status;
1554 qemu_irq_lower(bus->irq);
1555 break;
1556 }
1557 #ifdef DEBUG_IDE
1558 printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
1559 #endif
1560 return ret;
1561 }
1562
1563 uint32_t ide_status_read(void *opaque, uint32_t addr)
1564 {
1565 IDEBus *bus = opaque;
1566 IDEState *s = idebus_active_if(bus);
1567 int ret;
1568
1569 if ((!bus->ifs[0].bs && !bus->ifs[1].bs) ||
1570 (s != bus->ifs && !s->bs))
1571 ret = 0;
1572 else
1573 ret = s->status;
1574 #ifdef DEBUG_IDE
1575 printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
1576 #endif
1577 return ret;
1578 }
1579
1580 void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
1581 {
1582 IDEBus *bus = opaque;
1583 IDEState *s;
1584 int i;
1585
1586 #ifdef DEBUG_IDE
1587 printf("ide: write control addr=0x%x val=%02x\n", addr, val);
1588 #endif
1589 /* common for both drives */
1590 if (!(bus->cmd & IDE_CMD_RESET) &&
1591 (val & IDE_CMD_RESET)) {
1592 /* reset low to high */
1593 for(i = 0;i < 2; i++) {
1594 s = &bus->ifs[i];
1595 s->status = BUSY_STAT | SEEK_STAT;
1596 s->error = 0x01;
1597 }
1598 } else if ((bus->cmd & IDE_CMD_RESET) &&
1599 !(val & IDE_CMD_RESET)) {
1600 /* high to low */
1601 for(i = 0;i < 2; i++) {
1602 s = &bus->ifs[i];
1603 if (s->drive_kind == IDE_CD)
1604 s->status = 0x00; /* NOTE: READY is _not_ set */
1605 else
1606 s->status = READY_STAT | SEEK_STAT;
1607 ide_set_signature(s);
1608 }
1609 }
1610
1611 bus->cmd = val;
1612 }
1613
1614 /*
1615 * Returns true if the running PIO transfer is a PIO out (i.e. data is
1616 * transferred from the device to the guest), false if it's a PIO in
1617 */
1618 static bool ide_is_pio_out(IDEState *s)
1619 {
1620 if (s->end_transfer_func == ide_sector_write ||
1621 s->end_transfer_func == ide_atapi_cmd) {
1622 return false;
1623 } else if (s->end_transfer_func == ide_sector_read ||
1624 s->end_transfer_func == ide_transfer_stop ||
1625 s->end_transfer_func == ide_atapi_cmd_reply_end ||
1626 s->end_transfer_func == ide_dummy_transfer_stop) {
1627 return true;
1628 }
1629
1630 abort();
1631 }
1632
1633 void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
1634 {
1635 IDEBus *bus = opaque;
1636 IDEState *s = idebus_active_if(bus);
1637 uint8_t *p;
1638
1639 /* PIO data access allowed only when DRQ bit is set. The result of a write
1640 * during PIO out is indeterminate, just ignore it. */
1641 if (!(s->status & DRQ_STAT) || ide_is_pio_out(s)) {
1642 return;
1643 }
1644
1645 p = s->data_ptr;
1646 *(uint16_t *)p = le16_to_cpu(val);
1647 p += 2;
1648 s->data_ptr = p;
1649 if (p >= s->data_end)
1650 s->end_transfer_func(s);
1651 }
1652
1653 uint32_t ide_data_readw(void *opaque, uint32_t addr)
1654 {
1655 IDEBus *bus = opaque;
1656 IDEState *s = idebus_active_if(bus);
1657 uint8_t *p;
1658 int ret;
1659
1660 /* PIO data access allowed only when DRQ bit is set. The result of a read
1661 * during PIO in is indeterminate, return 0 and don't move forward. */
1662 if (!(s->status & DRQ_STAT) || !ide_is_pio_out(s)) {
1663 return 0;
1664 }
1665
1666 p = s->data_ptr;
1667 ret = cpu_to_le16(*(uint16_t *)p);
1668 p += 2;
1669 s->data_ptr = p;
1670 if (p >= s->data_end)
1671 s->end_transfer_func(s);
1672 return ret;
1673 }
1674
1675 void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
1676 {
1677 IDEBus *bus = opaque;
1678 IDEState *s = idebus_active_if(bus);
1679 uint8_t *p;
1680
1681 /* PIO data access allowed only when DRQ bit is set. The result of a write
1682 * during PIO out is indeterminate, just ignore it. */
1683 if (!(s->status & DRQ_STAT) || ide_is_pio_out(s)) {
1684 return;
1685 }
1686
1687 p = s->data_ptr;
1688 *(uint32_t *)p = le32_to_cpu(val);
1689 p += 4;
1690 s->data_ptr = p;
1691 if (p >= s->data_end)
1692 s->end_transfer_func(s);
1693 }
1694
1695 uint32_t ide_data_readl(void *opaque, uint32_t addr)
1696 {
1697 IDEBus *bus = opaque;
1698 IDEState *s = idebus_active_if(bus);
1699 uint8_t *p;
1700 int ret;
1701
1702 /* PIO data access allowed only when DRQ bit is set. The result of a read
1703 * during PIO in is indeterminate, return 0 and don't move forward. */
1704 if (!(s->status & DRQ_STAT) || !ide_is_pio_out(s)) {
1705 return 0;
1706 }
1707
1708 p = s->data_ptr;
1709 ret = cpu_to_le32(*(uint32_t *)p);
1710 p += 4;
1711 s->data_ptr = p;
1712 if (p >= s->data_end)
1713 s->end_transfer_func(s);
1714 return ret;
1715 }
1716
1717 static void ide_dummy_transfer_stop(IDEState *s)
1718 {
1719 s->data_ptr = s->io_buffer;
1720 s->data_end = s->io_buffer;
1721 s->io_buffer[0] = 0xff;
1722 s->io_buffer[1] = 0xff;
1723 s->io_buffer[2] = 0xff;
1724 s->io_buffer[3] = 0xff;
1725 }
1726
1727 static void ide_reset(IDEState *s)
1728 {
1729 #ifdef DEBUG_IDE
1730 printf("ide: reset\n");
1731 #endif
1732 if (s->drive_kind == IDE_CFATA)
1733 s->mult_sectors = 0;
1734 else
1735 s->mult_sectors = MAX_MULT_SECTORS;
1736 /* ide regs */
1737 s->feature = 0;
1738 s->error = 0;
1739 s->nsector = 0;
1740 s->sector = 0;
1741 s->lcyl = 0;
1742 s->hcyl = 0;
1743
1744 /* lba48 */
1745 s->hob_feature = 0;
1746 s->hob_sector = 0;
1747 s->hob_nsector = 0;
1748 s->hob_lcyl = 0;
1749 s->hob_hcyl = 0;
1750
1751 s->select = 0xa0;
1752 s->status = READY_STAT | SEEK_STAT;
1753
1754 s->lba48 = 0;
1755
1756 /* ATAPI specific */
1757 s->sense_key = 0;
1758 s->asc = 0;
1759 s->cdrom_changed = 0;
1760 s->packet_transfer_size = 0;
1761 s->elementary_transfer_size = 0;
1762 s->io_buffer_index = 0;
1763 s->cd_sector_size = 0;
1764 s->atapi_dma = 0;
1765 /* ATA DMA state */
1766 s->io_buffer_size = 0;
1767 s->req_nb_sectors = 0;
1768
1769 ide_set_signature(s);
1770 /* init the transfer handler so that 0xffff is returned on data
1771 accesses */
1772 s->end_transfer_func = ide_dummy_transfer_stop;
1773 ide_dummy_transfer_stop(s);
1774 s->media_changed = 0;
1775 }
1776
1777 void ide_bus_reset(IDEBus *bus)
1778 {
1779 bus->unit = 0;
1780 bus->cmd = 0;
1781 ide_reset(&bus->ifs[0]);
1782 ide_reset(&bus->ifs[1]);
1783 ide_clear_hob(bus);
1784
1785 /* pending async DMA */
1786 if (bus->dma->aiocb) {
1787 #ifdef DEBUG_AIO
1788 printf("aio_cancel\n");
1789 #endif
1790 bdrv_aio_cancel(bus->dma->aiocb);
1791 bus->dma->aiocb = NULL;
1792 }
1793
1794 /* reset dma provider too */
1795 bus->dma->ops->reset(bus->dma);
1796 }
1797
1798 static const BlockDevOps ide_cd_block_ops = {
1799 .change_media_cb = ide_cd_change_cb,
1800 };
1801
1802 int ide_init_drive(IDEState *s, BlockDriverState *bs, IDEDriveKind kind,
1803 const char *version, const char *serial)
1804 {
1805 int cylinders, heads, secs;
1806 uint64_t nb_sectors;
1807
1808 s->bs = bs;
1809 s->drive_kind = kind;
1810
1811 bdrv_get_geometry(bs, &nb_sectors);
1812 bdrv_guess_geometry(bs, &cylinders, &heads, &secs);
1813 if (cylinders < 1 || cylinders > 16383) {
1814 error_report("cyls must be between 1 and 16383");
1815 return -1;
1816 }
1817 if (heads < 1 || heads > 16) {
1818 error_report("heads must be between 1 and 16");
1819 return -1;
1820 }
1821 if (secs < 1 || secs > 63) {
1822 error_report("secs must be between 1 and 63");
1823 return -1;
1824 }
1825 s->cylinders = cylinders;
1826 s->heads = heads;
1827 s->sectors = secs;
1828 s->nb_sectors = nb_sectors;
1829 /* The SMART values should be preserved across power cycles
1830 but they aren't. */
1831 s->smart_enabled = 1;
1832 s->smart_autosave = 1;
1833 s->smart_errors = 0;
1834 s->smart_selftest_count = 0;
1835 if (kind == IDE_CD) {
1836 bdrv_set_dev_ops(bs, &ide_cd_block_ops, s);
1837 bs->buffer_alignment = 2048;
1838 } else {
1839 if (!bdrv_is_inserted(s->bs)) {
1840 error_report("Device needs media, but drive is empty");
1841 return -1;
1842 }
1843 if (bdrv_is_read_only(bs)) {
1844 error_report("Can't use a read-only drive");
1845 return -1;
1846 }
1847 }
1848 if (serial) {
1849 strncpy(s->drive_serial_str, serial, sizeof(s->drive_serial_str));
1850 } else {
1851 snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),
1852 "QM%05d", s->drive_serial);
1853 }
1854 if (version) {
1855 pstrcpy(s->version, sizeof(s->version), version);
1856 } else {
1857 pstrcpy(s->version, sizeof(s->version), QEMU_VERSION);
1858 }
1859
1860 ide_reset(s);
1861 bdrv_set_removable(bs, s->drive_kind == IDE_CD);
1862 return 0;
1863 }
1864
1865 static void ide_init1(IDEBus *bus, int unit)
1866 {
1867 static int drive_serial = 1;
1868 IDEState *s = &bus->ifs[unit];
1869
1870 s->bus = bus;
1871 s->unit = unit;
1872 s->drive_serial = drive_serial++;
1873 /* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
1874 s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
1875 s->io_buffer = qemu_memalign(2048, s->io_buffer_total_len);
1876 memset(s->io_buffer, 0, s->io_buffer_total_len);
1877
1878 s->smart_selftest_data = qemu_blockalign(s->bs, 512);
1879 memset(s->smart_selftest_data, 0, 512);
1880
1881 s->sector_write_timer = qemu_new_timer_ns(vm_clock,
1882 ide_sector_write_timer_cb, s);
1883 }
1884
1885 static void ide_nop_start(IDEDMA *dma, IDEState *s,
1886 BlockDriverCompletionFunc *cb)
1887 {
1888 }
1889
1890 static int ide_nop(IDEDMA *dma)
1891 {
1892 return 0;
1893 }
1894
1895 static int ide_nop_int(IDEDMA *dma, int x)
1896 {
1897 return 0;
1898 }
1899
1900 static void ide_nop_restart(void *opaque, int x, int y)
1901 {
1902 }
1903
1904 static const IDEDMAOps ide_dma_nop_ops = {
1905 .start_dma = ide_nop_start,
1906 .start_transfer = ide_nop,
1907 .prepare_buf = ide_nop_int,
1908 .rw_buf = ide_nop_int,
1909 .set_unit = ide_nop_int,
1910 .add_status = ide_nop_int,
1911 .set_inactive = ide_nop,
1912 .restart_cb = ide_nop_restart,
1913 .reset = ide_nop,
1914 };
1915
1916 static IDEDMA ide_dma_nop = {
1917 .ops = &ide_dma_nop_ops,
1918 .aiocb = NULL,
1919 };
1920
1921 void ide_init2(IDEBus *bus, qemu_irq irq)
1922 {
1923 int i;
1924
1925 for(i = 0; i < 2; i++) {
1926 ide_init1(bus, i);
1927 ide_reset(&bus->ifs[i]);
1928 }
1929 bus->irq = irq;
1930 bus->dma = &ide_dma_nop;
1931 }
1932
1933 /* TODO convert users to qdev and remove */
1934 void ide_init2_with_non_qdev_drives(IDEBus *bus, DriveInfo *hd0,
1935 DriveInfo *hd1, qemu_irq irq)
1936 {
1937 int i;
1938 DriveInfo *dinfo;
1939
1940 for(i = 0; i < 2; i++) {
1941 dinfo = i == 0 ? hd0 : hd1;
1942 ide_init1(bus, i);
1943 if (dinfo) {
1944 if (ide_init_drive(&bus->ifs[i], dinfo->bdrv,
1945 dinfo->media_cd ? IDE_CD : IDE_HD, NULL,
1946 *dinfo->serial ? dinfo->serial : NULL) < 0) {
1947 error_report("Can't set up IDE drive %s", dinfo->id);
1948 exit(1);
1949 }
1950 bdrv_attach_dev_nofail(dinfo->bdrv, &bus->ifs[i]);
1951 } else {
1952 ide_reset(&bus->ifs[i]);
1953 }
1954 }
1955 bus->irq = irq;
1956 bus->dma = &ide_dma_nop;
1957 }
1958
1959 void ide_init_ioport(IDEBus *bus, int iobase, int iobase2)
1960 {
1961 register_ioport_write(iobase, 8, 1, ide_ioport_write, bus);
1962 register_ioport_read(iobase, 8, 1, ide_ioport_read, bus);
1963 if (iobase2) {
1964 register_ioport_read(iobase2, 1, 1, ide_status_read, bus);
1965 register_ioport_write(iobase2, 1, 1, ide_cmd_write, bus);
1966 }
1967
1968 /* data ports */
1969 register_ioport_write(iobase, 2, 2, ide_data_writew, bus);
1970 register_ioport_read(iobase, 2, 2, ide_data_readw, bus);
1971 register_ioport_write(iobase, 4, 4, ide_data_writel, bus);
1972 register_ioport_read(iobase, 4, 4, ide_data_readl, bus);
1973 }
1974
1975 static bool is_identify_set(void *opaque, int version_id)
1976 {
1977 IDEState *s = opaque;
1978
1979 return s->identify_set != 0;
1980 }
1981
1982 static EndTransferFunc* transfer_end_table[] = {
1983 ide_sector_read,
1984 ide_sector_write,
1985 ide_transfer_stop,
1986 ide_atapi_cmd_reply_end,
1987 ide_atapi_cmd,
1988 ide_dummy_transfer_stop,
1989 };
1990
1991 static int transfer_end_table_idx(EndTransferFunc *fn)
1992 {
1993 int i;
1994
1995 for (i = 0; i < ARRAY_SIZE(transfer_end_table); i++)
1996 if (transfer_end_table[i] == fn)
1997 return i;
1998
1999 return -1;
2000 }
2001
2002 static int ide_drive_post_load(void *opaque, int version_id)
2003 {
2004 IDEState *s = opaque;
2005
2006 if (version_id < 3) {
2007 if (s->sense_key == SENSE_UNIT_ATTENTION &&
2008 s->asc == ASC_MEDIUM_MAY_HAVE_CHANGED) {
2009 s->cdrom_changed = 1;
2010 }
2011 }
2012 return 0;
2013 }
2014
2015 static int ide_drive_pio_post_load(void *opaque, int version_id)
2016 {
2017 IDEState *s = opaque;
2018
2019 if (s->end_transfer_fn_idx > ARRAY_SIZE(transfer_end_table)) {
2020 return -EINVAL;
2021 }
2022 s->end_transfer_func = transfer_end_table[s->end_transfer_fn_idx];
2023 s->data_ptr = s->io_buffer + s->cur_io_buffer_offset;
2024 s->data_end = s->data_ptr + s->cur_io_buffer_len;
2025
2026 return 0;
2027 }
2028
2029 static void ide_drive_pio_pre_save(void *opaque)
2030 {
2031 IDEState *s = opaque;
2032 int idx;
2033
2034 s->cur_io_buffer_offset = s->data_ptr - s->io_buffer;
2035 s->cur_io_buffer_len = s->data_end - s->data_ptr;
2036
2037 idx = transfer_end_table_idx(s->end_transfer_func);
2038 if (idx == -1) {
2039 fprintf(stderr, "%s: invalid end_transfer_func for DRQ_STAT\n",
2040 __func__);
2041 s->end_transfer_fn_idx = 2;
2042 } else {
2043 s->end_transfer_fn_idx = idx;
2044 }
2045 }
2046
2047 static bool ide_drive_pio_state_needed(void *opaque)
2048 {
2049 IDEState *s = opaque;
2050
2051 return ((s->status & DRQ_STAT) != 0)
2052 || (s->bus->error_status & BM_STATUS_PIO_RETRY);
2053 }
2054
2055 static bool ide_atapi_gesn_needed(void *opaque)
2056 {
2057 IDEState *s = opaque;
2058
2059 return s->events.new_media || s->events.eject_request;
2060 }
2061
2062 static bool ide_error_needed(void *opaque)
2063 {
2064 IDEBus *bus = opaque;
2065
2066 return (bus->error_status != 0);
2067 }
2068
2069 /* Fields for GET_EVENT_STATUS_NOTIFICATION ATAPI command */
2070 static const VMStateDescription vmstate_ide_atapi_gesn_state = {
2071 .name ="ide_drive/atapi/gesn_state",
2072 .version_id = 1,
2073 .minimum_version_id = 1,
2074 .minimum_version_id_old = 1,
2075 .fields = (VMStateField []) {
2076 VMSTATE_BOOL(events.new_media, IDEState),
2077 VMSTATE_BOOL(events.eject_request, IDEState),
2078 VMSTATE_END_OF_LIST()
2079 }
2080 };
2081
2082 static const VMStateDescription vmstate_ide_drive_pio_state = {
2083 .name = "ide_drive/pio_state",
2084 .version_id = 1,
2085 .minimum_version_id = 1,
2086 .minimum_version_id_old = 1,
2087 .pre_save = ide_drive_pio_pre_save,
2088 .post_load = ide_drive_pio_post_load,
2089 .fields = (VMStateField []) {
2090 VMSTATE_INT32(req_nb_sectors, IDEState),
2091 VMSTATE_VARRAY_INT32(io_buffer, IDEState, io_buffer_total_len, 1,
2092 vmstate_info_uint8, uint8_t),
2093 VMSTATE_INT32(cur_io_buffer_offset, IDEState),
2094 VMSTATE_INT32(cur_io_buffer_len, IDEState),
2095 VMSTATE_UINT8(end_transfer_fn_idx, IDEState),
2096 VMSTATE_INT32(elementary_transfer_size, IDEState),
2097 VMSTATE_INT32(packet_transfer_size, IDEState),
2098 VMSTATE_END_OF_LIST()
2099 }
2100 };
2101
2102 const VMStateDescription vmstate_ide_drive = {
2103 .name = "ide_drive",
2104 .version_id = 3,
2105 .minimum_version_id = 0,
2106 .minimum_version_id_old = 0,
2107 .post_load = ide_drive_post_load,
2108 .fields = (VMStateField []) {
2109 VMSTATE_INT32(mult_sectors, IDEState),
2110 VMSTATE_INT32(identify_set, IDEState),
2111 VMSTATE_BUFFER_TEST(identify_data, IDEState, is_identify_set),
2112 VMSTATE_UINT8(feature, IDEState),
2113 VMSTATE_UINT8(error, IDEState),
2114 VMSTATE_UINT32(nsector, IDEState),
2115 VMSTATE_UINT8(sector, IDEState),
2116 VMSTATE_UINT8(lcyl, IDEState),
2117 VMSTATE_UINT8(hcyl, IDEState),
2118 VMSTATE_UINT8(hob_feature, IDEState),
2119 VMSTATE_UINT8(hob_sector, IDEState),
2120 VMSTATE_UINT8(hob_nsector, IDEState),
2121 VMSTATE_UINT8(hob_lcyl, IDEState),
2122 VMSTATE_UINT8(hob_hcyl, IDEState),
2123 VMSTATE_UINT8(select, IDEState),
2124 VMSTATE_UINT8(status, IDEState),
2125 VMSTATE_UINT8(lba48, IDEState),
2126 VMSTATE_UINT8(sense_key, IDEState),
2127 VMSTATE_UINT8(asc, IDEState),
2128 VMSTATE_UINT8_V(cdrom_changed, IDEState, 3),
2129 VMSTATE_END_OF_LIST()
2130 },
2131 .subsections = (VMStateSubsection []) {
2132 {
2133 .vmsd = &vmstate_ide_drive_pio_state,
2134 .needed = ide_drive_pio_state_needed,
2135 }, {
2136 .vmsd = &vmstate_ide_atapi_gesn_state,
2137 .needed = ide_atapi_gesn_needed,
2138 }, {
2139 /* empty */
2140 }
2141 }
2142 };
2143
2144 static const VMStateDescription vmstate_ide_error_status = {
2145 .name ="ide_bus/error",
2146 .version_id = 1,
2147 .minimum_version_id = 1,
2148 .minimum_version_id_old = 1,
2149 .fields = (VMStateField []) {
2150 VMSTATE_INT32(error_status, IDEBus),
2151 VMSTATE_END_OF_LIST()
2152 }
2153 };
2154
2155 const VMStateDescription vmstate_ide_bus = {
2156 .name = "ide_bus",
2157 .version_id = 1,
2158 .minimum_version_id = 1,
2159 .minimum_version_id_old = 1,
2160 .fields = (VMStateField []) {
2161 VMSTATE_UINT8(cmd, IDEBus),
2162 VMSTATE_UINT8(unit, IDEBus),
2163 VMSTATE_END_OF_LIST()
2164 },
2165 .subsections = (VMStateSubsection []) {
2166 {
2167 .vmsd = &vmstate_ide_error_status,
2168 .needed = ide_error_needed,
2169 }, {
2170 /* empty */
2171 }
2172 }
2173 };
2174
2175 void ide_drive_get(DriveInfo **hd, int max_bus)
2176 {
2177 int i;
2178
2179 if (drive_get_max_bus(IF_IDE) >= max_bus) {
2180 fprintf(stderr, "qemu: too many IDE bus: %d\n", max_bus);
2181 exit(1);
2182 }
2183
2184 for(i = 0; i < max_bus * MAX_IDE_DEVS; i++) {
2185 hd[i] = drive_get(IF_IDE, i / MAX_IDE_DEVS, i % MAX_IDE_DEVS);
2186 }
2187 }
QEmu