]> git.proxmox.com Git - mirror_qemu.git/blob - hw/ide/core.c
projects / mirror_qemu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
util: include the target address in socket connect failures
[mirror_qemu.git] / hw / ide / core.c
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
26 #include "qemu/osdep.h"
27 #include "hw/isa/isa.h"
28 #include "migration/vmstate.h"
29 #include "qemu/error-report.h"
30 #include "qemu/main-loop.h"
31 #include "qemu/timer.h"
32 #include "sysemu/sysemu.h"
33 #include "sysemu/blockdev.h"
34 #include "sysemu/dma.h"
35 #include "hw/block/block.h"
36 #include "sysemu/block-backend.h"
37 #include "qapi/error.h"
38 #include "qemu/cutils.h"
39 #include "sysemu/replay.h"
40 #include "sysemu/runstate.h"
41 #include "hw/ide/internal.h"
42 #include "trace.h"
43
44 /* These values were based on a Seagate ST3500418AS but have been modified
45 to make more sense in QEMU */
46 static const int smart_attributes[][12] = {
47 /* id, flags, hflags, val, wrst, raw (6 bytes), threshold */
48 /* raw read error rate*/
49 { 0x01, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06},
50 /* spin up */
51 { 0x03, 0x03, 0x00, 0x64, 0x64, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
52 /* start stop count */
53 { 0x04, 0x02, 0x00, 0x64, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14},
54 /* remapped sectors */
55 { 0x05, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24},
56 /* power on hours */
57 { 0x09, 0x03, 0x00, 0x64, 0x64, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
58 /* power cycle count */
59 { 0x0c, 0x03, 0x00, 0x64, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
60 /* airflow-temperature-celsius */
61 { 190, 0x03, 0x00, 0x45, 0x45, 0x1f, 0x00, 0x1f, 0x1f, 0x00, 0x00, 0x32},
62 };
63
64 const char *IDE_DMA_CMD_lookup[IDE_DMA__COUNT] = {
65 [IDE_DMA_READ] = "DMA READ",
66 [IDE_DMA_WRITE] = "DMA WRITE",
67 [IDE_DMA_TRIM] = "DMA TRIM",
68 [IDE_DMA_ATAPI] = "DMA ATAPI"
69 };
70
71 static const char *IDE_DMA_CMD_str(enum ide_dma_cmd enval)
72 {
73 if ((unsigned)enval < IDE_DMA__COUNT) {
74 return IDE_DMA_CMD_lookup[enval];
75 }
76 return "DMA UNKNOWN CMD";
77 }
78
79 static void ide_dummy_transfer_stop(IDEState *s);
80
81 static void padstr(char *str, const char *src, int len)
82 {
83 int i, v;
84 for(i = 0; i < len; i++) {
85 if (*src)
86 v = *src++;
87 else
88 v = ' ';
89 str[i^1] = v;
90 }
91 }
92
93 static void put_le16(uint16_t *p, unsigned int v)
94 {
95 *p = cpu_to_le16(v);
96 }
97
98 static void ide_identify_size(IDEState *s)
99 {
100 uint16_t *p = (uint16_t *)s->identify_data;
101 put_le16(p + 60, s->nb_sectors);
102 put_le16(p + 61, s->nb_sectors >> 16);
103 put_le16(p + 100, s->nb_sectors);
104 put_le16(p + 101, s->nb_sectors >> 16);
105 put_le16(p + 102, s->nb_sectors >> 32);
106 put_le16(p + 103, s->nb_sectors >> 48);
107 }
108
109 static void ide_identify(IDEState *s)
110 {
111 uint16_t *p;
112 unsigned int oldsize;
113 IDEDevice *dev = s->unit ? s->bus->slave : s->bus->master;
114
115 p = (uint16_t *)s->identify_data;
116 if (s->identify_set) {
117 goto fill_buffer;
118 }
119 memset(p, 0, sizeof(s->identify_data));
120
121 put_le16(p + 0, 0x0040);
122 put_le16(p + 1, s->cylinders);
123 put_le16(p + 3, s->heads);
124 put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
125 put_le16(p + 5, 512); /* XXX: retired, remove ? */
126 put_le16(p + 6, s->sectors);
127 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
128 put_le16(p + 20, 3); /* XXX: retired, remove ? */
129 put_le16(p + 21, 512); /* cache size in sectors */
130 put_le16(p + 22, 4); /* ecc bytes */
131 padstr((char *)(p + 23), s->version, 8); /* firmware version */
132 padstr((char *)(p + 27), s->drive_model_str, 40); /* model */
133 #if MAX_MULT_SECTORS > 1
134 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
135 #endif
136 put_le16(p + 48, 1); /* dword I/O */
137 put_le16(p + 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
138 put_le16(p + 51, 0x200); /* PIO transfer cycle */
139 put_le16(p + 52, 0x200); /* DMA transfer cycle */
140 put_le16(p + 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
141 put_le16(p + 54, s->cylinders);
142 put_le16(p + 55, s->heads);
143 put_le16(p + 56, s->sectors);
144 oldsize = s->cylinders * s->heads * s->sectors;
145 put_le16(p + 57, oldsize);
146 put_le16(p + 58, oldsize >> 16);
147 if (s->mult_sectors)
148 put_le16(p + 59, 0x100 | s->mult_sectors);
149 /* *(p + 60) := nb_sectors -- see ide_identify_size */
150 /* *(p + 61) := nb_sectors >> 16 -- see ide_identify_size */
151 put_le16(p + 62, 0x07); /* single word dma0-2 supported */
152 put_le16(p + 63, 0x07); /* mdma0-2 supported */
153 put_le16(p + 64, 0x03); /* pio3-4 supported */
154 put_le16(p + 65, 120);
155 put_le16(p + 66, 120);
156 put_le16(p + 67, 120);
157 put_le16(p + 68, 120);
158 if (dev && dev->conf.discard_granularity) {
159 put_le16(p + 69, (1 << 14)); /* determinate TRIM behavior */
160 }
161
162 if (s->ncq_queues) {
163 put_le16(p + 75, s->ncq_queues - 1);
164 /* NCQ supported */
165 put_le16(p + 76, (1 << 8));
166 }
167
168 put_le16(p + 80, 0xf0); /* ata3 -> ata6 supported */
169 put_le16(p + 81, 0x16); /* conforms to ata5 */
170 /* 14=NOP supported, 5=WCACHE supported, 0=SMART supported */
171 put_le16(p + 82, (1 << 14) | (1 << 5) | 1);
172 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
173 put_le16(p + 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
174 /* 14=set to 1, 8=has WWN, 1=SMART self test, 0=SMART error logging */
175 if (s->wwn) {
176 put_le16(p + 84, (1 << 14) | (1 << 8) | 0);
177 } else {
178 put_le16(p + 84, (1 << 14) | 0);
179 }
180 /* 14 = NOP supported, 5=WCACHE enabled, 0=SMART feature set enabled */
181 if (blk_enable_write_cache(s->blk)) {
182 put_le16(p + 85, (1 << 14) | (1 << 5) | 1);
183 } else {
184 put_le16(p + 85, (1 << 14) | 1);
185 }
186 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
187 put_le16(p + 86, (1 << 13) | (1 <<12) | (1 << 10));
188 /* 14=set to 1, 8=has WWN, 1=SMART self test, 0=SMART error logging */
189 if (s->wwn) {
190 put_le16(p + 87, (1 << 14) | (1 << 8) | 0);
191 } else {
192 put_le16(p + 87, (1 << 14) | 0);
193 }
194 put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
195 put_le16(p + 93, 1 | (1 << 14) | 0x2000);
196 /* *(p + 100) := nb_sectors -- see ide_identify_size */
197 /* *(p + 101) := nb_sectors >> 16 -- see ide_identify_size */
198 /* *(p + 102) := nb_sectors >> 32 -- see ide_identify_size */
199 /* *(p + 103) := nb_sectors >> 48 -- see ide_identify_size */
200
201 if (dev && dev->conf.physical_block_size)
202 put_le16(p + 106, 0x6000 | get_physical_block_exp(&dev->conf));
203 if (s->wwn) {
204 /* LE 16-bit words 111-108 contain 64-bit World Wide Name */
205 put_le16(p + 108, s->wwn >> 48);
206 put_le16(p + 109, s->wwn >> 32);
207 put_le16(p + 110, s->wwn >> 16);
208 put_le16(p + 111, s->wwn);
209 }
210 if (dev && dev->conf.discard_granularity) {
211 put_le16(p + 169, 1); /* TRIM support */
212 }
213 if (dev) {
214 put_le16(p + 217, dev->rotation_rate); /* Nominal media rotation rate */
215 }
216
217 ide_identify_size(s);
218 s->identify_set = 1;
219
220 fill_buffer:
221 memcpy(s->io_buffer, p, sizeof(s->identify_data));
222 }
223
224 static void ide_atapi_identify(IDEState *s)
225 {
226 uint16_t *p;
227
228 p = (uint16_t *)s->identify_data;
229 if (s->identify_set) {
230 goto fill_buffer;
231 }
232 memset(p, 0, sizeof(s->identify_data));
233
234 /* Removable CDROM, 50us response, 12 byte packets */
235 put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
236 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
237 put_le16(p + 20, 3); /* buffer type */
238 put_le16(p + 21, 512); /* cache size in sectors */
239 put_le16(p + 22, 4); /* ecc bytes */
240 padstr((char *)(p + 23), s->version, 8); /* firmware version */
241 padstr((char *)(p + 27), s->drive_model_str, 40); /* model */
242 put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
243 #ifdef USE_DMA_CDROM
244 put_le16(p + 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
245 put_le16(p + 53, 7); /* words 64-70, 54-58, 88 valid */
246 put_le16(p + 62, 7); /* single word dma0-2 supported */
247 put_le16(p + 63, 7); /* mdma0-2 supported */
248 #else
249 put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
250 put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
251 put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
252 #endif
253 put_le16(p + 64, 3); /* pio3-4 supported */
254 put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
255 put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
256 put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
257 put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
258
259 put_le16(p + 71, 30); /* in ns */
260 put_le16(p + 72, 30); /* in ns */
261
262 if (s->ncq_queues) {
263 put_le16(p + 75, s->ncq_queues - 1);
264 /* NCQ supported */
265 put_le16(p + 76, (1 << 8));
266 }
267
268 put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
269 if (s->wwn) {
270 put_le16(p + 84, (1 << 8)); /* supports WWN for words 108-111 */
271 put_le16(p + 87, (1 << 8)); /* WWN enabled */
272 }
273
274 #ifdef USE_DMA_CDROM
275 put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
276 #endif
277
278 if (s->wwn) {
279 /* LE 16-bit words 111-108 contain 64-bit World Wide Name */
280 put_le16(p + 108, s->wwn >> 48);
281 put_le16(p + 109, s->wwn >> 32);
282 put_le16(p + 110, s->wwn >> 16);
283 put_le16(p + 111, s->wwn);
284 }
285
286 s->identify_set = 1;
287
288 fill_buffer:
289 memcpy(s->io_buffer, p, sizeof(s->identify_data));
290 }
291
292 static void ide_cfata_identify_size(IDEState *s)
293 {
294 uint16_t *p = (uint16_t *)s->identify_data;
295 put_le16(p + 7, s->nb_sectors >> 16); /* Sectors per card */
296 put_le16(p + 8, s->nb_sectors); /* Sectors per card */
297 put_le16(p + 60, s->nb_sectors); /* Total LBA sectors */
298 put_le16(p + 61, s->nb_sectors >> 16); /* Total LBA sectors */
299 }
300
301 static void ide_cfata_identify(IDEState *s)
302 {
303 uint16_t *p;
304 uint32_t cur_sec;
305
306 p = (uint16_t *)s->identify_data;
307 if (s->identify_set) {
308 goto fill_buffer;
309 }
310 memset(p, 0, sizeof(s->identify_data));
311
312 cur_sec = s->cylinders * s->heads * s->sectors;
313
314 put_le16(p + 0, 0x848a); /* CF Storage Card signature */
315 put_le16(p + 1, s->cylinders); /* Default cylinders */
316 put_le16(p + 3, s->heads); /* Default heads */
317 put_le16(p + 6, s->sectors); /* Default sectors per track */
318 /* *(p + 7) := nb_sectors >> 16 -- see ide_cfata_identify_size */
319 /* *(p + 8) := nb_sectors -- see ide_cfata_identify_size */
320 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
321 put_le16(p + 22, 0x0004); /* ECC bytes */
322 padstr((char *) (p + 23), s->version, 8); /* Firmware Revision */
323 padstr((char *) (p + 27), s->drive_model_str, 40);/* Model number */
324 #if MAX_MULT_SECTORS > 1
325 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
326 #else
327 put_le16(p + 47, 0x0000);
328 #endif
329 put_le16(p + 49, 0x0f00); /* Capabilities */
330 put_le16(p + 51, 0x0002); /* PIO cycle timing mode */
331 put_le16(p + 52, 0x0001); /* DMA cycle timing mode */
332 put_le16(p + 53, 0x0003); /* Translation params valid */
333 put_le16(p + 54, s->cylinders); /* Current cylinders */
334 put_le16(p + 55, s->heads); /* Current heads */
335 put_le16(p + 56, s->sectors); /* Current sectors */
336 put_le16(p + 57, cur_sec); /* Current capacity */
337 put_le16(p + 58, cur_sec >> 16); /* Current capacity */
338 if (s->mult_sectors) /* Multiple sector setting */
339 put_le16(p + 59, 0x100 | s->mult_sectors);
340 /* *(p + 60) := nb_sectors -- see ide_cfata_identify_size */
341 /* *(p + 61) := nb_sectors >> 16 -- see ide_cfata_identify_size */
342 put_le16(p + 63, 0x0203); /* Multiword DMA capability */
343 put_le16(p + 64, 0x0001); /* Flow Control PIO support */
344 put_le16(p + 65, 0x0096); /* Min. Multiword DMA cycle */
345 put_le16(p + 66, 0x0096); /* Rec. Multiword DMA cycle */
346 put_le16(p + 68, 0x00b4); /* Min. PIO cycle time */
347 put_le16(p + 82, 0x400c); /* Command Set supported */
348 put_le16(p + 83, 0x7068); /* Command Set supported */
349 put_le16(p + 84, 0x4000); /* Features supported */
350 put_le16(p + 85, 0x000c); /* Command Set enabled */
351 put_le16(p + 86, 0x7044); /* Command Set enabled */
352 put_le16(p + 87, 0x4000); /* Features enabled */
353 put_le16(p + 91, 0x4060); /* Current APM level */
354 put_le16(p + 129, 0x0002); /* Current features option */
355 put_le16(p + 130, 0x0005); /* Reassigned sectors */
356 put_le16(p + 131, 0x0001); /* Initial power mode */
357 put_le16(p + 132, 0x0000); /* User signature */
358 put_le16(p + 160, 0x8100); /* Power requirement */
359 put_le16(p + 161, 0x8001); /* CF command set */
360
361 ide_cfata_identify_size(s);
362 s->identify_set = 1;
363
364 fill_buffer:
365 memcpy(s->io_buffer, p, sizeof(s->identify_data));
366 }
367
368 static void ide_set_signature(IDEState *s)
369 {
370 s->select &= ~(ATA_DEV_HS); /* clear head */
371 /* put signature */
372 s->nsector = 1;
373 s->sector = 1;
374 if (s->drive_kind == IDE_CD) {
375 s->lcyl = 0x14;
376 s->hcyl = 0xeb;
377 } else if (s->blk) {
378 s->lcyl = 0;
379 s->hcyl = 0;
380 } else {
381 s->lcyl = 0xff;
382 s->hcyl = 0xff;
383 }
384 }
385
386 static bool ide_sect_range_ok(IDEState *s,
387 uint64_t sector, uint64_t nb_sectors)
388 {
389 uint64_t total_sectors;
390
391 blk_get_geometry(s->blk, &total_sectors);
392 if (sector > total_sectors || nb_sectors > total_sectors - sector) {
393 return false;
394 }
395 return true;
396 }
397
398 typedef struct TrimAIOCB {
399 BlockAIOCB common;
400 IDEState *s;
401 QEMUBH *bh;
402 int ret;
403 QEMUIOVector *qiov;
404 BlockAIOCB *aiocb;
405 int i, j;
406 } TrimAIOCB;
407
408 static void trim_aio_cancel(BlockAIOCB *acb)
409 {
410 TrimAIOCB *iocb = container_of(acb, TrimAIOCB, common);
411
412 /* Exit the loop so ide_issue_trim_cb will not continue */
413 iocb->j = iocb->qiov->niov - 1;
414 iocb->i = (iocb->qiov->iov[iocb->j].iov_len / 8) - 1;
415
416 iocb->ret = -ECANCELED;
417
418 if (iocb->aiocb) {
419 blk_aio_cancel_async(iocb->aiocb);
420 iocb->aiocb = NULL;
421 }
422 }
423
424 static const AIOCBInfo trim_aiocb_info = {
425 .aiocb_size = sizeof(TrimAIOCB),
426 .cancel_async = trim_aio_cancel,
427 };
428
429 static void ide_trim_bh_cb(void *opaque)
430 {
431 TrimAIOCB *iocb = opaque;
432
433 iocb->common.cb(iocb->common.opaque, iocb->ret);
434
435 qemu_bh_delete(iocb->bh);
436 iocb->bh = NULL;
437 qemu_aio_unref(iocb);
438 }
439
440 static void ide_issue_trim_cb(void *opaque, int ret)
441 {
442 TrimAIOCB *iocb = opaque;
443 IDEState *s = iocb->s;
444
445 if (iocb->i >= 0) {
446 if (ret >= 0) {
447 block_acct_done(blk_get_stats(s->blk), &s->acct);
448 } else {
449 block_acct_failed(blk_get_stats(s->blk), &s->acct);
450 }
451 }
452
453 if (ret >= 0) {
454 while (iocb->j < iocb->qiov->niov) {
455 int j = iocb->j;
456 while (++iocb->i < iocb->qiov->iov[j].iov_len / 8) {
457 int i = iocb->i;
458 uint64_t *buffer = iocb->qiov->iov[j].iov_base;
459
460 /* 6-byte LBA + 2-byte range per entry */
461 uint64_t entry = le64_to_cpu(buffer[i]);
462 uint64_t sector = entry & 0x0000ffffffffffffULL;
463 uint16_t count = entry >> 48;
464
465 if (count == 0) {
466 continue;
467 }
468
469 if (!ide_sect_range_ok(s, sector, count)) {
470 block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_UNMAP);
471 iocb->ret = -EINVAL;
472 goto done;
473 }
474
475 block_acct_start(blk_get_stats(s->blk), &s->acct,
476 count << BDRV_SECTOR_BITS, BLOCK_ACCT_UNMAP);
477
478 /* Got an entry! Submit and exit. */
479 iocb->aiocb = blk_aio_pdiscard(s->blk,
480 sector << BDRV_SECTOR_BITS,
481 count << BDRV_SECTOR_BITS,
482 ide_issue_trim_cb, opaque);
483 return;
484 }
485
486 iocb->j++;
487 iocb->i = -1;
488 }
489 } else {
490 iocb->ret = ret;
491 }
492
493 done:
494 iocb->aiocb = NULL;
495 if (iocb->bh) {
496 replay_bh_schedule_event(iocb->bh);
497 }
498 }
499
500 BlockAIOCB *ide_issue_trim(
501 int64_t offset, QEMUIOVector *qiov,
502 BlockCompletionFunc *cb, void *cb_opaque, void *opaque)
503 {
504 IDEState *s = opaque;
505 TrimAIOCB *iocb;
506
507 iocb = blk_aio_get(&trim_aiocb_info, s->blk, cb, cb_opaque);
508 iocb->s = s;
509 iocb->bh = qemu_bh_new(ide_trim_bh_cb, iocb);
510 iocb->ret = 0;
511 iocb->qiov = qiov;
512 iocb->i = -1;
513 iocb->j = 0;
514 ide_issue_trim_cb(iocb, 0);
515 return &iocb->common;
516 }
517
518 void ide_abort_command(IDEState *s)
519 {
520 ide_transfer_stop(s);
521 s->status = READY_STAT | ERR_STAT;
522 s->error = ABRT_ERR;
523 }
524
525 static void ide_set_retry(IDEState *s)
526 {
527 s->bus->retry_unit = s->unit;
528 s->bus->retry_sector_num = ide_get_sector(s);
529 s->bus->retry_nsector = s->nsector;
530 }
531
532 static void ide_clear_retry(IDEState *s)
533 {
534 s->bus->retry_unit = -1;
535 s->bus->retry_sector_num = 0;
536 s->bus->retry_nsector = 0;
537 }
538
539 /* prepare data transfer and tell what to do after */
540 bool ide_transfer_start_norecurse(IDEState *s, uint8_t *buf, int size,
541 EndTransferFunc *end_transfer_func)
542 {
543 s->data_ptr = buf;
544 s->data_end = buf + size;
545 ide_set_retry(s);
546 if (!(s->status & ERR_STAT)) {
547 s->status |= DRQ_STAT;
548 }
549 if (!s->bus->dma->ops->pio_transfer) {
550 s->end_transfer_func = end_transfer_func;
551 return false;
552 }
553 s->bus->dma->ops->pio_transfer(s->bus->dma);
554 return true;
555 }
556
557 void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
558 EndTransferFunc *end_transfer_func)
559 {
560 if (ide_transfer_start_norecurse(s, buf, size, end_transfer_func)) {
561 end_transfer_func(s);
562 }
563 }
564
565 static void ide_cmd_done(IDEState *s)
566 {
567 if (s->bus->dma->ops->cmd_done) {
568 s->bus->dma->ops->cmd_done(s->bus->dma);
569 }
570 }
571
572 static void ide_transfer_halt(IDEState *s)
573 {
574 s->end_transfer_func = ide_transfer_stop;
575 s->data_ptr = s->io_buffer;
576 s->data_end = s->io_buffer;
577 s->status &= ~DRQ_STAT;
578 }
579
580 void ide_transfer_stop(IDEState *s)
581 {
582 ide_transfer_halt(s);
583 ide_cmd_done(s);
584 }
585
586 int64_t ide_get_sector(IDEState *s)
587 {
588 int64_t sector_num;
589 if (s->select & (ATA_DEV_LBA)) {
590 if (s->lba48) {
591 sector_num = ((int64_t)s->hob_hcyl << 40) |
592 ((int64_t) s->hob_lcyl << 32) |
593 ((int64_t) s->hob_sector << 24) |
594 ((int64_t) s->hcyl << 16) |
595 ((int64_t) s->lcyl << 8) | s->sector;
596 } else {
597 /* LBA28 */
598 sector_num = ((s->select & (ATA_DEV_LBA_MSB)) << 24) |
599 (s->hcyl << 16) | (s->lcyl << 8) | s->sector;
600 }
601 } else {
602 /* CHS */
603 sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
604 (s->select & (ATA_DEV_HS)) * s->sectors + (s->sector - 1);
605 }
606
607 return sector_num;
608 }
609
610 void ide_set_sector(IDEState *s, int64_t sector_num)
611 {
612 unsigned int cyl, r;
613 if (s->select & (ATA_DEV_LBA)) {
614 if (s->lba48) {
615 s->sector = sector_num;
616 s->lcyl = sector_num >> 8;
617 s->hcyl = sector_num >> 16;
618 s->hob_sector = sector_num >> 24;
619 s->hob_lcyl = sector_num >> 32;
620 s->hob_hcyl = sector_num >> 40;
621 } else {
622 /* LBA28 */
623 s->select = (s->select & ~(ATA_DEV_LBA_MSB)) |
624 ((sector_num >> 24) & (ATA_DEV_LBA_MSB));
625 s->hcyl = (sector_num >> 16);
626 s->lcyl = (sector_num >> 8);
627 s->sector = (sector_num);
628 }
629 } else {
630 /* CHS */
631 cyl = sector_num / (s->heads * s->sectors);
632 r = sector_num % (s->heads * s->sectors);
633 s->hcyl = cyl >> 8;
634 s->lcyl = cyl;
635 s->select = (s->select & ~(ATA_DEV_HS)) |
636 ((r / s->sectors) & (ATA_DEV_HS));
637 s->sector = (r % s->sectors) + 1;
638 }
639 }
640
641 static void ide_rw_error(IDEState *s) {
642 ide_abort_command(s);
643 ide_set_irq(s->bus);
644 }
645
646 static void ide_buffered_readv_cb(void *opaque, int ret)
647 {
648 IDEBufferedRequest *req = opaque;
649 if (!req->orphaned) {
650 if (!ret) {
651 assert(req->qiov.size == req->original_qiov->size);
652 qemu_iovec_from_buf(req->original_qiov, 0,
653 req->qiov.local_iov.iov_base,
654 req->original_qiov->size);
655 }
656 req->original_cb(req->original_opaque, ret);
657 }
658 QLIST_REMOVE(req, list);
659 qemu_vfree(qemu_iovec_buf(&req->qiov));
660 g_free(req);
661 }
662
663 #define MAX_BUFFERED_REQS 16
664
665 BlockAIOCB *ide_buffered_readv(IDEState *s, int64_t sector_num,
666 QEMUIOVector *iov, int nb_sectors,
667 BlockCompletionFunc *cb, void *opaque)
668 {
669 BlockAIOCB *aioreq;
670 IDEBufferedRequest *req;
671 int c = 0;
672
673 QLIST_FOREACH(req, &s->buffered_requests, list) {
674 c++;
675 }
676 if (c > MAX_BUFFERED_REQS) {
677 return blk_abort_aio_request(s->blk, cb, opaque, -EIO);
678 }
679
680 req = g_new0(IDEBufferedRequest, 1);
681 req->original_qiov = iov;
682 req->original_cb = cb;
683 req->original_opaque = opaque;
684 qemu_iovec_init_buf(&req->qiov, blk_blockalign(s->blk, iov->size),
685 iov->size);
686
687 aioreq = blk_aio_preadv(s->blk, sector_num << BDRV_SECTOR_BITS,
688 &req->qiov, 0, ide_buffered_readv_cb, req);
689
690 QLIST_INSERT_HEAD(&s->buffered_requests, req, list);
691 return aioreq;
692 }
693
694 /**
695 * Cancel all pending DMA requests.
696 * Any buffered DMA requests are instantly canceled,
697 * but any pending unbuffered DMA requests must be waited on.
698 */
699 void ide_cancel_dma_sync(IDEState *s)
700 {
701 IDEBufferedRequest *req;
702
703 /* First invoke the callbacks of all buffered requests
704 * and flag those requests as orphaned. Ideally there
705 * are no unbuffered (Scatter Gather DMA Requests or
706 * write requests) pending and we can avoid to drain. */
707 QLIST_FOREACH(req, &s->buffered_requests, list) {
708 if (!req->orphaned) {
709 trace_ide_cancel_dma_sync_buffered(req->original_cb, req);
710 req->original_cb(req->original_opaque, -ECANCELED);
711 }
712 req->orphaned = true;
713 }
714
715 /*
716 * We can't cancel Scatter Gather DMA in the middle of the
717 * operation or a partial (not full) DMA transfer would reach
718 * the storage so we wait for completion instead (we behave
719 * like if the DMA was completed by the time the guest trying
720 * to cancel dma with bmdma_cmd_writeb with BM_CMD_START not
721 * set).
722 *
723 * In the future we'll be able to safely cancel the I/O if the
724 * whole DMA operation will be submitted to disk with a single
725 * aio operation with preadv/pwritev.
726 */
727 if (s->bus->dma->aiocb) {
728 trace_ide_cancel_dma_sync_remaining();
729 blk_drain(s->blk);
730 assert(s->bus->dma->aiocb == NULL);
731 }
732 }
733
734 static void ide_sector_read(IDEState *s);
735
736 static void ide_sector_read_cb(void *opaque, int ret)
737 {
738 IDEState *s = opaque;
739 int n;
740
741 s->pio_aiocb = NULL;
742 s->status &= ~BUSY_STAT;
743
744 if (ret != 0) {
745 if (ide_handle_rw_error(s, -ret, IDE_RETRY_PIO |
746 IDE_RETRY_READ)) {
747 return;
748 }
749 }
750
751 block_acct_done(blk_get_stats(s->blk), &s->acct);
752
753 n = s->nsector;
754 if (n > s->req_nb_sectors) {
755 n = s->req_nb_sectors;
756 }
757
758 ide_set_sector(s, ide_get_sector(s) + n);
759 s->nsector -= n;
760 /* Allow the guest to read the io_buffer */
761 ide_transfer_start(s, s->io_buffer, n * BDRV_SECTOR_SIZE, ide_sector_read);
762 ide_set_irq(s->bus);
763 }
764
765 static void ide_sector_read(IDEState *s)
766 {
767 int64_t sector_num;
768 int n;
769
770 s->status = READY_STAT | SEEK_STAT;
771 s->error = 0; /* not needed by IDE spec, but needed by Windows */
772 sector_num = ide_get_sector(s);
773 n = s->nsector;
774
775 if (n == 0) {
776 ide_transfer_stop(s);
777 return;
778 }
779
780 s->status |= BUSY_STAT;
781
782 if (n > s->req_nb_sectors) {
783 n = s->req_nb_sectors;
784 }
785
786 trace_ide_sector_read(sector_num, n);
787
788 if (!ide_sect_range_ok(s, sector_num, n)) {
789 ide_rw_error(s);
790 block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_READ);
791 return;
792 }
793
794 qemu_iovec_init_buf(&s->qiov, s->io_buffer, n * BDRV_SECTOR_SIZE);
795
796 block_acct_start(blk_get_stats(s->blk), &s->acct,
797 n * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
798 s->pio_aiocb = ide_buffered_readv(s, sector_num, &s->qiov, n,
799 ide_sector_read_cb, s);
800 }
801
802 void dma_buf_commit(IDEState *s, uint32_t tx_bytes)
803 {
804 if (s->bus->dma->ops->commit_buf) {
805 s->bus->dma->ops->commit_buf(s->bus->dma, tx_bytes);
806 }
807 s->io_buffer_offset += tx_bytes;
808 qemu_sglist_destroy(&s->sg);
809 }
810
811 void ide_set_inactive(IDEState *s, bool more)
812 {
813 s->bus->dma->aiocb = NULL;
814 ide_clear_retry(s);
815 if (s->bus->dma->ops->set_inactive) {
816 s->bus->dma->ops->set_inactive(s->bus->dma, more);
817 }
818 ide_cmd_done(s);
819 }
820
821 void ide_dma_error(IDEState *s)
822 {
823 dma_buf_commit(s, 0);
824 ide_abort_command(s);
825 ide_set_inactive(s, false);
826 ide_set_irq(s->bus);
827 }
828
829 int ide_handle_rw_error(IDEState *s, int error, int op)
830 {
831 bool is_read = (op & IDE_RETRY_READ) != 0;
832 BlockErrorAction action = blk_get_error_action(s->blk, is_read, error);
833
834 if (action == BLOCK_ERROR_ACTION_STOP) {
835 assert(s->bus->retry_unit == s->unit);
836 s->bus->error_status = op;
837 } else if (action == BLOCK_ERROR_ACTION_REPORT) {
838 block_acct_failed(blk_get_stats(s->blk), &s->acct);
839 if (IS_IDE_RETRY_DMA(op)) {
840 ide_dma_error(s);
841 } else if (IS_IDE_RETRY_ATAPI(op)) {
842 ide_atapi_io_error(s, -error);
843 } else {
844 ide_rw_error(s);
845 }
846 }
847 blk_error_action(s->blk, action, is_read, error);
848 return action != BLOCK_ERROR_ACTION_IGNORE;
849 }
850
851 static void ide_dma_cb(void *opaque, int ret)
852 {
853 IDEState *s = opaque;
854 int n;
855 int64_t sector_num;
856 uint64_t offset;
857 bool stay_active = false;
858 int32_t prep_size = 0;
859
860 if (ret == -EINVAL) {
861 ide_dma_error(s);
862 return;
863 }
864
865 if (ret < 0) {
866 if (ide_handle_rw_error(s, -ret, ide_dma_cmd_to_retry(s->dma_cmd))) {
867 s->bus->dma->aiocb = NULL;
868 dma_buf_commit(s, 0);
869 return;
870 }
871 }
872
873 if (s->io_buffer_size > s->nsector * 512) {
874 /*
875 * The PRDs were longer than needed for this request.
876 * The Active bit must remain set after the request completes.
877 */
878 n = s->nsector;
879 stay_active = true;
880 } else {
881 n = s->io_buffer_size >> 9;
882 }
883
884 sector_num = ide_get_sector(s);
885 if (n > 0) {
886 assert(n * 512 == s->sg.size);
887 dma_buf_commit(s, s->sg.size);
888 sector_num += n;
889 ide_set_sector(s, sector_num);
890 s->nsector -= n;
891 }
892
893 /* end of transfer ? */
894 if (s->nsector == 0) {
895 s->status = READY_STAT | SEEK_STAT;
896 ide_set_irq(s->bus);
897 goto eot;
898 }
899
900 /* launch next transfer */
901 n = s->nsector;
902 s->io_buffer_index = 0;
903 s->io_buffer_size = n * 512;
904 prep_size = s->bus->dma->ops->prepare_buf(s->bus->dma, s->io_buffer_size);
905 /* prepare_buf() must succeed and respect the limit */
906 assert(prep_size >= 0 && prep_size <= n * 512);
907
908 /*
909 * Now prep_size stores the number of bytes in the sglist, and
910 * s->io_buffer_size stores the number of bytes described by the PRDs.
911 */
912
913 if (prep_size < n * 512) {
914 /*
915 * The PRDs are too short for this request. Error condition!
916 * Reset the Active bit and don't raise the interrupt.
917 */
918 s->status = READY_STAT | SEEK_STAT;
919 dma_buf_commit(s, 0);
920 goto eot;
921 }
922
923 trace_ide_dma_cb(s, sector_num, n, IDE_DMA_CMD_str(s->dma_cmd));
924
925 if ((s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) &&
926 !ide_sect_range_ok(s, sector_num, n)) {
927 ide_dma_error(s);
928 block_acct_invalid(blk_get_stats(s->blk), s->acct.type);
929 return;
930 }
931
932 offset = sector_num << BDRV_SECTOR_BITS;
933 switch (s->dma_cmd) {
934 case IDE_DMA_READ:
935 s->bus->dma->aiocb = dma_blk_read(s->blk, &s->sg, offset,
936 BDRV_SECTOR_SIZE, ide_dma_cb, s);
937 break;
938 case IDE_DMA_WRITE:
939 s->bus->dma->aiocb = dma_blk_write(s->blk, &s->sg, offset,
940 BDRV_SECTOR_SIZE, ide_dma_cb, s);
941 break;
942 case IDE_DMA_TRIM:
943 s->bus->dma->aiocb = dma_blk_io(blk_get_aio_context(s->blk),
944 &s->sg, offset, BDRV_SECTOR_SIZE,
945 ide_issue_trim, s, ide_dma_cb, s,
946 DMA_DIRECTION_TO_DEVICE);
947 break;
948 default:
949 abort();
950 }
951 return;
952
953 eot:
954 if (s->dma_cmd == IDE_DMA_READ || s->dma_cmd == IDE_DMA_WRITE) {
955 block_acct_done(blk_get_stats(s->blk), &s->acct);
956 }
957 ide_set_inactive(s, stay_active);
958 }
959
960 static void ide_sector_start_dma(IDEState *s, enum ide_dma_cmd dma_cmd)
961 {
962 s->status = READY_STAT | SEEK_STAT | DRQ_STAT;
963 s->io_buffer_size = 0;
964 s->dma_cmd = dma_cmd;
965
966 switch (dma_cmd) {
967 case IDE_DMA_READ:
968 block_acct_start(blk_get_stats(s->blk), &s->acct,
969 s->nsector * BDRV_SECTOR_SIZE, BLOCK_ACCT_READ);
970 break;
971 case IDE_DMA_WRITE:
972 block_acct_start(blk_get_stats(s->blk), &s->acct,
973 s->nsector * BDRV_SECTOR_SIZE, BLOCK_ACCT_WRITE);
974 break;
975 default:
976 break;
977 }
978
979 ide_start_dma(s, ide_dma_cb);
980 }
981
982 void ide_start_dma(IDEState *s, BlockCompletionFunc *cb)
983 {
984 s->io_buffer_index = 0;
985 ide_set_retry(s);
986 if (s->bus->dma->ops->start_dma) {
987 s->bus->dma->ops->start_dma(s->bus->dma, s, cb);
988 }
989 }
990
991 static void ide_sector_write(IDEState *s);
992
993 static void ide_sector_write_timer_cb(void *opaque)
994 {
995 IDEState *s = opaque;
996 ide_set_irq(s->bus);
997 }
998
999 static void ide_sector_write_cb(void *opaque, int ret)
1000 {
1001 IDEState *s = opaque;
1002 int n;
1003
1004 s->pio_aiocb = NULL;
1005 s->status &= ~BUSY_STAT;
1006
1007 if (ret != 0) {
1008 if (ide_handle_rw_error(s, -ret, IDE_RETRY_PIO)) {
1009 return;
1010 }
1011 }
1012
1013 block_acct_done(blk_get_stats(s->blk), &s->acct);
1014
1015 n = s->nsector;
1016 if (n > s->req_nb_sectors) {
1017 n = s->req_nb_sectors;
1018 }
1019 s->nsector -= n;
1020
1021 ide_set_sector(s, ide_get_sector(s) + n);
1022 if (s->nsector == 0) {
1023 /* no more sectors to write */
1024 ide_transfer_stop(s);
1025 } else {
1026 int n1 = s->nsector;
1027 if (n1 > s->req_nb_sectors) {
1028 n1 = s->req_nb_sectors;
1029 }
1030 ide_transfer_start(s, s->io_buffer, n1 * BDRV_SECTOR_SIZE,
1031 ide_sector_write);
1032 }
1033
1034 if (win2k_install_hack && ((++s->irq_count % 16) == 0)) {
1035 /* It seems there is a bug in the Windows 2000 installer HDD
1036 IDE driver which fills the disk with empty logs when the
1037 IDE write IRQ comes too early. This hack tries to correct
1038 that at the expense of slower write performances. Use this
1039 option _only_ to install Windows 2000. You must disable it
1040 for normal use. */
1041 timer_mod(s->sector_write_timer, qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
1042 (NANOSECONDS_PER_SECOND / 1000));
1043 } else {
1044 ide_set_irq(s->bus);
1045 }
1046 }
1047
1048 static void ide_sector_write(IDEState *s)
1049 {
1050 int64_t sector_num;
1051 int n;
1052
1053 s->status = READY_STAT | SEEK_STAT | BUSY_STAT;
1054 sector_num = ide_get_sector(s);
1055
1056 n = s->nsector;
1057 if (n > s->req_nb_sectors) {
1058 n = s->req_nb_sectors;
1059 }
1060
1061 trace_ide_sector_write(sector_num, n);
1062
1063 if (!ide_sect_range_ok(s, sector_num, n)) {
1064 ide_rw_error(s);
1065 block_acct_invalid(blk_get_stats(s->blk), BLOCK_ACCT_WRITE);
1066 return;
1067 }
1068
1069 qemu_iovec_init_buf(&s->qiov, s->io_buffer, n * BDRV_SECTOR_SIZE);
1070
1071 block_acct_start(blk_get_stats(s->blk), &s->acct,
1072 n * BDRV_SECTOR_SIZE, BLOCK_ACCT_WRITE);
1073 s->pio_aiocb = blk_aio_pwritev(s->blk, sector_num << BDRV_SECTOR_BITS,
1074 &s->qiov, 0, ide_sector_write_cb, s);
1075 }
1076
1077 static void ide_flush_cb(void *opaque, int ret)
1078 {
1079 IDEState *s = opaque;
1080
1081 s->pio_aiocb = NULL;
1082
1083 if (ret < 0) {
1084 /* XXX: What sector number to set here? */
1085 if (ide_handle_rw_error(s, -ret, IDE_RETRY_FLUSH)) {
1086 return;
1087 }
1088 }
1089
1090 if (s->blk) {
1091 block_acct_done(blk_get_stats(s->blk), &s->acct);
1092 }
1093 s->status = READY_STAT | SEEK_STAT;
1094 ide_cmd_done(s);
1095 ide_set_irq(s->bus);
1096 }
1097
1098 static void ide_flush_cache(IDEState *s)
1099 {
1100 if (s->blk == NULL) {
1101 ide_flush_cb(s, 0);
1102 return;
1103 }
1104
1105 s->status |= BUSY_STAT;
1106 ide_set_retry(s);
1107 block_acct_start(blk_get_stats(s->blk), &s->acct, 0, BLOCK_ACCT_FLUSH);
1108 s->pio_aiocb = blk_aio_flush(s->blk, ide_flush_cb, s);
1109 }
1110
1111 static void ide_cfata_metadata_inquiry(IDEState *s)
1112 {
1113 uint16_t *p;
1114 uint32_t spd;
1115
1116 p = (uint16_t *) s->io_buffer;
1117 memset(p, 0, 0x200);
1118 spd = ((s->mdata_size - 1) >> 9) + 1;
1119
1120 put_le16(p + 0, 0x0001); /* Data format revision */
1121 put_le16(p + 1, 0x0000); /* Media property: silicon */
1122 put_le16(p + 2, s->media_changed); /* Media status */
1123 put_le16(p + 3, s->mdata_size & 0xffff); /* Capacity in bytes (low) */
1124 put_le16(p + 4, s->mdata_size >> 16); /* Capacity in bytes (high) */
1125 put_le16(p + 5, spd & 0xffff); /* Sectors per device (low) */
1126 put_le16(p + 6, spd >> 16); /* Sectors per device (high) */
1127 }
1128
1129 static void ide_cfata_metadata_read(IDEState *s)
1130 {
1131 uint16_t *p;
1132
1133 if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
1134 s->status = ERR_STAT;
1135 s->error = ABRT_ERR;
1136 return;
1137 }
1138
1139 p = (uint16_t *) s->io_buffer;
1140 memset(p, 0, 0x200);
1141
1142 put_le16(p + 0, s->media_changed); /* Media status */
1143 memcpy(p + 1, s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
1144 MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
1145 s->nsector << 9), 0x200 - 2));
1146 }
1147
1148 static void ide_cfata_metadata_write(IDEState *s)
1149 {
1150 if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
1151 s->status = ERR_STAT;
1152 s->error = ABRT_ERR;
1153 return;
1154 }
1155
1156 s->media_changed = 0;
1157
1158 memcpy(s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
1159 s->io_buffer + 2,
1160 MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
1161 s->nsector << 9), 0x200 - 2));
1162 }
1163
1164 /* called when the inserted state of the media has changed */
1165 static void ide_cd_change_cb(void *opaque, bool load, Error **errp)
1166 {
1167 IDEState *s = opaque;
1168 uint64_t nb_sectors;
1169
1170 s->tray_open = !load;
1171 blk_get_geometry(s->blk, &nb_sectors);
1172 s->nb_sectors = nb_sectors;
1173
1174 /*
1175 * First indicate to the guest that a CD has been removed. That's
1176 * done on the next command the guest sends us.
1177 *
1178 * Then we set UNIT_ATTENTION, by which the guest will
1179 * detect a new CD in the drive. See ide_atapi_cmd() for details.
1180 */
1181 s->cdrom_changed = 1;
1182 s->events.new_media = true;
1183 s->events.eject_request = false;
1184 ide_set_irq(s->bus);
1185 }
1186
1187 static void ide_cd_eject_request_cb(void *opaque, bool force)
1188 {
1189 IDEState *s = opaque;
1190
1191 s->events.eject_request = true;
1192 if (force) {
1193 s->tray_locked = false;
1194 }
1195 ide_set_irq(s->bus);
1196 }
1197
1198 static void ide_cmd_lba48_transform(IDEState *s, int lba48)
1199 {
1200 s->lba48 = lba48;
1201
1202 /* handle the 'magic' 0 nsector count conversion here. to avoid
1203 * fiddling with the rest of the read logic, we just store the
1204 * full sector count in ->nsector and ignore ->hob_nsector from now
1205 */
1206 if (!s->lba48) {
1207 if (!s->nsector)
1208 s->nsector = 256;
1209 } else {
1210 if (!s->nsector && !s->hob_nsector)
1211 s->nsector = 65536;
1212 else {
1213 int lo = s->nsector;
1214 int hi = s->hob_nsector;
1215
1216 s->nsector = (hi << 8) | lo;
1217 }
1218 }
1219 }
1220
1221 static void ide_clear_hob(IDEBus *bus)
1222 {
1223 /* any write clears HOB high bit of device control register */
1224 bus->cmd &= ~(IDE_CTRL_HOB);
1225 }
1226
1227 /* IOport [W]rite [R]egisters */
1228 enum ATA_IOPORT_WR {
1229 ATA_IOPORT_WR_DATA = 0,
1230 ATA_IOPORT_WR_FEATURES = 1,
1231 ATA_IOPORT_WR_SECTOR_COUNT = 2,
1232 ATA_IOPORT_WR_SECTOR_NUMBER = 3,
1233 ATA_IOPORT_WR_CYLINDER_LOW = 4,
1234 ATA_IOPORT_WR_CYLINDER_HIGH = 5,
1235 ATA_IOPORT_WR_DEVICE_HEAD = 6,
1236 ATA_IOPORT_WR_COMMAND = 7,
1237 ATA_IOPORT_WR_NUM_REGISTERS,
1238 };
1239
1240 const char *ATA_IOPORT_WR_lookup[ATA_IOPORT_WR_NUM_REGISTERS] = {
1241 [ATA_IOPORT_WR_DATA] = "Data",
1242 [ATA_IOPORT_WR_FEATURES] = "Features",
1243 [ATA_IOPORT_WR_SECTOR_COUNT] = "Sector Count",
1244 [ATA_IOPORT_WR_SECTOR_NUMBER] = "Sector Number",
1245 [ATA_IOPORT_WR_CYLINDER_LOW] = "Cylinder Low",
1246 [ATA_IOPORT_WR_CYLINDER_HIGH] = "Cylinder High",
1247 [ATA_IOPORT_WR_DEVICE_HEAD] = "Device/Head",
1248 [ATA_IOPORT_WR_COMMAND] = "Command"
1249 };
1250
1251 void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
1252 {
1253 IDEBus *bus = opaque;
1254 IDEState *s = idebus_active_if(bus);
1255 int reg_num = addr & 7;
1256
1257 trace_ide_ioport_write(addr, ATA_IOPORT_WR_lookup[reg_num], val, bus, s);
1258
1259 /* ignore writes to command block while busy with previous command */
1260 if (reg_num != 7 && (s->status & (BUSY_STAT|DRQ_STAT))) {
1261 return;
1262 }
1263
1264 /* NOTE: Device0 and Device1 both receive incoming register writes.
1265 * (They're on the same bus! They have to!) */
1266
1267 switch (reg_num) {
1268 case 0:
1269 break;
1270 case ATA_IOPORT_WR_FEATURES:
1271 ide_clear_hob(bus);
1272 bus->ifs[0].hob_feature = bus->ifs[0].feature;
1273 bus->ifs[1].hob_feature = bus->ifs[1].feature;
1274 bus->ifs[0].feature = val;
1275 bus->ifs[1].feature = val;
1276 break;
1277 case ATA_IOPORT_WR_SECTOR_COUNT:
1278 ide_clear_hob(bus);
1279 bus->ifs[0].hob_nsector = bus->ifs[0].nsector;
1280 bus->ifs[1].hob_nsector = bus->ifs[1].nsector;
1281 bus->ifs[0].nsector = val;
1282 bus->ifs[1].nsector = val;
1283 break;
1284 case ATA_IOPORT_WR_SECTOR_NUMBER:
1285 ide_clear_hob(bus);
1286 bus->ifs[0].hob_sector = bus->ifs[0].sector;
1287 bus->ifs[1].hob_sector = bus->ifs[1].sector;
1288 bus->ifs[0].sector = val;
1289 bus->ifs[1].sector = val;
1290 break;
1291 case ATA_IOPORT_WR_CYLINDER_LOW:
1292 ide_clear_hob(bus);
1293 bus->ifs[0].hob_lcyl = bus->ifs[0].lcyl;
1294 bus->ifs[1].hob_lcyl = bus->ifs[1].lcyl;
1295 bus->ifs[0].lcyl = val;
1296 bus->ifs[1].lcyl = val;
1297 break;
1298 case ATA_IOPORT_WR_CYLINDER_HIGH:
1299 ide_clear_hob(bus);
1300 bus->ifs[0].hob_hcyl = bus->ifs[0].hcyl;
1301 bus->ifs[1].hob_hcyl = bus->ifs[1].hcyl;
1302 bus->ifs[0].hcyl = val;
1303 bus->ifs[1].hcyl = val;
1304 break;
1305 case ATA_IOPORT_WR_DEVICE_HEAD:
1306 ide_clear_hob(bus);
1307 bus->ifs[0].select = val | (ATA_DEV_ALWAYS_ON);
1308 bus->ifs[1].select = val | (ATA_DEV_ALWAYS_ON);
1309 /* select drive */
1310 bus->unit = (val & (ATA_DEV_SELECT)) ? 1 : 0;
1311 break;
1312 default:
1313 case ATA_IOPORT_WR_COMMAND:
1314 ide_clear_hob(bus);
1315 qemu_irq_lower(bus->irq);
1316 ide_exec_cmd(bus, val);
1317 break;
1318 }
1319 }
1320
1321 static void ide_reset(IDEState *s)
1322 {
1323 trace_ide_reset(s);
1324
1325 if (s->pio_aiocb) {
1326 blk_aio_cancel(s->pio_aiocb);
1327 s->pio_aiocb = NULL;
1328 }
1329
1330 if (s->drive_kind == IDE_CFATA)
1331 s->mult_sectors = 0;
1332 else
1333 s->mult_sectors = MAX_MULT_SECTORS;
1334 /* ide regs */
1335 s->feature = 0;
1336 s->error = 0;
1337 s->nsector = 0;
1338 s->sector = 0;
1339 s->lcyl = 0;
1340 s->hcyl = 0;
1341
1342 /* lba48 */
1343 s->hob_feature = 0;
1344 s->hob_sector = 0;
1345 s->hob_nsector = 0;
1346 s->hob_lcyl = 0;
1347 s->hob_hcyl = 0;
1348
1349 s->select = (ATA_DEV_ALWAYS_ON);
1350 s->status = READY_STAT | SEEK_STAT;
1351
1352 s->lba48 = 0;
1353
1354 /* ATAPI specific */
1355 s->sense_key = 0;
1356 s->asc = 0;
1357 s->cdrom_changed = 0;
1358 s->packet_transfer_size = 0;
1359 s->elementary_transfer_size = 0;
1360 s->io_buffer_index = 0;
1361 s->cd_sector_size = 0;
1362 s->atapi_dma = 0;
1363 s->tray_locked = 0;
1364 s->tray_open = 0;
1365 /* ATA DMA state */
1366 s->io_buffer_size = 0;
1367 s->req_nb_sectors = 0;
1368
1369 ide_set_signature(s);
1370 /* init the transfer handler so that 0xffff is returned on data
1371 accesses */
1372 s->end_transfer_func = ide_dummy_transfer_stop;
1373 ide_dummy_transfer_stop(s);
1374 s->media_changed = 0;
1375 }
1376
1377 static bool cmd_nop(IDEState *s, uint8_t cmd)
1378 {
1379 return true;
1380 }
1381
1382 static bool cmd_device_reset(IDEState *s, uint8_t cmd)
1383 {
1384 /* Halt PIO (in the DRQ phase), then DMA */
1385 ide_transfer_halt(s);
1386 ide_cancel_dma_sync(s);
1387
1388 /* Reset any PIO commands, reset signature, etc */
1389 ide_reset(s);
1390
1391 /* RESET: ATA8-ACS3 7.10.4 "Normal Outputs";
1392 * ATA8-ACS3 Table 184 "Device Signatures for Normal Output" */
1393 s->status = 0x00;
1394
1395 /* Do not overwrite status register */
1396 return false;
1397 }
1398
1399 static bool cmd_data_set_management(IDEState *s, uint8_t cmd)
1400 {
1401 switch (s->feature) {
1402 case DSM_TRIM:
1403 if (s->blk) {
1404 ide_sector_start_dma(s, IDE_DMA_TRIM);
1405 return false;
1406 }
1407 break;
1408 }
1409
1410 ide_abort_command(s);
1411 return true;
1412 }
1413
1414 static bool cmd_identify(IDEState *s, uint8_t cmd)
1415 {
1416 if (s->blk && s->drive_kind != IDE_CD) {
1417 if (s->drive_kind != IDE_CFATA) {
1418 ide_identify(s);
1419 } else {
1420 ide_cfata_identify(s);
1421 }
1422 s->status = READY_STAT | SEEK_STAT;
1423 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1424 ide_set_irq(s->bus);
1425 return false;
1426 } else {
1427 if (s->drive_kind == IDE_CD) {
1428 ide_set_signature(s);
1429 }
1430 ide_abort_command(s);
1431 }
1432
1433 return true;
1434 }
1435
1436 static bool cmd_verify(IDEState *s, uint8_t cmd)
1437 {
1438 bool lba48 = (cmd == WIN_VERIFY_EXT);
1439
1440 /* do sector number check ? */
1441 ide_cmd_lba48_transform(s, lba48);
1442
1443 return true;
1444 }
1445
1446 static bool cmd_set_multiple_mode(IDEState *s, uint8_t cmd)
1447 {
1448 if (s->drive_kind == IDE_CFATA && s->nsector == 0) {
1449 /* Disable Read and Write Multiple */
1450 s->mult_sectors = 0;
1451 } else if ((s->nsector & 0xff) != 0 &&
1452 ((s->nsector & 0xff) > MAX_MULT_SECTORS ||
1453 (s->nsector & (s->nsector - 1)) != 0)) {
1454 ide_abort_command(s);
1455 } else {
1456 s->mult_sectors = s->nsector & 0xff;
1457 }
1458
1459 return true;
1460 }
1461
1462 static bool cmd_read_multiple(IDEState *s, uint8_t cmd)
1463 {
1464 bool lba48 = (cmd == WIN_MULTREAD_EXT);
1465
1466 if (!s->blk || !s->mult_sectors) {
1467 ide_abort_command(s);
1468 return true;
1469 }
1470
1471 ide_cmd_lba48_transform(s, lba48);
1472 s->req_nb_sectors = s->mult_sectors;
1473 ide_sector_read(s);
1474 return false;
1475 }
1476
1477 static bool cmd_write_multiple(IDEState *s, uint8_t cmd)
1478 {
1479 bool lba48 = (cmd == WIN_MULTWRITE_EXT);
1480 int n;
1481
1482 if (!s->blk || !s->mult_sectors) {
1483 ide_abort_command(s);
1484 return true;
1485 }
1486
1487 ide_cmd_lba48_transform(s, lba48);
1488
1489 s->req_nb_sectors = s->mult_sectors;
1490 n = MIN(s->nsector, s->req_nb_sectors);
1491
1492 s->status = SEEK_STAT | READY_STAT;
1493 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
1494
1495 s->media_changed = 1;
1496
1497 return false;
1498 }
1499
1500 static bool cmd_read_pio(IDEState *s, uint8_t cmd)
1501 {
1502 bool lba48 = (cmd == WIN_READ_EXT);
1503
1504 if (s->drive_kind == IDE_CD) {
1505 ide_set_signature(s); /* odd, but ATA4 8.27.5.2 requires it */
1506 ide_abort_command(s);
1507 return true;
1508 }
1509
1510 if (!s->blk) {
1511 ide_abort_command(s);
1512 return true;
1513 }
1514
1515 ide_cmd_lba48_transform(s, lba48);
1516 s->req_nb_sectors = 1;
1517 ide_sector_read(s);
1518
1519 return false;
1520 }
1521
1522 static bool cmd_write_pio(IDEState *s, uint8_t cmd)
1523 {
1524 bool lba48 = (cmd == WIN_WRITE_EXT);
1525
1526 if (!s->blk) {
1527 ide_abort_command(s);
1528 return true;
1529 }
1530
1531 ide_cmd_lba48_transform(s, lba48);
1532
1533 s->req_nb_sectors = 1;
1534 s->status = SEEK_STAT | READY_STAT;
1535 ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
1536
1537 s->media_changed = 1;
1538
1539 return false;
1540 }
1541
1542 static bool cmd_read_dma(IDEState *s, uint8_t cmd)
1543 {
1544 bool lba48 = (cmd == WIN_READDMA_EXT);
1545
1546 if (!s->blk) {
1547 ide_abort_command(s);
1548 return true;
1549 }
1550
1551 ide_cmd_lba48_transform(s, lba48);
1552 ide_sector_start_dma(s, IDE_DMA_READ);
1553
1554 return false;
1555 }
1556
1557 static bool cmd_write_dma(IDEState *s, uint8_t cmd)
1558 {
1559 bool lba48 = (cmd == WIN_WRITEDMA_EXT);
1560
1561 if (!s->blk) {
1562 ide_abort_command(s);
1563 return true;
1564 }
1565
1566 ide_cmd_lba48_transform(s, lba48);
1567 ide_sector_start_dma(s, IDE_DMA_WRITE);
1568
1569 s->media_changed = 1;
1570
1571 return false;
1572 }
1573
1574 static bool cmd_flush_cache(IDEState *s, uint8_t cmd)
1575 {
1576 ide_flush_cache(s);
1577 return false;
1578 }
1579
1580 static bool cmd_seek(IDEState *s, uint8_t cmd)
1581 {
1582 /* XXX: Check that seek is within bounds */
1583 return true;
1584 }
1585
1586 static bool cmd_read_native_max(IDEState *s, uint8_t cmd)
1587 {
1588 bool lba48 = (cmd == WIN_READ_NATIVE_MAX_EXT);
1589
1590 /* Refuse if no sectors are addressable (e.g. medium not inserted) */
1591 if (s->nb_sectors == 0) {
1592 ide_abort_command(s);
1593 return true;
1594 }
1595
1596 ide_cmd_lba48_transform(s, lba48);
1597 ide_set_sector(s, s->nb_sectors - 1);
1598
1599 return true;
1600 }
1601
1602 static bool cmd_check_power_mode(IDEState *s, uint8_t cmd)
1603 {
1604 s->nsector = 0xff; /* device active or idle */
1605 return true;
1606 }
1607
1608 static bool cmd_set_features(IDEState *s, uint8_t cmd)
1609 {
1610 uint16_t *identify_data;
1611
1612 if (!s->blk) {
1613 ide_abort_command(s);
1614 return true;
1615 }
1616
1617 /* XXX: valid for CDROM ? */
1618 switch (s->feature) {
1619 case 0x02: /* write cache enable */
1620 blk_set_enable_write_cache(s->blk, true);
1621 identify_data = (uint16_t *)s->identify_data;
1622 put_le16(identify_data + 85, (1 << 14) | (1 << 5) | 1);
1623 return true;
1624 case 0x82: /* write cache disable */
1625 blk_set_enable_write_cache(s->blk, false);
1626 identify_data = (uint16_t *)s->identify_data;
1627 put_le16(identify_data + 85, (1 << 14) | 1);
1628 ide_flush_cache(s);
1629 return false;
1630 case 0xcc: /* reverting to power-on defaults enable */
1631 case 0x66: /* reverting to power-on defaults disable */
1632 case 0xaa: /* read look-ahead enable */
1633 case 0x55: /* read look-ahead disable */
1634 case 0x05: /* set advanced power management mode */
1635 case 0x85: /* disable advanced power management mode */
1636 case 0x69: /* NOP */
1637 case 0x67: /* NOP */
1638 case 0x96: /* NOP */
1639 case 0x9a: /* NOP */
1640 case 0x42: /* enable Automatic Acoustic Mode */
1641 case 0xc2: /* disable Automatic Acoustic Mode */
1642 return true;
1643 case 0x03: /* set transfer mode */
1644 {
1645 uint8_t val = s->nsector & 0x07;
1646 identify_data = (uint16_t *)s->identify_data;
1647
1648 switch (s->nsector >> 3) {
1649 case 0x00: /* pio default */
1650 case 0x01: /* pio mode */
1651 put_le16(identify_data + 62, 0x07);
1652 put_le16(identify_data + 63, 0x07);
1653 put_le16(identify_data + 88, 0x3f);
1654 break;
1655 case 0x02: /* sigle word dma mode*/
1656 put_le16(identify_data + 62, 0x07 | (1 << (val + 8)));
1657 put_le16(identify_data + 63, 0x07);
1658 put_le16(identify_data + 88, 0x3f);
1659 break;
1660 case 0x04: /* mdma mode */
1661 put_le16(identify_data + 62, 0x07);
1662 put_le16(identify_data + 63, 0x07 | (1 << (val + 8)));
1663 put_le16(identify_data + 88, 0x3f);
1664 break;
1665 case 0x08: /* udma mode */
1666 put_le16(identify_data + 62, 0x07);
1667 put_le16(identify_data + 63, 0x07);
1668 put_le16(identify_data + 88, 0x3f | (1 << (val + 8)));
1669 break;
1670 default:
1671 goto abort_cmd;
1672 }
1673 return true;
1674 }
1675 }
1676
1677 abort_cmd:
1678 ide_abort_command(s);
1679 return true;
1680 }
1681
1682
1683 /*** ATAPI commands ***/
1684
1685 static bool cmd_identify_packet(IDEState *s, uint8_t cmd)
1686 {
1687 ide_atapi_identify(s);
1688 s->status = READY_STAT | SEEK_STAT;
1689 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1690 ide_set_irq(s->bus);
1691 return false;
1692 }
1693
1694 static bool cmd_exec_dev_diagnostic(IDEState *s, uint8_t cmd)
1695 {
1696 ide_set_signature(s);
1697
1698 if (s->drive_kind == IDE_CD) {
1699 s->status = 0; /* ATAPI spec (v6) section 9.10 defines packet
1700 * devices to return a clear status register
1701 * with READY_STAT *not* set. */
1702 s->error = 0x01;
1703 } else {
1704 s->status = READY_STAT | SEEK_STAT;
1705 /* The bits of the error register are not as usual for this command!
1706 * They are part of the regular output (this is why ERR_STAT isn't set)
1707 * Device 0 passed, Device 1 passed or not present. */
1708 s->error = 0x01;
1709 ide_set_irq(s->bus);
1710 }
1711
1712 return false;
1713 }
1714
1715 static bool cmd_packet(IDEState *s, uint8_t cmd)
1716 {
1717 /* overlapping commands not supported */
1718 if (s->feature & 0x02) {
1719 ide_abort_command(s);
1720 return true;
1721 }
1722
1723 s->status = READY_STAT | SEEK_STAT;
1724 s->atapi_dma = s->feature & 1;
1725 if (s->atapi_dma) {
1726 s->dma_cmd = IDE_DMA_ATAPI;
1727 }
1728 s->nsector = 1;
1729 ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
1730 ide_atapi_cmd);
1731 return false;
1732 }
1733
1734
1735 /*** CF-ATA commands ***/
1736
1737 static bool cmd_cfa_req_ext_error_code(IDEState *s, uint8_t cmd)
1738 {
1739 s->error = 0x09; /* miscellaneous error */
1740 s->status = READY_STAT | SEEK_STAT;
1741 ide_set_irq(s->bus);
1742
1743 return false;
1744 }
1745
1746 static bool cmd_cfa_erase_sectors(IDEState *s, uint8_t cmd)
1747 {
1748 /* WIN_SECURITY_FREEZE_LOCK has the same ID as CFA_WEAR_LEVEL and is
1749 * required for Windows 8 to work with AHCI */
1750
1751 if (cmd == CFA_WEAR_LEVEL) {
1752 s->nsector = 0;
1753 }
1754
1755 if (cmd == CFA_ERASE_SECTORS) {
1756 s->media_changed = 1;
1757 }
1758
1759 return true;
1760 }
1761
1762 static bool cmd_cfa_translate_sector(IDEState *s, uint8_t cmd)
1763 {
1764 s->status = READY_STAT | SEEK_STAT;
1765
1766 memset(s->io_buffer, 0, 0x200);
1767 s->io_buffer[0x00] = s->hcyl; /* Cyl MSB */
1768 s->io_buffer[0x01] = s->lcyl; /* Cyl LSB */
1769 s->io_buffer[0x02] = s->select; /* Head */
1770 s->io_buffer[0x03] = s->sector; /* Sector */
1771 s->io_buffer[0x04] = ide_get_sector(s) >> 16; /* LBA MSB */
1772 s->io_buffer[0x05] = ide_get_sector(s) >> 8; /* LBA */
1773 s->io_buffer[0x06] = ide_get_sector(s) >> 0; /* LBA LSB */
1774 s->io_buffer[0x13] = 0x00; /* Erase flag */
1775 s->io_buffer[0x18] = 0x00; /* Hot count */
1776 s->io_buffer[0x19] = 0x00; /* Hot count */
1777 s->io_buffer[0x1a] = 0x01; /* Hot count */
1778
1779 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1780 ide_set_irq(s->bus);
1781
1782 return false;
1783 }
1784
1785 static bool cmd_cfa_access_metadata_storage(IDEState *s, uint8_t cmd)
1786 {
1787 switch (s->feature) {
1788 case 0x02: /* Inquiry Metadata Storage */
1789 ide_cfata_metadata_inquiry(s);
1790 break;
1791 case 0x03: /* Read Metadata Storage */
1792 ide_cfata_metadata_read(s);
1793 break;
1794 case 0x04: /* Write Metadata Storage */
1795 ide_cfata_metadata_write(s);
1796 break;
1797 default:
1798 ide_abort_command(s);
1799 return true;
1800 }
1801
1802 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1803 s->status = 0x00; /* NOTE: READY is _not_ set */
1804 ide_set_irq(s->bus);
1805
1806 return false;
1807 }
1808
1809 static bool cmd_ibm_sense_condition(IDEState *s, uint8_t cmd)
1810 {
1811 switch (s->feature) {
1812 case 0x01: /* sense temperature in device */
1813 s->nsector = 0x50; /* +20 C */
1814 break;
1815 default:
1816 ide_abort_command(s);
1817 return true;
1818 }
1819
1820 return true;
1821 }
1822
1823
1824 /*** SMART commands ***/
1825
1826 static bool cmd_smart(IDEState *s, uint8_t cmd)
1827 {
1828 int n;
1829
1830 if (s->hcyl != 0xc2 || s->lcyl != 0x4f) {
1831 goto abort_cmd;
1832 }
1833
1834 if (!s->smart_enabled && s->feature != SMART_ENABLE) {
1835 goto abort_cmd;
1836 }
1837
1838 switch (s->feature) {
1839 case SMART_DISABLE:
1840 s->smart_enabled = 0;
1841 return true;
1842
1843 case SMART_ENABLE:
1844 s->smart_enabled = 1;
1845 return true;
1846
1847 case SMART_ATTR_AUTOSAVE:
1848 switch (s->sector) {
1849 case 0x00:
1850 s->smart_autosave = 0;
1851 break;
1852 case 0xf1:
1853 s->smart_autosave = 1;
1854 break;
1855 default:
1856 goto abort_cmd;
1857 }
1858 return true;
1859
1860 case SMART_STATUS:
1861 if (!s->smart_errors) {
1862 s->hcyl = 0xc2;
1863 s->lcyl = 0x4f;
1864 } else {
1865 s->hcyl = 0x2c;
1866 s->lcyl = 0xf4;
1867 }
1868 return true;
1869
1870 case SMART_READ_THRESH:
1871 memset(s->io_buffer, 0, 0x200);
1872 s->io_buffer[0] = 0x01; /* smart struct version */
1873
1874 for (n = 0; n < ARRAY_SIZE(smart_attributes); n++) {
1875 s->io_buffer[2 + 0 + (n * 12)] = smart_attributes[n][0];
1876 s->io_buffer[2 + 1 + (n * 12)] = smart_attributes[n][11];
1877 }
1878
1879 /* checksum */
1880 for (n = 0; n < 511; n++) {
1881 s->io_buffer[511] += s->io_buffer[n];
1882 }
1883 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1884
1885 s->status = READY_STAT | SEEK_STAT;
1886 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1887 ide_set_irq(s->bus);
1888 return false;
1889
1890 case SMART_READ_DATA:
1891 memset(s->io_buffer, 0, 0x200);
1892 s->io_buffer[0] = 0x01; /* smart struct version */
1893
1894 for (n = 0; n < ARRAY_SIZE(smart_attributes); n++) {
1895 int i;
1896 for (i = 0; i < 11; i++) {
1897 s->io_buffer[2 + i + (n * 12)] = smart_attributes[n][i];
1898 }
1899 }
1900
1901 s->io_buffer[362] = 0x02 | (s->smart_autosave ? 0x80 : 0x00);
1902 if (s->smart_selftest_count == 0) {
1903 s->io_buffer[363] = 0;
1904 } else {
1905 s->io_buffer[363] =
1906 s->smart_selftest_data[3 +
1907 (s->smart_selftest_count - 1) *
1908 24];
1909 }
1910 s->io_buffer[364] = 0x20;
1911 s->io_buffer[365] = 0x01;
1912 /* offline data collection capacity: execute + self-test*/
1913 s->io_buffer[367] = (1 << 4 | 1 << 3 | 1);
1914 s->io_buffer[368] = 0x03; /* smart capability (1) */
1915 s->io_buffer[369] = 0x00; /* smart capability (2) */
1916 s->io_buffer[370] = 0x01; /* error logging supported */
1917 s->io_buffer[372] = 0x02; /* minutes for poll short test */
1918 s->io_buffer[373] = 0x36; /* minutes for poll ext test */
1919 s->io_buffer[374] = 0x01; /* minutes for poll conveyance */
1920
1921 for (n = 0; n < 511; n++) {
1922 s->io_buffer[511] += s->io_buffer[n];
1923 }
1924 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1925
1926 s->status = READY_STAT | SEEK_STAT;
1927 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1928 ide_set_irq(s->bus);
1929 return false;
1930
1931 case SMART_READ_LOG:
1932 switch (s->sector) {
1933 case 0x01: /* summary smart error log */
1934 memset(s->io_buffer, 0, 0x200);
1935 s->io_buffer[0] = 0x01;
1936 s->io_buffer[1] = 0x00; /* no error entries */
1937 s->io_buffer[452] = s->smart_errors & 0xff;
1938 s->io_buffer[453] = (s->smart_errors & 0xff00) >> 8;
1939
1940 for (n = 0; n < 511; n++) {
1941 s->io_buffer[511] += s->io_buffer[n];
1942 }
1943 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1944 break;
1945 case 0x06: /* smart self test log */
1946 memset(s->io_buffer, 0, 0x200);
1947 s->io_buffer[0] = 0x01;
1948 if (s->smart_selftest_count == 0) {
1949 s->io_buffer[508] = 0;
1950 } else {
1951 s->io_buffer[508] = s->smart_selftest_count;
1952 for (n = 2; n < 506; n++) {
1953 s->io_buffer[n] = s->smart_selftest_data[n];
1954 }
1955 }
1956
1957 for (n = 0; n < 511; n++) {
1958 s->io_buffer[511] += s->io_buffer[n];
1959 }
1960 s->io_buffer[511] = 0x100 - s->io_buffer[511];
1961 break;
1962 default:
1963 goto abort_cmd;
1964 }
1965 s->status = READY_STAT | SEEK_STAT;
1966 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
1967 ide_set_irq(s->bus);
1968 return false;
1969
1970 case SMART_EXECUTE_OFFLINE:
1971 switch (s->sector) {
1972 case 0: /* off-line routine */
1973 case 1: /* short self test */
1974 case 2: /* extended self test */
1975 s->smart_selftest_count++;
1976 if (s->smart_selftest_count > 21) {
1977 s->smart_selftest_count = 1;
1978 }
1979 n = 2 + (s->smart_selftest_count - 1) * 24;
1980 s->smart_selftest_data[n] = s->sector;
1981 s->smart_selftest_data[n + 1] = 0x00; /* OK and finished */
1982 s->smart_selftest_data[n + 2] = 0x34; /* hour count lsb */
1983 s->smart_selftest_data[n + 3] = 0x12; /* hour count msb */
1984 break;
1985 default:
1986 goto abort_cmd;
1987 }
1988 return true;
1989 }
1990
1991 abort_cmd:
1992 ide_abort_command(s);
1993 return true;
1994 }
1995
1996 #define HD_OK (1u << IDE_HD)
1997 #define CD_OK (1u << IDE_CD)
1998 #define CFA_OK (1u << IDE_CFATA)
1999 #define HD_CFA_OK (HD_OK | CFA_OK)
2000 #define ALL_OK (HD_OK | CD_OK | CFA_OK)
2001
2002 /* Set the Disk Seek Completed status bit during completion */
2003 #define SET_DSC (1u << 8)
2004
2005 /* See ACS-2 T13/2015-D Table B.2 Command codes */
2006 static const struct {
2007 /* Returns true if the completion code should be run */
2008 bool (*handler)(IDEState *s, uint8_t cmd);
2009 int flags;
2010 } ide_cmd_table[0x100] = {
2011 /* NOP not implemented, mandatory for CD */
2012 [CFA_REQ_EXT_ERROR_CODE] = { cmd_cfa_req_ext_error_code, CFA_OK },
2013 [WIN_DSM] = { cmd_data_set_management, HD_CFA_OK },
2014 [WIN_DEVICE_RESET] = { cmd_device_reset, CD_OK },
2015 [WIN_RECAL] = { cmd_nop, HD_CFA_OK | SET_DSC},
2016 [WIN_READ] = { cmd_read_pio, ALL_OK },
2017 [WIN_READ_ONCE] = { cmd_read_pio, HD_CFA_OK },
2018 [WIN_READ_EXT] = { cmd_read_pio, HD_CFA_OK },
2019 [WIN_READDMA_EXT] = { cmd_read_dma, HD_CFA_OK },
2020 [WIN_READ_NATIVE_MAX_EXT] = { cmd_read_native_max, HD_CFA_OK | SET_DSC },
2021 [WIN_MULTREAD_EXT] = { cmd_read_multiple, HD_CFA_OK },
2022 [WIN_WRITE] = { cmd_write_pio, HD_CFA_OK },
2023 [WIN_WRITE_ONCE] = { cmd_write_pio, HD_CFA_OK },
2024 [WIN_WRITE_EXT] = { cmd_write_pio, HD_CFA_OK },
2025 [WIN_WRITEDMA_EXT] = { cmd_write_dma, HD_CFA_OK },
2026 [CFA_WRITE_SECT_WO_ERASE] = { cmd_write_pio, CFA_OK },
2027 [WIN_MULTWRITE_EXT] = { cmd_write_multiple, HD_CFA_OK },
2028 [WIN_WRITE_VERIFY] = { cmd_write_pio, HD_CFA_OK },
2029 [WIN_VERIFY] = { cmd_verify, HD_CFA_OK | SET_DSC },
2030 [WIN_VERIFY_ONCE] = { cmd_verify, HD_CFA_OK | SET_DSC },
2031 [WIN_VERIFY_EXT] = { cmd_verify, HD_CFA_OK | SET_DSC },
2032 [WIN_SEEK] = { cmd_seek, HD_CFA_OK | SET_DSC },
2033 [CFA_TRANSLATE_SECTOR] = { cmd_cfa_translate_sector, CFA_OK },
2034 [WIN_DIAGNOSE] = { cmd_exec_dev_diagnostic, ALL_OK },
2035 [WIN_SPECIFY] = { cmd_nop, HD_CFA_OK | SET_DSC },
2036 [WIN_STANDBYNOW2] = { cmd_nop, HD_CFA_OK },
2037 [WIN_IDLEIMMEDIATE2] = { cmd_nop, HD_CFA_OK },
2038 [WIN_STANDBY2] = { cmd_nop, HD_CFA_OK },
2039 [WIN_SETIDLE2] = { cmd_nop, HD_CFA_OK },
2040 [WIN_CHECKPOWERMODE2] = { cmd_check_power_mode, HD_CFA_OK | SET_DSC },
2041 [WIN_SLEEPNOW2] = { cmd_nop, HD_CFA_OK },
2042 [WIN_PACKETCMD] = { cmd_packet, CD_OK },
2043 [WIN_PIDENTIFY] = { cmd_identify_packet, CD_OK },
2044 [WIN_SMART] = { cmd_smart, HD_CFA_OK | SET_DSC },
2045 [CFA_ACCESS_METADATA_STORAGE] = { cmd_cfa_access_metadata_storage, CFA_OK },
2046 [CFA_ERASE_SECTORS] = { cmd_cfa_erase_sectors, CFA_OK | SET_DSC },
2047 [WIN_MULTREAD] = { cmd_read_multiple, HD_CFA_OK },
2048 [WIN_MULTWRITE] = { cmd_write_multiple, HD_CFA_OK },
2049 [WIN_SETMULT] = { cmd_set_multiple_mode, HD_CFA_OK | SET_DSC },
2050 [WIN_READDMA] = { cmd_read_dma, HD_CFA_OK },
2051 [WIN_READDMA_ONCE] = { cmd_read_dma, HD_CFA_OK },
2052 [WIN_WRITEDMA] = { cmd_write_dma, HD_CFA_OK },
2053 [WIN_WRITEDMA_ONCE] = { cmd_write_dma, HD_CFA_OK },
2054 [CFA_WRITE_MULTI_WO_ERASE] = { cmd_write_multiple, CFA_OK },
2055 [WIN_STANDBYNOW1] = { cmd_nop, HD_CFA_OK },
2056 [WIN_IDLEIMMEDIATE] = { cmd_nop, HD_CFA_OK },
2057 [WIN_STANDBY] = { cmd_nop, HD_CFA_OK },
2058 [WIN_SETIDLE1] = { cmd_nop, HD_CFA_OK },
2059 [WIN_CHECKPOWERMODE1] = { cmd_check_power_mode, HD_CFA_OK | SET_DSC },
2060 [WIN_SLEEPNOW1] = { cmd_nop, HD_CFA_OK },
2061 [WIN_FLUSH_CACHE] = { cmd_flush_cache, ALL_OK },
2062 [WIN_FLUSH_CACHE_EXT] = { cmd_flush_cache, HD_CFA_OK },
2063 [WIN_IDENTIFY] = { cmd_identify, ALL_OK },
2064 [WIN_SETFEATURES] = { cmd_set_features, ALL_OK | SET_DSC },
2065 [IBM_SENSE_CONDITION] = { cmd_ibm_sense_condition, CFA_OK | SET_DSC },
2066 [CFA_WEAR_LEVEL] = { cmd_cfa_erase_sectors, HD_CFA_OK | SET_DSC },
2067 [WIN_READ_NATIVE_MAX] = { cmd_read_native_max, HD_CFA_OK | SET_DSC },
2068 };
2069
2070 static bool ide_cmd_permitted(IDEState *s, uint32_t cmd)
2071 {
2072 return cmd < ARRAY_SIZE(ide_cmd_table)
2073 && (ide_cmd_table[cmd].flags & (1u << s->drive_kind));
2074 }
2075
2076 void ide_exec_cmd(IDEBus *bus, uint32_t val)
2077 {
2078 IDEState *s;
2079 bool complete;
2080
2081 s = idebus_active_if(bus);
2082 trace_ide_exec_cmd(bus, s, val);
2083
2084 /* ignore commands to non existent slave */
2085 if (s != bus->ifs && !s->blk) {
2086 return;
2087 }
2088
2089 /* Only RESET is allowed while BSY and/or DRQ are set,
2090 * and only to ATAPI devices. */
2091 if (s->status & (BUSY_STAT|DRQ_STAT)) {
2092 if (val != WIN_DEVICE_RESET || s->drive_kind != IDE_CD) {
2093 return;
2094 }
2095 }
2096
2097 if (!ide_cmd_permitted(s, val)) {
2098 ide_abort_command(s);
2099 ide_set_irq(s->bus);
2100 return;
2101 }
2102
2103 s->status = READY_STAT | BUSY_STAT;
2104 s->error = 0;
2105 s->io_buffer_offset = 0;
2106
2107 complete = ide_cmd_table[val].handler(s, val);
2108 if (complete) {
2109 s->status &= ~BUSY_STAT;
2110 assert(!!s->error == !!(s->status & ERR_STAT));
2111
2112 if ((ide_cmd_table[val].flags & SET_DSC) && !s->error) {
2113 s->status |= SEEK_STAT;
2114 }
2115
2116 ide_cmd_done(s);
2117 ide_set_irq(s->bus);
2118 }
2119 }
2120
2121 /* IOport [R]ead [R]egisters */
2122 enum ATA_IOPORT_RR {
2123 ATA_IOPORT_RR_DATA = 0,
2124 ATA_IOPORT_RR_ERROR = 1,
2125 ATA_IOPORT_RR_SECTOR_COUNT = 2,
2126 ATA_IOPORT_RR_SECTOR_NUMBER = 3,
2127 ATA_IOPORT_RR_CYLINDER_LOW = 4,
2128 ATA_IOPORT_RR_CYLINDER_HIGH = 5,
2129 ATA_IOPORT_RR_DEVICE_HEAD = 6,
2130 ATA_IOPORT_RR_STATUS = 7,
2131 ATA_IOPORT_RR_NUM_REGISTERS,
2132 };
2133
2134 const char *ATA_IOPORT_RR_lookup[ATA_IOPORT_RR_NUM_REGISTERS] = {
2135 [ATA_IOPORT_RR_DATA] = "Data",
2136 [ATA_IOPORT_RR_ERROR] = "Error",
2137 [ATA_IOPORT_RR_SECTOR_COUNT] = "Sector Count",
2138 [ATA_IOPORT_RR_SECTOR_NUMBER] = "Sector Number",
2139 [ATA_IOPORT_RR_CYLINDER_LOW] = "Cylinder Low",
2140 [ATA_IOPORT_RR_CYLINDER_HIGH] = "Cylinder High",
2141 [ATA_IOPORT_RR_DEVICE_HEAD] = "Device/Head",
2142 [ATA_IOPORT_RR_STATUS] = "Status"
2143 };
2144
2145 uint32_t ide_ioport_read(void *opaque, uint32_t addr)
2146 {
2147 IDEBus *bus = opaque;
2148 IDEState *s = idebus_active_if(bus);
2149 uint32_t reg_num;
2150 int ret, hob;
2151
2152 reg_num = addr & 7;
2153 hob = bus->cmd & (IDE_CTRL_HOB);
2154 switch (reg_num) {
2155 case ATA_IOPORT_RR_DATA:
2156 ret = 0xff;
2157 break;
2158 case ATA_IOPORT_RR_ERROR:
2159 if ((!bus->ifs[0].blk && !bus->ifs[1].blk) ||
2160 (s != bus->ifs && !s->blk)) {
2161 ret = 0;
2162 } else if (!hob) {
2163 ret = s->error;
2164 } else {
2165 ret = s->hob_feature;
2166 }
2167 break;
2168 case ATA_IOPORT_RR_SECTOR_COUNT:
2169 if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
2170 ret = 0;
2171 } else if (!hob) {
2172 ret = s->nsector & 0xff;
2173 } else {
2174 ret = s->hob_nsector;
2175 }
2176 break;
2177 case ATA_IOPORT_RR_SECTOR_NUMBER:
2178 if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
2179 ret = 0;
2180 } else if (!hob) {
2181 ret = s->sector;
2182 } else {
2183 ret = s->hob_sector;
2184 }
2185 break;
2186 case ATA_IOPORT_RR_CYLINDER_LOW:
2187 if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
2188 ret = 0;
2189 } else if (!hob) {
2190 ret = s->lcyl;
2191 } else {
2192 ret = s->hob_lcyl;
2193 }
2194 break;
2195 case ATA_IOPORT_RR_CYLINDER_HIGH:
2196 if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
2197 ret = 0;
2198 } else if (!hob) {
2199 ret = s->hcyl;
2200 } else {
2201 ret = s->hob_hcyl;
2202 }
2203 break;
2204 case ATA_IOPORT_RR_DEVICE_HEAD:
2205 if (!bus->ifs[0].blk && !bus->ifs[1].blk) {
2206 ret = 0;
2207 } else {
2208 ret = s->select;
2209 }
2210 break;
2211 default:
2212 case ATA_IOPORT_RR_STATUS:
2213 if ((!bus->ifs[0].blk && !bus->ifs[1].blk) ||
2214 (s != bus->ifs && !s->blk)) {
2215 ret = 0;
2216 } else {
2217 ret = s->status;
2218 }
2219 qemu_irq_lower(bus->irq);
2220 break;
2221 }
2222
2223 trace_ide_ioport_read(addr, ATA_IOPORT_RR_lookup[reg_num], ret, bus, s);
2224 return ret;
2225 }
2226
2227 uint32_t ide_status_read(void *opaque, uint32_t addr)
2228 {
2229 IDEBus *bus = opaque;
2230 IDEState *s = idebus_active_if(bus);
2231 int ret;
2232
2233 if ((!bus->ifs[0].blk && !bus->ifs[1].blk) ||
2234 (s != bus->ifs && !s->blk)) {
2235 ret = 0;
2236 } else {
2237 ret = s->status;
2238 }
2239
2240 trace_ide_status_read(addr, ret, bus, s);
2241 return ret;
2242 }
2243
2244 static void ide_perform_srst(IDEState *s)
2245 {
2246 s->status |= BUSY_STAT;
2247
2248 /* Halt PIO (Via register state); PIO BH remains scheduled. */
2249 ide_transfer_halt(s);
2250
2251 /* Cancel DMA -- may drain block device and invoke callbacks */
2252 ide_cancel_dma_sync(s);
2253
2254 /* Cancel PIO callback, reset registers/signature, etc */
2255 ide_reset(s);
2256
2257 if (s->drive_kind == IDE_CD) {
2258 /* ATAPI drives do not set READY or SEEK */
2259 s->status = 0x00;
2260 }
2261 }
2262
2263 static void ide_bus_perform_srst(void *opaque)
2264 {
2265 IDEBus *bus = opaque;
2266 IDEState *s;
2267 int i;
2268
2269 for (i = 0; i < 2; i++) {
2270 s = &bus->ifs[i];
2271 ide_perform_srst(s);
2272 }
2273 }
2274
2275 void ide_ctrl_write(void *opaque, uint32_t addr, uint32_t val)
2276 {
2277 IDEBus *bus = opaque;
2278 IDEState *s;
2279 int i;
2280
2281 trace_ide_ctrl_write(addr, val, bus);
2282
2283 /* Device0 and Device1 each have their own control register,
2284 * but QEMU models it as just one register in the controller. */
2285 if ((bus->cmd & IDE_CTRL_RESET) &&
2286 !(val & IDE_CTRL_RESET)) {
2287 /* SRST triggers on falling edge */
2288 for (i = 0; i < 2; i++) {
2289 s = &bus->ifs[i];
2290 s->status |= BUSY_STAT;
2291 }
2292 replay_bh_schedule_oneshot_event(qemu_get_aio_context(),
2293 ide_bus_perform_srst, bus);
2294 }
2295
2296 bus->cmd = val;
2297 }
2298
2299 /*
2300 * Returns true if the running PIO transfer is a PIO out (i.e. data is
2301 * transferred from the device to the guest), false if it's a PIO in
2302 */
2303 static bool ide_is_pio_out(IDEState *s)
2304 {
2305 if (s->end_transfer_func == ide_sector_write ||
2306 s->end_transfer_func == ide_atapi_cmd) {
2307 return false;
2308 } else if (s->end_transfer_func == ide_sector_read ||
2309 s->end_transfer_func == ide_transfer_stop ||
2310 s->end_transfer_func == ide_atapi_cmd_reply_end ||
2311 s->end_transfer_func == ide_dummy_transfer_stop) {
2312 return true;
2313 }
2314
2315 abort();
2316 }
2317
2318 void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
2319 {
2320 IDEBus *bus = opaque;
2321 IDEState *s = idebus_active_if(bus);
2322 uint8_t *p;
2323
2324 trace_ide_data_writew(addr, val, bus, s);
2325
2326 /* PIO data access allowed only when DRQ bit is set. The result of a write
2327 * during PIO out is indeterminate, just ignore it. */
2328 if (!(s->status & DRQ_STAT) || ide_is_pio_out(s)) {
2329 return;
2330 }
2331
2332 p = s->data_ptr;
2333 if (p + 2 > s->data_end) {
2334 return;
2335 }
2336
2337 *(uint16_t *)p = le16_to_cpu(val);
2338 p += 2;
2339 s->data_ptr = p;
2340 if (p >= s->data_end) {
2341 s->status &= ~DRQ_STAT;
2342 s->end_transfer_func(s);
2343 }
2344 }
2345
2346 uint32_t ide_data_readw(void *opaque, uint32_t addr)
2347 {
2348 IDEBus *bus = opaque;
2349 IDEState *s = idebus_active_if(bus);
2350 uint8_t *p;
2351 int ret;
2352
2353 /* PIO data access allowed only when DRQ bit is set. The result of a read
2354 * during PIO in is indeterminate, return 0 and don't move forward. */
2355 if (!(s->status & DRQ_STAT) || !ide_is_pio_out(s)) {
2356 return 0;
2357 }
2358
2359 p = s->data_ptr;
2360 if (p + 2 > s->data_end) {
2361 return 0;
2362 }
2363
2364 ret = cpu_to_le16(*(uint16_t *)p);
2365 p += 2;
2366 s->data_ptr = p;
2367 if (p >= s->data_end) {
2368 s->status &= ~DRQ_STAT;
2369 s->end_transfer_func(s);
2370 }
2371
2372 trace_ide_data_readw(addr, ret, bus, s);
2373 return ret;
2374 }
2375
2376 void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
2377 {
2378 IDEBus *bus = opaque;
2379 IDEState *s = idebus_active_if(bus);
2380 uint8_t *p;
2381
2382 trace_ide_data_writel(addr, val, bus, s);
2383
2384 /* PIO data access allowed only when DRQ bit is set. The result of a write
2385 * during PIO out is indeterminate, just ignore it. */
2386 if (!(s->status & DRQ_STAT) || ide_is_pio_out(s)) {
2387 return;
2388 }
2389
2390 p = s->data_ptr;
2391 if (p + 4 > s->data_end) {
2392 return;
2393 }
2394
2395 *(uint32_t *)p = le32_to_cpu(val);
2396 p += 4;
2397 s->data_ptr = p;
2398 if (p >= s->data_end) {
2399 s->status &= ~DRQ_STAT;
2400 s->end_transfer_func(s);
2401 }
2402 }
2403
2404 uint32_t ide_data_readl(void *opaque, uint32_t addr)
2405 {
2406 IDEBus *bus = opaque;
2407 IDEState *s = idebus_active_if(bus);
2408 uint8_t *p;
2409 int ret;
2410
2411 /* PIO data access allowed only when DRQ bit is set. The result of a read
2412 * during PIO in is indeterminate, return 0 and don't move forward. */
2413 if (!(s->status & DRQ_STAT) || !ide_is_pio_out(s)) {
2414 ret = 0;
2415 goto out;
2416 }
2417
2418 p = s->data_ptr;
2419 if (p + 4 > s->data_end) {
2420 return 0;
2421 }
2422
2423 ret = cpu_to_le32(*(uint32_t *)p);
2424 p += 4;
2425 s->data_ptr = p;
2426 if (p >= s->data_end) {
2427 s->status &= ~DRQ_STAT;
2428 s->end_transfer_func(s);
2429 }
2430
2431 out:
2432 trace_ide_data_readl(addr, ret, bus, s);
2433 return ret;
2434 }
2435
2436 static void ide_dummy_transfer_stop(IDEState *s)
2437 {
2438 s->data_ptr = s->io_buffer;
2439 s->data_end = s->io_buffer;
2440 s->io_buffer[0] = 0xff;
2441 s->io_buffer[1] = 0xff;
2442 s->io_buffer[2] = 0xff;
2443 s->io_buffer[3] = 0xff;
2444 }
2445
2446 void ide_bus_reset(IDEBus *bus)
2447 {
2448 bus->unit = 0;
2449 bus->cmd = 0;
2450 ide_reset(&bus->ifs[0]);
2451 ide_reset(&bus->ifs[1]);
2452 ide_clear_hob(bus);
2453
2454 /* pending async DMA */
2455 if (bus->dma->aiocb) {
2456 trace_ide_bus_reset_aio();
2457 blk_aio_cancel(bus->dma->aiocb);
2458 bus->dma->aiocb = NULL;
2459 }
2460
2461 /* reset dma provider too */
2462 if (bus->dma->ops->reset) {
2463 bus->dma->ops->reset(bus->dma);
2464 }
2465 }
2466
2467 static bool ide_cd_is_tray_open(void *opaque)
2468 {
2469 return ((IDEState *)opaque)->tray_open;
2470 }
2471
2472 static bool ide_cd_is_medium_locked(void *opaque)
2473 {
2474 return ((IDEState *)opaque)->tray_locked;
2475 }
2476
2477 static void ide_resize_cb(void *opaque)
2478 {
2479 IDEState *s = opaque;
2480 uint64_t nb_sectors;
2481
2482 if (!s->identify_set) {
2483 return;
2484 }
2485
2486 blk_get_geometry(s->blk, &nb_sectors);
2487 s->nb_sectors = nb_sectors;
2488
2489 /* Update the identify data buffer. */
2490 if (s->drive_kind == IDE_CFATA) {
2491 ide_cfata_identify_size(s);
2492 } else {
2493 /* IDE_CD uses a different set of callbacks entirely. */
2494 assert(s->drive_kind != IDE_CD);
2495 ide_identify_size(s);
2496 }
2497 }
2498
2499 static const BlockDevOps ide_cd_block_ops = {
2500 .change_media_cb = ide_cd_change_cb,
2501 .eject_request_cb = ide_cd_eject_request_cb,
2502 .is_tray_open = ide_cd_is_tray_open,
2503 .is_medium_locked = ide_cd_is_medium_locked,
2504 };
2505
2506 static const BlockDevOps ide_hd_block_ops = {
2507 .resize_cb = ide_resize_cb,
2508 };
2509
2510 int ide_init_drive(IDEState *s, BlockBackend *blk, IDEDriveKind kind,
2511 const char *version, const char *serial, const char *model,
2512 uint64_t wwn,
2513 uint32_t cylinders, uint32_t heads, uint32_t secs,
2514 int chs_trans, Error **errp)
2515 {
2516 uint64_t nb_sectors;
2517
2518 s->blk = blk;
2519 s->drive_kind = kind;
2520
2521 blk_get_geometry(blk, &nb_sectors);
2522 s->cylinders = cylinders;
2523 s->heads = heads;
2524 s->sectors = secs;
2525 s->chs_trans = chs_trans;
2526 s->nb_sectors = nb_sectors;
2527 s->wwn = wwn;
2528 /* The SMART values should be preserved across power cycles
2529 but they aren't. */
2530 s->smart_enabled = 1;
2531 s->smart_autosave = 1;
2532 s->smart_errors = 0;
2533 s->smart_selftest_count = 0;
2534 if (kind == IDE_CD) {
2535 blk_set_dev_ops(blk, &ide_cd_block_ops, s);
2536 blk_set_guest_block_size(blk, 2048);
2537 } else {
2538 if (!blk_is_inserted(s->blk)) {
2539 error_setg(errp, "Device needs media, but drive is empty");
2540 return -1;
2541 }
2542 if (blk_is_read_only(blk)) {
2543 error_setg(errp, "Can't use a read-only drive");
2544 return -1;
2545 }
2546 blk_set_dev_ops(blk, &ide_hd_block_ops, s);
2547 }
2548 if (serial) {
2549 pstrcpy(s->drive_serial_str, sizeof(s->drive_serial_str), serial);
2550 } else {
2551 snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),
2552 "QM%05d", s->drive_serial);
2553 }
2554 if (model) {
2555 pstrcpy(s->drive_model_str, sizeof(s->drive_model_str), model);
2556 } else {
2557 switch (kind) {
2558 case IDE_CD:
2559 strcpy(s->drive_model_str, "QEMU DVD-ROM");
2560 break;
2561 case IDE_CFATA:
2562 strcpy(s->drive_model_str, "QEMU MICRODRIVE");
2563 break;
2564 default:
2565 strcpy(s->drive_model_str, "QEMU HARDDISK");
2566 break;
2567 }
2568 }
2569
2570 if (version) {
2571 pstrcpy(s->version, sizeof(s->version), version);
2572 } else {
2573 pstrcpy(s->version, sizeof(s->version), qemu_hw_version());
2574 }
2575
2576 ide_reset(s);
2577 blk_iostatus_enable(blk);
2578 return 0;
2579 }
2580
2581 static void ide_init1(IDEBus *bus, int unit)
2582 {
2583 static int drive_serial = 1;
2584 IDEState *s = &bus->ifs[unit];
2585
2586 s->bus = bus;
2587 s->unit = unit;
2588 s->drive_serial = drive_serial++;
2589 /* we need at least 2k alignment for accessing CDROMs using O_DIRECT */
2590 s->io_buffer_total_len = IDE_DMA_BUF_SECTORS*512 + 4;
2591 s->io_buffer = qemu_memalign(2048, s->io_buffer_total_len);
2592 memset(s->io_buffer, 0, s->io_buffer_total_len);
2593
2594 s->smart_selftest_data = blk_blockalign(s->blk, 512);
2595 memset(s->smart_selftest_data, 0, 512);
2596
2597 s->sector_write_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL,
2598 ide_sector_write_timer_cb, s);
2599 }
2600
2601 static int ide_nop_int(const IDEDMA *dma, bool is_write)
2602 {
2603 return 0;
2604 }
2605
2606 static void ide_nop(const IDEDMA *dma)
2607 {
2608 }
2609
2610 static int32_t ide_nop_int32(const IDEDMA *dma, int32_t l)
2611 {
2612 return 0;
2613 }
2614
2615 static const IDEDMAOps ide_dma_nop_ops = {
2616 .prepare_buf = ide_nop_int32,
2617 .restart_dma = ide_nop,
2618 .rw_buf = ide_nop_int,
2619 };
2620
2621 static void ide_restart_dma(IDEState *s, enum ide_dma_cmd dma_cmd)
2622 {
2623 s->unit = s->bus->retry_unit;
2624 ide_set_sector(s, s->bus->retry_sector_num);
2625 s->nsector = s->bus->retry_nsector;
2626 s->bus->dma->ops->restart_dma(s->bus->dma);
2627 s->io_buffer_size = 0;
2628 s->dma_cmd = dma_cmd;
2629 ide_start_dma(s, ide_dma_cb);
2630 }
2631
2632 static void ide_restart_bh(void *opaque)
2633 {
2634 IDEBus *bus = opaque;
2635 IDEState *s;
2636 bool is_read;
2637 int error_status;
2638
2639 qemu_bh_delete(bus->bh);
2640 bus->bh = NULL;
2641
2642 error_status = bus->error_status;
2643 if (bus->error_status == 0) {
2644 return;
2645 }
2646
2647 s = idebus_active_if(bus);
2648 is_read = (bus->error_status & IDE_RETRY_READ) != 0;
2649
2650 /* The error status must be cleared before resubmitting the request: The
2651 * request may fail again, and this case can only be distinguished if the
2652 * called function can set a new error status. */
2653 bus->error_status = 0;
2654
2655 /* The HBA has generically asked to be kicked on retry */
2656 if (error_status & IDE_RETRY_HBA) {
2657 if (s->bus->dma->ops->restart) {
2658 s->bus->dma->ops->restart(s->bus->dma);
2659 }
2660 } else if (IS_IDE_RETRY_DMA(error_status)) {
2661 if (error_status & IDE_RETRY_TRIM) {
2662 ide_restart_dma(s, IDE_DMA_TRIM);
2663 } else {
2664 ide_restart_dma(s, is_read ? IDE_DMA_READ : IDE_DMA_WRITE);
2665 }
2666 } else if (IS_IDE_RETRY_PIO(error_status)) {
2667 if (is_read) {
2668 ide_sector_read(s);
2669 } else {
2670 ide_sector_write(s);
2671 }
2672 } else if (error_status & IDE_RETRY_FLUSH) {
2673 ide_flush_cache(s);
2674 } else if (IS_IDE_RETRY_ATAPI(error_status)) {
2675 assert(s->end_transfer_func == ide_atapi_cmd);
2676 ide_atapi_dma_restart(s);
2677 } else {
2678 abort();
2679 }
2680 }
2681
2682 static void ide_restart_cb(void *opaque, int running, RunState state)
2683 {
2684 IDEBus *bus = opaque;
2685
2686 if (!running)
2687 return;
2688
2689 if (!bus->bh) {
2690 bus->bh = qemu_bh_new(ide_restart_bh, bus);
2691 qemu_bh_schedule(bus->bh);
2692 }
2693 }
2694
2695 void ide_register_restart_cb(IDEBus *bus)
2696 {
2697 if (bus->dma->ops->restart_dma) {
2698 bus->vmstate = qemu_add_vm_change_state_handler(ide_restart_cb, bus);
2699 }
2700 }
2701
2702 static IDEDMA ide_dma_nop = {
2703 .ops = &ide_dma_nop_ops,
2704 .aiocb = NULL,
2705 };
2706
2707 void ide_init2(IDEBus *bus, qemu_irq irq)
2708 {
2709 int i;
2710
2711 for(i = 0; i < 2; i++) {
2712 ide_init1(bus, i);
2713 ide_reset(&bus->ifs[i]);
2714 }
2715 bus->irq = irq;
2716 bus->dma = &ide_dma_nop;
2717 }
2718
2719 void ide_exit(IDEState *s)
2720 {
2721 timer_del(s->sector_write_timer);
2722 timer_free(s->sector_write_timer);
2723 qemu_vfree(s->smart_selftest_data);
2724 qemu_vfree(s->io_buffer);
2725 }
2726
2727 static bool is_identify_set(void *opaque, int version_id)
2728 {
2729 IDEState *s = opaque;
2730
2731 return s->identify_set != 0;
2732 }
2733
2734 static EndTransferFunc* transfer_end_table[] = {
2735 ide_sector_read,
2736 ide_sector_write,
2737 ide_transfer_stop,
2738 ide_atapi_cmd_reply_end,
2739 ide_atapi_cmd,
2740 ide_dummy_transfer_stop,
2741 };
2742
2743 static int transfer_end_table_idx(EndTransferFunc *fn)
2744 {
2745 int i;
2746
2747 for (i = 0; i < ARRAY_SIZE(transfer_end_table); i++)
2748 if (transfer_end_table[i] == fn)
2749 return i;
2750
2751 return -1;
2752 }
2753
2754 static int ide_drive_post_load(void *opaque, int version_id)
2755 {
2756 IDEState *s = opaque;
2757
2758 if (s->blk && s->identify_set) {
2759 blk_set_enable_write_cache(s->blk, !!(s->identify_data[85] & (1 << 5)));
2760 }
2761 return 0;
2762 }
2763
2764 static int ide_drive_pio_post_load(void *opaque, int version_id)
2765 {
2766 IDEState *s = opaque;
2767
2768 if (s->end_transfer_fn_idx >= ARRAY_SIZE(transfer_end_table)) {
2769 return -EINVAL;
2770 }
2771 s->end_transfer_func = transfer_end_table[s->end_transfer_fn_idx];
2772 s->data_ptr = s->io_buffer + s->cur_io_buffer_offset;
2773 s->data_end = s->data_ptr + s->cur_io_buffer_len;
2774 s->atapi_dma = s->feature & 1; /* as per cmd_packet */
2775
2776 return 0;
2777 }
2778
2779 static int ide_drive_pio_pre_save(void *opaque)
2780 {
2781 IDEState *s = opaque;
2782 int idx;
2783
2784 s->cur_io_buffer_offset = s->data_ptr - s->io_buffer;
2785 s->cur_io_buffer_len = s->data_end - s->data_ptr;
2786
2787 idx = transfer_end_table_idx(s->end_transfer_func);
2788 if (idx == -1) {
2789 fprintf(stderr, "%s: invalid end_transfer_func for DRQ_STAT\n",
2790 __func__);
2791 s->end_transfer_fn_idx = 2;
2792 } else {
2793 s->end_transfer_fn_idx = idx;
2794 }
2795
2796 return 0;
2797 }
2798
2799 static bool ide_drive_pio_state_needed(void *opaque)
2800 {
2801 IDEState *s = opaque;
2802
2803 return ((s->status & DRQ_STAT) != 0)
2804 || (s->bus->error_status & IDE_RETRY_PIO);
2805 }
2806
2807 static bool ide_tray_state_needed(void *opaque)
2808 {
2809 IDEState *s = opaque;
2810
2811 return s->tray_open || s->tray_locked;
2812 }
2813
2814 static bool ide_atapi_gesn_needed(void *opaque)
2815 {
2816 IDEState *s = opaque;
2817
2818 return s->events.new_media || s->events.eject_request;
2819 }
2820
2821 static bool ide_error_needed(void *opaque)
2822 {
2823 IDEBus *bus = opaque;
2824
2825 return (bus->error_status != 0);
2826 }
2827
2828 /* Fields for GET_EVENT_STATUS_NOTIFICATION ATAPI command */
2829 static const VMStateDescription vmstate_ide_atapi_gesn_state = {
2830 .name ="ide_drive/atapi/gesn_state",
2831 .version_id = 1,
2832 .minimum_version_id = 1,
2833 .needed = ide_atapi_gesn_needed,
2834 .fields = (VMStateField[]) {
2835 VMSTATE_BOOL(events.new_media, IDEState),
2836 VMSTATE_BOOL(events.eject_request, IDEState),
2837 VMSTATE_END_OF_LIST()
2838 }
2839 };
2840
2841 static const VMStateDescription vmstate_ide_tray_state = {
2842 .name = "ide_drive/tray_state",
2843 .version_id = 1,
2844 .minimum_version_id = 1,
2845 .needed = ide_tray_state_needed,
2846 .fields = (VMStateField[]) {
2847 VMSTATE_BOOL(tray_open, IDEState),
2848 VMSTATE_BOOL(tray_locked, IDEState),
2849 VMSTATE_END_OF_LIST()
2850 }
2851 };
2852
2853 static const VMStateDescription vmstate_ide_drive_pio_state = {
2854 .name = "ide_drive/pio_state",
2855 .version_id = 1,
2856 .minimum_version_id = 1,
2857 .pre_save = ide_drive_pio_pre_save,
2858 .post_load = ide_drive_pio_post_load,
2859 .needed = ide_drive_pio_state_needed,
2860 .fields = (VMStateField[]) {
2861 VMSTATE_INT32(req_nb_sectors, IDEState),
2862 VMSTATE_VARRAY_INT32(io_buffer, IDEState, io_buffer_total_len, 1,
2863 vmstate_info_uint8, uint8_t),
2864 VMSTATE_INT32(cur_io_buffer_offset, IDEState),
2865 VMSTATE_INT32(cur_io_buffer_len, IDEState),
2866 VMSTATE_UINT8(end_transfer_fn_idx, IDEState),
2867 VMSTATE_INT32(elementary_transfer_size, IDEState),
2868 VMSTATE_INT32(packet_transfer_size, IDEState),
2869 VMSTATE_END_OF_LIST()
2870 }
2871 };
2872
2873 const VMStateDescription vmstate_ide_drive = {
2874 .name = "ide_drive",
2875 .version_id = 3,
2876 .minimum_version_id = 0,
2877 .post_load = ide_drive_post_load,
2878 .fields = (VMStateField[]) {
2879 VMSTATE_INT32(mult_sectors, IDEState),
2880 VMSTATE_INT32(identify_set, IDEState),
2881 VMSTATE_BUFFER_TEST(identify_data, IDEState, is_identify_set),
2882 VMSTATE_UINT8(feature, IDEState),
2883 VMSTATE_UINT8(error, IDEState),
2884 VMSTATE_UINT32(nsector, IDEState),
2885 VMSTATE_UINT8(sector, IDEState),
2886 VMSTATE_UINT8(lcyl, IDEState),
2887 VMSTATE_UINT8(hcyl, IDEState),
2888 VMSTATE_UINT8(hob_feature, IDEState),
2889 VMSTATE_UINT8(hob_sector, IDEState),
2890 VMSTATE_UINT8(hob_nsector, IDEState),
2891 VMSTATE_UINT8(hob_lcyl, IDEState),
2892 VMSTATE_UINT8(hob_hcyl, IDEState),
2893 VMSTATE_UINT8(select, IDEState),
2894 VMSTATE_UINT8(status, IDEState),
2895 VMSTATE_UINT8(lba48, IDEState),
2896 VMSTATE_UINT8(sense_key, IDEState),
2897 VMSTATE_UINT8(asc, IDEState),
2898 VMSTATE_UINT8_V(cdrom_changed, IDEState, 3),
2899 VMSTATE_END_OF_LIST()
2900 },
2901 .subsections = (const VMStateDescription*[]) {
2902 &vmstate_ide_drive_pio_state,
2903 &vmstate_ide_tray_state,
2904 &vmstate_ide_atapi_gesn_state,
2905 NULL
2906 }
2907 };
2908
2909 static const VMStateDescription vmstate_ide_error_status = {
2910 .name ="ide_bus/error",
2911 .version_id = 2,
2912 .minimum_version_id = 1,
2913 .needed = ide_error_needed,
2914 .fields = (VMStateField[]) {
2915 VMSTATE_INT32(error_status, IDEBus),
2916 VMSTATE_INT64_V(retry_sector_num, IDEBus, 2),
2917 VMSTATE_UINT32_V(retry_nsector, IDEBus, 2),
2918 VMSTATE_UINT8_V(retry_unit, IDEBus, 2),
2919 VMSTATE_END_OF_LIST()
2920 }
2921 };
2922
2923 const VMStateDescription vmstate_ide_bus = {
2924 .name = "ide_bus",
2925 .version_id = 1,
2926 .minimum_version_id = 1,
2927 .fields = (VMStateField[]) {
2928 VMSTATE_UINT8(cmd, IDEBus),
2929 VMSTATE_UINT8(unit, IDEBus),
2930 VMSTATE_END_OF_LIST()
2931 },
2932 .subsections = (const VMStateDescription*[]) {
2933 &vmstate_ide_error_status,
2934 NULL
2935 }
2936 };
2937
2938 void ide_drive_get(DriveInfo **hd, int n)
2939 {
2940 int i;
2941
2942 for (i = 0; i < n; i++) {
2943 hd[i] = drive_get_by_index(IF_IDE, i);
2944 }
2945 }
QEMU mirror