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