?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Convert IDE to use new dma helpers (Avi Kivity)
[qemu.git] / hw / ide.c
blob1db0bcdf58435dcc2bb2adfd9d100d529f184f2e
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.h"
26 #include "pc.h"
27 #include "pci.h"
28 #include "scsi-disk.h"
29 #include "pcmcia.h"
30 #include "block.h"
31 #include "qemu-timer.h"
32 #include "sysemu.h"
33 #include "ppc_mac.h"
34 #include "mac_dbdma.h"
35 #include "sh.h"
36 #include "dma.h"
37
38 /* debug IDE devices */
39 //#define DEBUG_IDE
40 //#define DEBUG_IDE_ATAPI
41 //#define DEBUG_AIO
42 #define USE_DMA_CDROM
43
44 /* Bits of HD_STATUS */
45 #define ERR_STAT 0x01
46 #define INDEX_STAT 0x02
47 #define ECC_STAT 0x04 /* Corrected error */
48 #define DRQ_STAT 0x08
49 #define SEEK_STAT 0x10
50 #define SRV_STAT 0x10
51 #define WRERR_STAT 0x20
52 #define READY_STAT 0x40
53 #define BUSY_STAT 0x80
54
55 /* Bits for HD_ERROR */
56 #define MARK_ERR 0x01 /* Bad address mark */
57 #define TRK0_ERR 0x02 /* couldn't find track 0 */
58 #define ABRT_ERR 0x04 /* Command aborted */
59 #define MCR_ERR 0x08 /* media change request */
60 #define ID_ERR 0x10 /* ID field not found */
61 #define MC_ERR 0x20 /* media changed */
62 #define ECC_ERR 0x40 /* Uncorrectable ECC error */
63 #define BBD_ERR 0x80 /* pre-EIDE meaning: block marked bad */
64 #define ICRC_ERR 0x80 /* new meaning: CRC error during transfer */
65
66 /* Bits of HD_NSECTOR */
67 #define CD 0x01
68 #define IO 0x02
69 #define REL 0x04
70 #define TAG_MASK 0xf8
71
72 #define IDE_CMD_RESET 0x04
73 #define IDE_CMD_DISABLE_IRQ 0x02
74
75 /* ATA/ATAPI Commands pre T13 Spec */
76 #define WIN_NOP 0x00
77 /*
78 * 0x01->0x02 Reserved
79 */
80 #define CFA_REQ_EXT_ERROR_CODE 0x03 /* CFA Request Extended Error Code */
81 /*
82 * 0x04->0x07 Reserved
83 */
84 #define WIN_SRST 0x08 /* ATAPI soft reset command */
85 #define WIN_DEVICE_RESET 0x08
86 /*
87 * 0x09->0x0F Reserved
88 */
89 #define WIN_RECAL 0x10
90 #define WIN_RESTORE WIN_RECAL
91 /*
92 * 0x10->0x1F Reserved
93 */
94 #define WIN_READ 0x20 /* 28-Bit */
95 #define WIN_READ_ONCE 0x21 /* 28-Bit without retries */
96 #define WIN_READ_LONG 0x22 /* 28-Bit */
97 #define WIN_READ_LONG_ONCE 0x23 /* 28-Bit without retries */
98 #define WIN_READ_EXT 0x24 /* 48-Bit */
99 #define WIN_READDMA_EXT 0x25 /* 48-Bit */
100 #define WIN_READDMA_QUEUED_EXT 0x26 /* 48-Bit */
101 #define WIN_READ_NATIVE_MAX_EXT 0x27 /* 48-Bit */
102 /*
103 * 0x28
104 */
105 #define WIN_MULTREAD_EXT 0x29 /* 48-Bit */
106 /*
107 * 0x2A->0x2F Reserved
108 */
109 #define WIN_WRITE 0x30 /* 28-Bit */
110 #define WIN_WRITE_ONCE 0x31 /* 28-Bit without retries */
111 #define WIN_WRITE_LONG 0x32 /* 28-Bit */
112 #define WIN_WRITE_LONG_ONCE 0x33 /* 28-Bit without retries */
113 #define WIN_WRITE_EXT 0x34 /* 48-Bit */
114 #define WIN_WRITEDMA_EXT 0x35 /* 48-Bit */
115 #define WIN_WRITEDMA_QUEUED_EXT 0x36 /* 48-Bit */
116 #define WIN_SET_MAX_EXT 0x37 /* 48-Bit */
117 #define CFA_WRITE_SECT_WO_ERASE 0x38 /* CFA Write Sectors without erase */
118 #define WIN_MULTWRITE_EXT 0x39 /* 48-Bit */
119 /*
120 * 0x3A->0x3B Reserved
121 */
122 #define WIN_WRITE_VERIFY 0x3C /* 28-Bit */
123 /*
124 * 0x3D->0x3F Reserved
125 */
126 #define WIN_VERIFY 0x40 /* 28-Bit - Read Verify Sectors */
127 #define WIN_VERIFY_ONCE 0x41 /* 28-Bit - without retries */
128 #define WIN_VERIFY_EXT 0x42 /* 48-Bit */
129 /*
130 * 0x43->0x4F Reserved
131 */
132 #define WIN_FORMAT 0x50
133 /*
134 * 0x51->0x5F Reserved
135 */
136 #define WIN_INIT 0x60
137 /*
138 * 0x61->0x5F Reserved
139 */
140 #define WIN_SEEK 0x70 /* 0x70-0x7F Reserved */
141 #define CFA_TRANSLATE_SECTOR 0x87 /* CFA Translate Sector */
142 #define WIN_DIAGNOSE 0x90
143 #define WIN_SPECIFY 0x91 /* set drive geometry translation */
144 #define WIN_DOWNLOAD_MICROCODE 0x92
145 #define WIN_STANDBYNOW2 0x94
146 #define CFA_IDLEIMMEDIATE 0x95 /* force drive to become "ready" */
147 #define WIN_STANDBY2 0x96
148 #define WIN_SETIDLE2 0x97
149 #define WIN_CHECKPOWERMODE2 0x98
150 #define WIN_SLEEPNOW2 0x99
151 /*
152 * 0x9A VENDOR
153 */
154 #define WIN_PACKETCMD 0xA0 /* Send a packet command. */
155 #define WIN_PIDENTIFY 0xA1 /* identify ATAPI device */
156 #define WIN_QUEUED_SERVICE 0xA2
157 #define WIN_SMART 0xB0 /* self-monitoring and reporting */
158 #define CFA_ACCESS_METADATA_STORAGE 0xB8
159 #define CFA_ERASE_SECTORS 0xC0 /* microdrives implement as NOP */
160 #define WIN_MULTREAD 0xC4 /* read sectors using multiple mode*/
161 #define WIN_MULTWRITE 0xC5 /* write sectors using multiple mode */
162 #define WIN_SETMULT 0xC6 /* enable/disable multiple mode */
163 #define WIN_READDMA_QUEUED 0xC7 /* read sectors using Queued DMA transfers */
164 #define WIN_READDMA 0xC8 /* read sectors using DMA transfers */
165 #define WIN_READDMA_ONCE 0xC9 /* 28-Bit - without retries */
166 #define WIN_WRITEDMA 0xCA /* write sectors using DMA transfers */
167 #define WIN_WRITEDMA_ONCE 0xCB /* 28-Bit - without retries */
168 #define WIN_WRITEDMA_QUEUED 0xCC /* write sectors using Queued DMA transfers */
169 #define CFA_WRITE_MULTI_WO_ERASE 0xCD /* CFA Write multiple without erase */
170 #define WIN_GETMEDIASTATUS 0xDA
171 #define WIN_ACKMEDIACHANGE 0xDB /* ATA-1, ATA-2 vendor */
172 #define WIN_POSTBOOT 0xDC
173 #define WIN_PREBOOT 0xDD
174 #define WIN_DOORLOCK 0xDE /* lock door on removable drives */
175 #define WIN_DOORUNLOCK 0xDF /* unlock door on removable drives */
176 #define WIN_STANDBYNOW1 0xE0
177 #define WIN_IDLEIMMEDIATE 0xE1 /* force drive to become "ready" */
178 #define WIN_STANDBY 0xE2 /* Set device in Standby Mode */
179 #define WIN_SETIDLE1 0xE3
180 #define WIN_READ_BUFFER 0xE4 /* force read only 1 sector */
181 #define WIN_CHECKPOWERMODE1 0xE5
182 #define WIN_SLEEPNOW1 0xE6
183 #define WIN_FLUSH_CACHE 0xE7
184 #define WIN_WRITE_BUFFER 0xE8 /* force write only 1 sector */
185 #define WIN_WRITE_SAME 0xE9 /* read ata-2 to use */
186 /* SET_FEATURES 0x22 or 0xDD */
187 #define WIN_FLUSH_CACHE_EXT 0xEA /* 48-Bit */
188 #define WIN_IDENTIFY 0xEC /* ask drive to identify itself */
189 #define WIN_MEDIAEJECT 0xED
190 #define WIN_IDENTIFY_DMA 0xEE /* same as WIN_IDENTIFY, but DMA */
191 #define WIN_SETFEATURES 0xEF /* set special drive features */
192 #define EXABYTE_ENABLE_NEST 0xF0
193 #define IBM_SENSE_CONDITION 0xF0 /* measure disk temperature */
194 #define WIN_SECURITY_SET_PASS 0xF1
195 #define WIN_SECURITY_UNLOCK 0xF2
196 #define WIN_SECURITY_ERASE_PREPARE 0xF3
197 #define WIN_SECURITY_ERASE_UNIT 0xF4
198 #define WIN_SECURITY_FREEZE_LOCK 0xF5
199 #define CFA_WEAR_LEVEL 0xF5 /* microdrives implement as NOP */
200 #define WIN_SECURITY_DISABLE 0xF6
201 #define WIN_READ_NATIVE_MAX 0xF8 /* return the native maximum address */
202 #define WIN_SET_MAX 0xF9
203 #define DISABLE_SEAGATE 0xFB
204
205 /* set to 1 set disable mult support */
206 #define MAX_MULT_SECTORS 16
207
208 #define IDE_DMA_BUF_SECTORS 256
209
210 #if (IDE_DMA_BUF_SECTORS < MAX_MULT_SECTORS)
211 #error "IDE_DMA_BUF_SECTORS must be bigger or equal to MAX_MULT_SECTORS"
212 #endif
213
214 /* ATAPI defines */
215
216 #define ATAPI_PACKET_SIZE 12
217
218 /* The generic packet command opcodes for CD/DVD Logical Units,
219 * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
220 #define GPCMD_BLANK 0xa1
221 #define GPCMD_CLOSE_TRACK 0x5b
222 #define GPCMD_FLUSH_CACHE 0x35
223 #define GPCMD_FORMAT_UNIT 0x04
224 #define GPCMD_GET_CONFIGURATION 0x46
225 #define GPCMD_GET_EVENT_STATUS_NOTIFICATION 0x4a
226 #define GPCMD_GET_PERFORMANCE 0xac
227 #define GPCMD_INQUIRY 0x12
228 #define GPCMD_LOAD_UNLOAD 0xa6
229 #define GPCMD_MECHANISM_STATUS 0xbd
230 #define GPCMD_MODE_SELECT_10 0x55
231 #define GPCMD_MODE_SENSE_10 0x5a
232 #define GPCMD_PAUSE_RESUME 0x4b
233 #define GPCMD_PLAY_AUDIO_10 0x45
234 #define GPCMD_PLAY_AUDIO_MSF 0x47
235 #define GPCMD_PLAY_AUDIO_TI 0x48
236 #define GPCMD_PLAY_CD 0xbc
237 #define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
238 #define GPCMD_READ_10 0x28
239 #define GPCMD_READ_12 0xa8
240 #define GPCMD_READ_CDVD_CAPACITY 0x25
241 #define GPCMD_READ_CD 0xbe
242 #define GPCMD_READ_CD_MSF 0xb9
243 #define GPCMD_READ_DISC_INFO 0x51
244 #define GPCMD_READ_DVD_STRUCTURE 0xad
245 #define GPCMD_READ_FORMAT_CAPACITIES 0x23
246 #define GPCMD_READ_HEADER 0x44
247 #define GPCMD_READ_TRACK_RZONE_INFO 0x52
248 #define GPCMD_READ_SUBCHANNEL 0x42
249 #define GPCMD_READ_TOC_PMA_ATIP 0x43
250 #define GPCMD_REPAIR_RZONE_TRACK 0x58
251 #define GPCMD_REPORT_KEY 0xa4
252 #define GPCMD_REQUEST_SENSE 0x03
253 #define GPCMD_RESERVE_RZONE_TRACK 0x53
254 #define GPCMD_SCAN 0xba
255 #define GPCMD_SEEK 0x2b
256 #define GPCMD_SEND_DVD_STRUCTURE 0xad
257 #define GPCMD_SEND_EVENT 0xa2
258 #define GPCMD_SEND_KEY 0xa3
259 #define GPCMD_SEND_OPC 0x54
260 #define GPCMD_SET_READ_AHEAD 0xa7
261 #define GPCMD_SET_STREAMING 0xb6
262 #define GPCMD_START_STOP_UNIT 0x1b
263 #define GPCMD_STOP_PLAY_SCAN 0x4e
264 #define GPCMD_TEST_UNIT_READY 0x00
265 #define GPCMD_VERIFY_10 0x2f
266 #define GPCMD_WRITE_10 0x2a
267 #define GPCMD_WRITE_AND_VERIFY_10 0x2e
268 /* This is listed as optional in ATAPI 2.6, but is (curiously)
269 * missing from Mt. Fuji, Table 57. It _is_ mentioned in Mt. Fuji
270 * Table 377 as an MMC command for SCSi devices though... Most ATAPI
271 * drives support it. */
272 #define GPCMD_SET_SPEED 0xbb
273 /* This seems to be a SCSI specific CD-ROM opcode
274 * to play data at track/index */
275 #define GPCMD_PLAYAUDIO_TI 0x48
276 /*
277 * From MS Media Status Notification Support Specification. For
278 * older drives only.
279 */
280 #define GPCMD_GET_MEDIA_STATUS 0xda
281 #define GPCMD_MODE_SENSE_6 0x1a
282
283 /* Mode page codes for mode sense/set */
284 #define GPMODE_R_W_ERROR_PAGE 0x01
285 #define GPMODE_WRITE_PARMS_PAGE 0x05
286 #define GPMODE_AUDIO_CTL_PAGE 0x0e
287 #define GPMODE_POWER_PAGE 0x1a
288 #define GPMODE_FAULT_FAIL_PAGE 0x1c
289 #define GPMODE_TO_PROTECT_PAGE 0x1d
290 #define GPMODE_CAPABILITIES_PAGE 0x2a
291 #define GPMODE_ALL_PAGES 0x3f
292 /* Not in Mt. Fuji, but in ATAPI 2.6 -- depricated now in favor
293 * of MODE_SENSE_POWER_PAGE */
294 #define GPMODE_CDROM_PAGE 0x0d
295
296 /*
297 * Based on values from <linux/cdrom.h> but extending CD_MINS
298 * to the maximum common size allowed by the Orange's Book ATIP
299 *
300 * 90 and 99 min CDs are also available but using them as the
301 * upper limit reduces the effectiveness of the heuristic to
302 * detect DVDs burned to less than 25% of their maximum capacity
303 */
304
305 /* Some generally useful CD-ROM information */
306 #define CD_MINS 80 /* max. minutes per CD */
307 #define CD_SECS 60 /* seconds per minute */
308 #define CD_FRAMES 75 /* frames per second */
309 #define CD_FRAMESIZE 2048 /* bytes per frame, "cooked" mode */
310 #define CD_MAX_BYTES (CD_MINS * CD_SECS * CD_FRAMES * CD_FRAMESIZE)
311 #define CD_MAX_SECTORS (CD_MAX_BYTES / 512)
312
313 /*
314 * The MMC values are not IDE specific and might need to be moved
315 * to a common header if they are also needed for the SCSI emulation
316 */
317
318 /* Profile list from MMC-6 revision 1 table 91 */
319 #define MMC_PROFILE_NONE 0x0000
320 #define MMC_PROFILE_CD_ROM 0x0008
321 #define MMC_PROFILE_CD_R 0x0009
322 #define MMC_PROFILE_CD_RW 0x000A
323 #define MMC_PROFILE_DVD_ROM 0x0010
324 #define MMC_PROFILE_DVD_R_SR 0x0011
325 #define MMC_PROFILE_DVD_RAM 0x0012
326 #define MMC_PROFILE_DVD_RW_RO 0x0013
327 #define MMC_PROFILE_DVD_RW_SR 0x0014
328 #define MMC_PROFILE_DVD_R_DL_SR 0x0015
329 #define MMC_PROFILE_DVD_R_DL_JR 0x0016
330 #define MMC_PROFILE_DVD_RW_DL 0x0017
331 #define MMC_PROFILE_DVD_DDR 0x0018
332 #define MMC_PROFILE_DVD_PLUS_RW 0x001A
333 #define MMC_PROFILE_DVD_PLUS_R 0x001B
334 #define MMC_PROFILE_DVD_PLUS_RW_DL 0x002A
335 #define MMC_PROFILE_DVD_PLUS_R_DL 0x002B
336 #define MMC_PROFILE_BD_ROM 0x0040
337 #define MMC_PROFILE_BD_R_SRM 0x0041
338 #define MMC_PROFILE_BD_R_RRM 0x0042
339 #define MMC_PROFILE_BD_RE 0x0043
340 #define MMC_PROFILE_HDDVD_ROM 0x0050
341 #define MMC_PROFILE_HDDVD_R 0x0051
342 #define MMC_PROFILE_HDDVD_RAM 0x0052
343 #define MMC_PROFILE_HDDVD_RW 0x0053
344 #define MMC_PROFILE_HDDVD_R_DL 0x0058
345 #define MMC_PROFILE_HDDVD_RW_DL 0x005A
346 #define MMC_PROFILE_INVALID 0xFFFF
347
348 #define ATAPI_INT_REASON_CD 0x01 /* 0 = data transfer */
349 #define ATAPI_INT_REASON_IO 0x02 /* 1 = transfer to the host */
350 #define ATAPI_INT_REASON_REL 0x04
351 #define ATAPI_INT_REASON_TAG 0xf8
352
353 /* same constants as bochs */
354 #define ASC_ILLEGAL_OPCODE 0x20
355 #define ASC_LOGICAL_BLOCK_OOR 0x21
356 #define ASC_INV_FIELD_IN_CMD_PACKET 0x24
357 #define ASC_MEDIUM_MAY_HAVE_CHANGED 0x28
358 #define ASC_INCOMPATIBLE_FORMAT 0x30
359 #define ASC_MEDIUM_NOT_PRESENT 0x3a
360 #define ASC_SAVING_PARAMETERS_NOT_SUPPORTED 0x39
361
362 #define CFA_NO_ERROR 0x00
363 #define CFA_MISC_ERROR 0x09
364 #define CFA_INVALID_COMMAND 0x20
365 #define CFA_INVALID_ADDRESS 0x21
366 #define CFA_ADDRESS_OVERFLOW 0x2f
367
368 #define SENSE_NONE 0
369 #define SENSE_NOT_READY 2
370 #define SENSE_ILLEGAL_REQUEST 5
371 #define SENSE_UNIT_ATTENTION 6
372
373 struct IDEState;
374
375 typedef void EndTransferFunc(struct IDEState *);
376
377 /* NOTE: IDEState represents in fact one drive */
378 typedef struct IDEState {
379 /* ide config */
380 int is_cdrom;
381 int is_cf;
382 int cylinders, heads, sectors;
383 int64_t nb_sectors;
384 int mult_sectors;
385 int identify_set;
386 uint16_t identify_data[256];
387 qemu_irq irq;
388 PCIDevice *pci_dev;
389 struct BMDMAState *bmdma;
390 int drive_serial;
391 char drive_serial_str[21];
392 /* ide regs */
393 uint8_t feature;
394 uint8_t error;
395 uint32_t nsector;
396 uint8_t sector;
397 uint8_t lcyl;
398 uint8_t hcyl;
399 /* other part of tf for lba48 support */
400 uint8_t hob_feature;
401 uint8_t hob_nsector;
402 uint8_t hob_sector;
403 uint8_t hob_lcyl;
404 uint8_t hob_hcyl;
405
406 uint8_t select;
407 uint8_t status;
408
409 /* 0x3f6 command, only meaningful for drive 0 */
410 uint8_t cmd;
411 /* set for lba48 access */
412 uint8_t lba48;
413 /* depends on bit 4 in select, only meaningful for drive 0 */
414 struct IDEState *cur_drive;
415 BlockDriverState *bs;
416 /* ATAPI specific */
417 uint8_t sense_key;
418 uint8_t asc;
419 int packet_transfer_size;
420 int elementary_transfer_size;
421 int io_buffer_index;
422 int lba;
423 int cd_sector_size;
424 int atapi_dma; /* true if dma is requested for the packet cmd */
425 /* ATA DMA state */
426 int io_buffer_size;
427 QEMUSGList sg;
428 /* PIO transfer handling */
429 int req_nb_sectors; /* number of sectors per interrupt */
430 EndTransferFunc *end_transfer_func;
431 uint8_t *data_ptr;
432 uint8_t *data_end;
433 uint8_t *io_buffer;
434 QEMUTimer *sector_write_timer; /* only used for win2k install hack */
435 uint32_t irq_count; /* counts IRQs when using win2k install hack */
436 /* CF-ATA extended error */
437 uint8_t ext_error;
438 /* CF-ATA metadata storage */
439 uint32_t mdata_size;
440 uint8_t *mdata_storage;
441 int media_changed;
442 /* for pmac */
443 int is_read;
444 } IDEState;
445
446 /* XXX: DVDs that could fit on a CD will be reported as a CD */
447 static inline int media_present(IDEState *s)
448 {
449 return (s->nb_sectors > 0);
450 }
451
452 static inline int media_is_dvd(IDEState *s)
453 {
454 return (media_present(s) && s->nb_sectors > CD_MAX_SECTORS);
455 }
456
457 static inline int media_is_cd(IDEState *s)
458 {
459 return (media_present(s) && s->nb_sectors <= CD_MAX_SECTORS);
460 }
461
462 #define BM_STATUS_DMAING 0x01
463 #define BM_STATUS_ERROR 0x02
464 #define BM_STATUS_INT 0x04
465 #define BM_STATUS_DMA_RETRY 0x08
466 #define BM_STATUS_PIO_RETRY 0x10
467
468 #define BM_CMD_START 0x01
469 #define BM_CMD_READ 0x08
470
471 #define IDE_TYPE_PIIX3 0
472 #define IDE_TYPE_CMD646 1
473 #define IDE_TYPE_PIIX4 2
474
475 /* CMD646 specific */
476 #define MRDMODE 0x71
477 #define MRDMODE_INTR_CH0 0x04
478 #define MRDMODE_INTR_CH1 0x08
479 #define MRDMODE_BLK_CH0 0x10
480 #define MRDMODE_BLK_CH1 0x20
481 #define UDIDETCR0 0x73
482 #define UDIDETCR1 0x7B
483
484 typedef struct BMDMAState {
485 uint8_t cmd;
486 uint8_t status;
487 uint32_t addr;
488
489 struct PCIIDEState *pci_dev;
490 /* current transfer state */
491 uint32_t cur_addr;
492 uint32_t cur_prd_last;
493 uint32_t cur_prd_addr;
494 uint32_t cur_prd_len;
495 IDEState *ide_if;
496 BlockDriverCompletionFunc *dma_cb;
497 BlockDriverAIOCB *aiocb;
498 int64_t sector_num;
499 uint32_t nsector;
500 } BMDMAState;
501
502 typedef struct PCIIDEState {
503 PCIDevice dev;
504 IDEState ide_if[4];
505 BMDMAState bmdma[2];
506 int type; /* see IDE_TYPE_xxx */
507 } PCIIDEState;
508
509 static void ide_dma_start(IDEState *s, BlockDriverCompletionFunc *dma_cb);
510 static void ide_dma_restart(IDEState *s);
511 static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret);
512
513 static void padstr(char *str, const char *src, int len)
514 {
515 int i, v;
516 for(i = 0; i < len; i++) {
517 if (*src)
518 v = *src++;
519 else
520 v = ' ';
521 str[i^1] = v;
522 }
523 }
524
525 static void padstr8(uint8_t *buf, int buf_size, const char *src)
526 {
527 int i;
528 for(i = 0; i < buf_size; i++) {
529 if (*src)
530 buf[i] = *src++;
531 else
532 buf[i] = ' ';
533 }
534 }
535
536 static void put_le16(uint16_t *p, unsigned int v)
537 {
538 *p = cpu_to_le16(v);
539 }
540
541 static void ide_identify(IDEState *s)
542 {
543 uint16_t *p;
544 unsigned int oldsize;
545
546 if (s->identify_set) {
547 memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
548 return;
549 }
550
551 memset(s->io_buffer, 0, 512);
552 p = (uint16_t *)s->io_buffer;
553 put_le16(p + 0, 0x0040);
554 put_le16(p + 1, s->cylinders);
555 put_le16(p + 3, s->heads);
556 put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
557 put_le16(p + 5, 512); /* XXX: retired, remove ? */
558 put_le16(p + 6, s->sectors);
559 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
560 put_le16(p + 20, 3); /* XXX: retired, remove ? */
561 put_le16(p + 21, 512); /* cache size in sectors */
562 put_le16(p + 22, 4); /* ecc bytes */
563 padstr((char *)(p + 23), QEMU_VERSION, 8); /* firmware version */
564 padstr((char *)(p + 27), "QEMU HARDDISK", 40); /* model */
565 #if MAX_MULT_SECTORS > 1
566 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
567 #endif
568 put_le16(p + 48, 1); /* dword I/O */
569 put_le16(p + 49, (1 << 11) | (1 << 9) | (1 << 8)); /* DMA and LBA supported */
570 put_le16(p + 51, 0x200); /* PIO transfer cycle */
571 put_le16(p + 52, 0x200); /* DMA transfer cycle */
572 put_le16(p + 53, 1 | (1 << 1) | (1 << 2)); /* words 54-58,64-70,88 are valid */
573 put_le16(p + 54, s->cylinders);
574 put_le16(p + 55, s->heads);
575 put_le16(p + 56, s->sectors);
576 oldsize = s->cylinders * s->heads * s->sectors;
577 put_le16(p + 57, oldsize);
578 put_le16(p + 58, oldsize >> 16);
579 if (s->mult_sectors)
580 put_le16(p + 59, 0x100 | s->mult_sectors);
581 put_le16(p + 60, s->nb_sectors);
582 put_le16(p + 61, s->nb_sectors >> 16);
583 put_le16(p + 62, 0x07); /* single word dma0-2 supported */
584 put_le16(p + 63, 0x07); /* mdma0-2 supported */
585 put_le16(p + 65, 120);
586 put_le16(p + 66, 120);
587 put_le16(p + 67, 120);
588 put_le16(p + 68, 120);
589 put_le16(p + 80, 0xf0); /* ata3 -> ata6 supported */
590 put_le16(p + 81, 0x16); /* conforms to ata5 */
591 put_le16(p + 82, (1 << 14));
592 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
593 put_le16(p + 83, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
594 put_le16(p + 84, (1 << 14));
595 put_le16(p + 85, (1 << 14));
596 /* 13=flush_cache_ext,12=flush_cache,10=lba48 */
597 put_le16(p + 86, (1 << 14) | (1 << 13) | (1 <<12) | (1 << 10));
598 put_le16(p + 87, (1 << 14));
599 put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
600 put_le16(p + 93, 1 | (1 << 14) | 0x2000);
601 put_le16(p + 100, s->nb_sectors);
602 put_le16(p + 101, s->nb_sectors >> 16);
603 put_le16(p + 102, s->nb_sectors >> 32);
604 put_le16(p + 103, s->nb_sectors >> 48);
605
606 memcpy(s->identify_data, p, sizeof(s->identify_data));
607 s->identify_set = 1;
608 }
609
610 static void ide_atapi_identify(IDEState *s)
611 {
612 uint16_t *p;
613
614 if (s->identify_set) {
615 memcpy(s->io_buffer, s->identify_data, sizeof(s->identify_data));
616 return;
617 }
618
619 memset(s->io_buffer, 0, 512);
620 p = (uint16_t *)s->io_buffer;
621 /* Removable CDROM, 50us response, 12 byte packets */
622 put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
623 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
624 put_le16(p + 20, 3); /* buffer type */
625 put_le16(p + 21, 512); /* cache size in sectors */
626 put_le16(p + 22, 4); /* ecc bytes */
627 padstr((char *)(p + 23), QEMU_VERSION, 8); /* firmware version */
628 padstr((char *)(p + 27), "QEMU DVD-ROM", 40); /* model */
629 put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
630 #ifdef USE_DMA_CDROM
631 put_le16(p + 49, 1 << 9 | 1 << 8); /* DMA and LBA supported */
632 put_le16(p + 53, 7); /* words 64-70, 54-58, 88 valid */
633 put_le16(p + 62, 7); /* single word dma0-2 supported */
634 put_le16(p + 63, 7); /* mdma0-2 supported */
635 put_le16(p + 64, 0x3f); /* PIO modes supported */
636 #else
637 put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
638 put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
639 put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
640 put_le16(p + 64, 1); /* PIO modes */
641 #endif
642 put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
643 put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
644 put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
645 put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
646
647 put_le16(p + 71, 30); /* in ns */
648 put_le16(p + 72, 30); /* in ns */
649
650 put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
651 #ifdef USE_DMA_CDROM
652 put_le16(p + 88, 0x3f | (1 << 13)); /* udma5 set and supported */
653 #endif
654 memcpy(s->identify_data, p, sizeof(s->identify_data));
655 s->identify_set = 1;
656 }
657
658 static void ide_cfata_identify(IDEState *s)
659 {
660 uint16_t *p;
661 uint32_t cur_sec;
662
663 p = (uint16_t *) s->identify_data;
664 if (s->identify_set)
665 goto fill_buffer;
666
667 memset(p, 0, sizeof(s->identify_data));
668
669 cur_sec = s->cylinders * s->heads * s->sectors;
670
671 put_le16(p + 0, 0x848a); /* CF Storage Card signature */
672 put_le16(p + 1, s->cylinders); /* Default cylinders */
673 put_le16(p + 3, s->heads); /* Default heads */
674 put_le16(p + 6, s->sectors); /* Default sectors per track */
675 put_le16(p + 7, s->nb_sectors >> 16); /* Sectors per card */
676 put_le16(p + 8, s->nb_sectors); /* Sectors per card */
677 padstr((char *)(p + 10), s->drive_serial_str, 20); /* serial number */
678 put_le16(p + 22, 0x0004); /* ECC bytes */
679 padstr((char *) (p + 23), QEMU_VERSION, 8); /* Firmware Revision */
680 padstr((char *) (p + 27), "QEMU MICRODRIVE", 40);/* Model number */
681 #if MAX_MULT_SECTORS > 1
682 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
683 #else
684 put_le16(p + 47, 0x0000);
685 #endif
686 put_le16(p + 49, 0x0f00); /* Capabilities */
687 put_le16(p + 51, 0x0002); /* PIO cycle timing mode */
688 put_le16(p + 52, 0x0001); /* DMA cycle timing mode */
689 put_le16(p + 53, 0x0003); /* Translation params valid */
690 put_le16(p + 54, s->cylinders); /* Current cylinders */
691 put_le16(p + 55, s->heads); /* Current heads */
692 put_le16(p + 56, s->sectors); /* Current sectors */
693 put_le16(p + 57, cur_sec); /* Current capacity */
694 put_le16(p + 58, cur_sec >> 16); /* Current capacity */
695 if (s->mult_sectors) /* Multiple sector setting */
696 put_le16(p + 59, 0x100 | s->mult_sectors);
697 put_le16(p + 60, s->nb_sectors); /* Total LBA sectors */
698 put_le16(p + 61, s->nb_sectors >> 16); /* Total LBA sectors */
699 put_le16(p + 63, 0x0203); /* Multiword DMA capability */
700 put_le16(p + 64, 0x0001); /* Flow Control PIO support */
701 put_le16(p + 65, 0x0096); /* Min. Multiword DMA cycle */
702 put_le16(p + 66, 0x0096); /* Rec. Multiword DMA cycle */
703 put_le16(p + 68, 0x00b4); /* Min. PIO cycle time */
704 put_le16(p + 82, 0x400c); /* Command Set supported */
705 put_le16(p + 83, 0x7068); /* Command Set supported */
706 put_le16(p + 84, 0x4000); /* Features supported */
707 put_le16(p + 85, 0x000c); /* Command Set enabled */
708 put_le16(p + 86, 0x7044); /* Command Set enabled */
709 put_le16(p + 87, 0x4000); /* Features enabled */
710 put_le16(p + 91, 0x4060); /* Current APM level */
711 put_le16(p + 129, 0x0002); /* Current features option */
712 put_le16(p + 130, 0x0005); /* Reassigned sectors */
713 put_le16(p + 131, 0x0001); /* Initial power mode */
714 put_le16(p + 132, 0x0000); /* User signature */
715 put_le16(p + 160, 0x8100); /* Power requirement */
716 put_le16(p + 161, 0x8001); /* CF command set */
717
718 s->identify_set = 1;
719
720 fill_buffer:
721 memcpy(s->io_buffer, p, sizeof(s->identify_data));
722 }
723
724 static void ide_set_signature(IDEState *s)
725 {
726 s->select &= 0xf0; /* clear head */
727 /* put signature */
728 s->nsector = 1;
729 s->sector = 1;
730 if (s->is_cdrom) {
731 s->lcyl = 0x14;
732 s->hcyl = 0xeb;
733 } else if (s->bs) {
734 s->lcyl = 0;
735 s->hcyl = 0;
736 } else {
737 s->lcyl = 0xff;
738 s->hcyl = 0xff;
739 }
740 }
741
742 static inline void ide_abort_command(IDEState *s)
743 {
744 s->status = READY_STAT | ERR_STAT;
745 s->error = ABRT_ERR;
746 }
747
748 static inline void ide_dma_submit_check(IDEState *s,
749 BlockDriverCompletionFunc *dma_cb, BMDMAState *bm)
750 {
751 if (bm->aiocb)
752 return;
753 dma_cb(bm, -1);
754 }
755
756 static inline void ide_set_irq(IDEState *s)
757 {
758 BMDMAState *bm = s->bmdma;
759 if (!(s->cmd & IDE_CMD_DISABLE_IRQ)) {
760 if (bm) {
761 bm->status |= BM_STATUS_INT;
762 }
763 qemu_irq_raise(s->irq);
764 }
765 }
766
767 /* prepare data transfer and tell what to do after */
768 static void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
769 EndTransferFunc *end_transfer_func)
770 {
771 s->end_transfer_func = end_transfer_func;
772 s->data_ptr = buf;
773 s->data_end = buf + size;
774 if (!(s->status & ERR_STAT))
775 s->status |= DRQ_STAT;
776 }
777
778 static void ide_transfer_stop(IDEState *s)
779 {
780 s->end_transfer_func = ide_transfer_stop;
781 s->data_ptr = s->io_buffer;
782 s->data_end = s->io_buffer;
783 s->status &= ~DRQ_STAT;
784 }
785
786 static int64_t ide_get_sector(IDEState *s)
787 {
788 int64_t sector_num;
789 if (s->select & 0x40) {
790 /* lba */
791 if (!s->lba48) {
792 sector_num = ((s->select & 0x0f) << 24) | (s->hcyl << 16) |
793 (s->lcyl << 8) | s->sector;
794 } else {
795 sector_num = ((int64_t)s->hob_hcyl << 40) |
796 ((int64_t) s->hob_lcyl << 32) |
797 ((int64_t) s->hob_sector << 24) |
798 ((int64_t) s->hcyl << 16) |
799 ((int64_t) s->lcyl << 8) | s->sector;
800 }
801 } else {
802 sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
803 (s->select & 0x0f) * s->sectors + (s->sector - 1);
804 }
805 return sector_num;
806 }
807
808 static void ide_set_sector(IDEState *s, int64_t sector_num)
809 {
810 unsigned int cyl, r;
811 if (s->select & 0x40) {
812 if (!s->lba48) {
813 s->select = (s->select & 0xf0) | (sector_num >> 24);
814 s->hcyl = (sector_num >> 16);
815 s->lcyl = (sector_num >> 8);
816 s->sector = (sector_num);
817 } else {
818 s->sector = sector_num;
819 s->lcyl = sector_num >> 8;
820 s->hcyl = sector_num >> 16;
821 s->hob_sector = sector_num >> 24;
822 s->hob_lcyl = sector_num >> 32;
823 s->hob_hcyl = sector_num >> 40;
824 }
825 } else {
826 cyl = sector_num / (s->heads * s->sectors);
827 r = sector_num % (s->heads * s->sectors);
828 s->hcyl = cyl >> 8;
829 s->lcyl = cyl;
830 s->select = (s->select & 0xf0) | ((r / s->sectors) & 0x0f);
831 s->sector = (r % s->sectors) + 1;
832 }
833 }
834
835 static void ide_rw_error(IDEState *s) {
836 ide_abort_command(s);
837 ide_set_irq(s);
838 }
839
840 static void ide_sector_read(IDEState *s)
841 {
842 int64_t sector_num;
843 int ret, n;
844
845 s->status = READY_STAT | SEEK_STAT;
846 s->error = 0; /* not needed by IDE spec, but needed by Windows */
847 sector_num = ide_get_sector(s);
848 n = s->nsector;
849 if (n == 0) {
850 /* no more sector to read from disk */
851 ide_transfer_stop(s);
852 } else {
853 #if defined(DEBUG_IDE)
854 printf("read sector=%" PRId64 "\n", sector_num);
855 #endif
856 if (n > s->req_nb_sectors)
857 n = s->req_nb_sectors;
858 ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
859 if (ret != 0) {
860 ide_rw_error(s);
861 return;
862 }
863 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_read);
864 ide_set_irq(s);
865 ide_set_sector(s, sector_num + n);
866 s->nsector -= n;
867 }
868 }
869
870
871 /* return 0 if buffer completed */
872 static int dma_buf_prepare(BMDMAState *bm, int is_write)
873 {
874 IDEState *s = bm->ide_if;
875 struct {
876 uint32_t addr;
877 uint32_t size;
878 } prd;
879 int l, len;
880
881 qemu_sglist_init(&s->sg, s->nsector / (TARGET_PAGE_SIZE/512) + 1);
882 s->io_buffer_size = 0;
883 for(;;) {
884 if (bm->cur_prd_len == 0) {
885 /* end of table (with a fail safe of one page) */
886 if (bm->cur_prd_last ||
887 (bm->cur_addr - bm->addr) >= 4096)
888 return s->io_buffer_size != 0;
889 cpu_physical_memory_read(bm->cur_addr, (uint8_t *)&prd, 8);
890 bm->cur_addr += 8;
891 prd.addr = le32_to_cpu(prd.addr);
892 prd.size = le32_to_cpu(prd.size);
893 len = prd.size & 0xfffe;
894 if (len == 0)
895 len = 0x10000;
896 bm->cur_prd_len = len;
897 bm->cur_prd_addr = prd.addr;
898 bm->cur_prd_last = (prd.size & 0x80000000);
899 }
900 l = bm->cur_prd_len;
901 if (l > 0) {
902 qemu_sglist_add(&s->sg, bm->cur_prd_addr, l);
903 bm->cur_prd_addr += l;
904 bm->cur_prd_len -= l;
905 s->io_buffer_size += l;
906 }
907 }
908 return 1;
909 }
910
911 static void dma_buf_commit(IDEState *s, int is_write)
912 {
913 qemu_sglist_destroy(&s->sg);
914 }
915
916 static void ide_dma_error(IDEState *s)
917 {
918 ide_transfer_stop(s);
919 s->error = ABRT_ERR;
920 s->status = READY_STAT | ERR_STAT;
921 ide_set_irq(s);
922 }
923
924 static int ide_handle_write_error(IDEState *s, int error, int op)
925 {
926 BlockInterfaceErrorAction action = drive_get_onerror(s->bs);
927
928 if (action == BLOCK_ERR_IGNORE)
929 return 0;
930
931 if ((error == ENOSPC && action == BLOCK_ERR_STOP_ENOSPC)
932 || action == BLOCK_ERR_STOP_ANY) {
933 s->bmdma->ide_if = s;
934 s->bmdma->status |= op;
935 vm_stop(0);
936 } else {
937 if (op == BM_STATUS_DMA_RETRY) {
938 dma_buf_commit(s, 0);
939 ide_dma_error(s);
940 } else {
941 ide_rw_error(s);
942 }
943 }
944
945 return 1;
946 }
947
948 /* return 0 if buffer completed */
949 static int dma_buf_rw(BMDMAState *bm, int is_write)
950 {
951 IDEState *s = bm->ide_if;
952 struct {
953 uint32_t addr;
954 uint32_t size;
955 } prd;
956 int l, len;
957
958 for(;;) {
959 l = s->io_buffer_size - s->io_buffer_index;
960 if (l <= 0)
961 break;
962 if (bm->cur_prd_len == 0) {
963 /* end of table (with a fail safe of one page) */
964 if (bm->cur_prd_last ||
965 (bm->cur_addr - bm->addr) >= 4096)
966 return 0;
967 cpu_physical_memory_read(bm->cur_addr, (uint8_t *)&prd, 8);
968 bm->cur_addr += 8;
969 prd.addr = le32_to_cpu(prd.addr);
970 prd.size = le32_to_cpu(prd.size);
971 len = prd.size & 0xfffe;
972 if (len == 0)
973 len = 0x10000;
974 bm->cur_prd_len = len;
975 bm->cur_prd_addr = prd.addr;
976 bm->cur_prd_last = (prd.size & 0x80000000);
977 }
978 if (l > bm->cur_prd_len)
979 l = bm->cur_prd_len;
980 if (l > 0) {
981 if (is_write) {
982 cpu_physical_memory_write(bm->cur_prd_addr,
983 s->io_buffer + s->io_buffer_index, l);
984 } else {
985 cpu_physical_memory_read(bm->cur_prd_addr,
986 s->io_buffer + s->io_buffer_index, l);
987 }
988 bm->cur_prd_addr += l;
989 bm->cur_prd_len -= l;
990 s->io_buffer_index += l;
991 }
992 }
993 return 1;
994 }
995
996 static void ide_read_dma_cb(void *opaque, int ret)
997 {
998 BMDMAState *bm = opaque;
999 IDEState *s = bm->ide_if;
1000 int n;
1001 int64_t sector_num;
1002
1003 if (ret < 0) {
1004 dma_buf_commit(s, 1);
1005 ide_dma_error(s);
1006 return;
1007 }
1008
1009 n = s->io_buffer_size >> 9;
1010 sector_num = ide_get_sector(s);
1011 if (n > 0) {
1012 dma_buf_commit(s, 1);
1013 sector_num += n;
1014 ide_set_sector(s, sector_num);
1015 s->nsector -= n;
1016 }
1017
1018 /* end of transfer ? */
1019 if (s->nsector == 0) {
1020 s->status = READY_STAT | SEEK_STAT;
1021 ide_set_irq(s);
1022 eot:
1023 bm->status &= ~BM_STATUS_DMAING;
1024 bm->status |= BM_STATUS_INT;
1025 bm->dma_cb = NULL;
1026 bm->ide_if = NULL;
1027 bm->aiocb = NULL;
1028 return;
1029 }
1030
1031 /* launch next transfer */
1032 n = s->nsector;
1033 s->io_buffer_index = 0;
1034 s->io_buffer_size = n * 512;
1035 if (dma_buf_prepare(bm, 1) == 0)
1036 goto eot;
1037 #ifdef DEBUG_AIO
1038 printf("aio_read: sector_num=%" PRId64 " n=%d\n", sector_num, n);
1039 #endif
1040 bm->aiocb = dma_bdrv_read(s->bs, &s->sg, sector_num, ide_read_dma_cb, bm);
1041 ide_dma_submit_check(s, ide_read_dma_cb, bm);
1042 }
1043
1044 static void ide_sector_read_dma(IDEState *s)
1045 {
1046 s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
1047 s->io_buffer_index = 0;
1048 s->io_buffer_size = 0;
1049 s->is_read = 1;
1050 ide_dma_start(s, ide_read_dma_cb);
1051 }
1052
1053 static void ide_sector_write_timer_cb(void *opaque)
1054 {
1055 IDEState *s = opaque;
1056 ide_set_irq(s);
1057 }
1058
1059 static void ide_sector_write(IDEState *s)
1060 {
1061 int64_t sector_num;
1062 int ret, n, n1;
1063
1064 s->status = READY_STAT | SEEK_STAT;
1065 sector_num = ide_get_sector(s);
1066 #if defined(DEBUG_IDE)
1067 printf("write sector=%" PRId64 "\n", sector_num);
1068 #endif
1069 n = s->nsector;
1070 if (n > s->req_nb_sectors)
1071 n = s->req_nb_sectors;
1072 ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
1073
1074 if (ret != 0) {
1075 if (ide_handle_write_error(s, -ret, BM_STATUS_PIO_RETRY))
1076 return;
1077 }
1078
1079 s->nsector -= n;
1080 if (s->nsector == 0) {
1081 /* no more sectors to write */
1082 ide_transfer_stop(s);
1083 } else {
1084 n1 = s->nsector;
1085 if (n1 > s->req_nb_sectors)
1086 n1 = s->req_nb_sectors;
1087 ide_transfer_start(s, s->io_buffer, 512 * n1, ide_sector_write);
1088 }
1089 ide_set_sector(s, sector_num + n);
1090
1091 #ifdef TARGET_I386
1092 if (win2k_install_hack && ((++s->irq_count % 16) == 0)) {
1093 /* It seems there is a bug in the Windows 2000 installer HDD
1094 IDE driver which fills the disk with empty logs when the
1095 IDE write IRQ comes too early. This hack tries to correct
1096 that at the expense of slower write performances. Use this
1097 option _only_ to install Windows 2000. You must disable it
1098 for normal use. */
1099 qemu_mod_timer(s->sector_write_timer,
1100 qemu_get_clock(vm_clock) + (ticks_per_sec / 1000));
1101 } else
1102 #endif
1103 {
1104 ide_set_irq(s);
1105 }
1106 }
1107
1108 static void ide_dma_restart_cb(void *opaque, int running, int reason)
1109 {
1110 BMDMAState *bm = opaque;
1111 if (!running)
1112 return;
1113 if (bm->status & BM_STATUS_DMA_RETRY) {
1114 bm->status &= ~BM_STATUS_DMA_RETRY;
1115 ide_dma_restart(bm->ide_if);
1116 } else if (bm->status & BM_STATUS_PIO_RETRY) {
1117 bm->status &= ~BM_STATUS_PIO_RETRY;
1118 ide_sector_write(bm->ide_if);
1119 }
1120 }
1121
1122 static void ide_write_dma_cb(void *opaque, int ret)
1123 {
1124 BMDMAState *bm = opaque;
1125 IDEState *s = bm->ide_if;
1126 int n;
1127 int64_t sector_num;
1128
1129 if (ret < 0) {
1130 if (ide_handle_write_error(s, -ret, BM_STATUS_DMA_RETRY))
1131 return;
1132 }
1133
1134 n = s->io_buffer_size >> 9;
1135 sector_num = ide_get_sector(s);
1136 if (n > 0) {
1137 dma_buf_commit(s, 0);
1138 sector_num += n;
1139 ide_set_sector(s, sector_num);
1140 s->nsector -= n;
1141 }
1142
1143 /* end of transfer ? */
1144 if (s->nsector == 0) {
1145 s->status = READY_STAT | SEEK_STAT;
1146 ide_set_irq(s);
1147 eot:
1148 bm->status &= ~BM_STATUS_DMAING;
1149 bm->status |= BM_STATUS_INT;
1150 bm->dma_cb = NULL;
1151 bm->ide_if = NULL;
1152 bm->aiocb = NULL;
1153 return;
1154 }
1155
1156 n = s->nsector;
1157 s->io_buffer_size = n * 512;
1158 /* launch next transfer */
1159 if (dma_buf_prepare(bm, 0) == 0)
1160 goto eot;
1161 #ifdef DEBUG_AIO
1162 printf("aio_write: sector_num=%" PRId64 " n=%d\n", sector_num, n);
1163 #endif
1164 bm->aiocb = dma_bdrv_write(s->bs, &s->sg, sector_num, ide_write_dma_cb, bm);
1165 ide_dma_submit_check(s, ide_write_dma_cb, bm);
1166 }
1167
1168 static void ide_sector_write_dma(IDEState *s)
1169 {
1170 s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
1171 s->io_buffer_index = 0;
1172 s->io_buffer_size = 0;
1173 s->is_read = 0;
1174 ide_dma_start(s, ide_write_dma_cb);
1175 }
1176
1177 static void ide_atapi_cmd_ok(IDEState *s)
1178 {
1179 s->error = 0;
1180 s->status = READY_STAT | SEEK_STAT;
1181 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
1182 ide_set_irq(s);
1183 }
1184
1185 static void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc)
1186 {
1187 #ifdef DEBUG_IDE_ATAPI
1188 printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key, asc);
1189 #endif
1190 s->error = sense_key << 4;
1191 s->status = READY_STAT | ERR_STAT;
1192 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
1193 s->sense_key = sense_key;
1194 s->asc = asc;
1195 ide_set_irq(s);
1196 }
1197
1198 static void ide_atapi_cmd_check_status(IDEState *s)
1199 {
1200 #ifdef DEBUG_IDE_ATAPI
1201 printf("atapi_cmd_check_status\n");
1202 #endif
1203 s->error = MC_ERR | (SENSE_UNIT_ATTENTION << 4);
1204 s->status = ERR_STAT;
1205 s->nsector = 0;
1206 ide_set_irq(s);
1207 }
1208
1209 static inline void cpu_to_ube16(uint8_t *buf, int val)
1210 {
1211 buf[0] = val >> 8;
1212 buf[1] = val;
1213 }
1214
1215 static inline void cpu_to_ube32(uint8_t *buf, unsigned int val)
1216 {
1217 buf[0] = val >> 24;
1218 buf[1] = val >> 16;
1219 buf[2] = val >> 8;
1220 buf[3] = val;
1221 }
1222
1223 static inline int ube16_to_cpu(const uint8_t *buf)
1224 {
1225 return (buf[0] << 8) | buf[1];
1226 }
1227
1228 static inline int ube32_to_cpu(const uint8_t *buf)
1229 {
1230 return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
1231 }
1232
1233 static void lba_to_msf(uint8_t *buf, int lba)
1234 {
1235 lba += 150;
1236 buf[0] = (lba / 75) / 60;
1237 buf[1] = (lba / 75) % 60;
1238 buf[2] = lba % 75;
1239 }
1240
1241 static void cd_data_to_raw(uint8_t *buf, int lba)
1242 {
1243 /* sync bytes */
1244 buf[0] = 0x00;
1245 memset(buf + 1, 0xff, 10);
1246 buf[11] = 0x00;
1247 buf += 12;
1248 /* MSF */
1249 lba_to_msf(buf, lba);
1250 buf[3] = 0x01; /* mode 1 data */
1251 buf += 4;
1252 /* data */
1253 buf += 2048;
1254 /* XXX: ECC not computed */
1255 memset(buf, 0, 288);
1256 }
1257
1258 static int cd_read_sector(BlockDriverState *bs, int lba, uint8_t *buf,
1259 int sector_size)
1260 {
1261 int ret;
1262
1263 switch(sector_size) {
1264 case 2048:
1265 ret = bdrv_read(bs, (int64_t)lba << 2, buf, 4);
1266 break;
1267 case 2352:
1268 ret = bdrv_read(bs, (int64_t)lba << 2, buf + 16, 4);
1269 if (ret < 0)
1270 return ret;
1271 cd_data_to_raw(buf, lba);
1272 break;
1273 default:
1274 ret = -EIO;
1275 break;
1276 }
1277 return ret;
1278 }
1279
1280 static void ide_atapi_io_error(IDEState *s, int ret)
1281 {
1282 /* XXX: handle more errors */
1283 if (ret == -ENOMEDIUM) {
1284 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1285 ASC_MEDIUM_NOT_PRESENT);
1286 } else {
1287 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1288 ASC_LOGICAL_BLOCK_OOR);
1289 }
1290 }
1291
1292 /* The whole ATAPI transfer logic is handled in this function */
1293 static void ide_atapi_cmd_reply_end(IDEState *s)
1294 {
1295 int byte_count_limit, size, ret;
1296 #ifdef DEBUG_IDE_ATAPI
1297 printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
1298 s->packet_transfer_size,
1299 s->elementary_transfer_size,
1300 s->io_buffer_index);
1301 #endif
1302 if (s->packet_transfer_size <= 0) {
1303 /* end of transfer */
1304 ide_transfer_stop(s);
1305 s->status = READY_STAT | SEEK_STAT;
1306 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
1307 ide_set_irq(s);
1308 #ifdef DEBUG_IDE_ATAPI
1309 printf("status=0x%x\n", s->status);
1310 #endif
1311 } else {
1312 /* see if a new sector must be read */
1313 if (s->lba != -1 && s->io_buffer_index >= s->cd_sector_size) {
1314 ret = cd_read_sector(s->bs, s->lba, s->io_buffer, s->cd_sector_size);
1315 if (ret < 0) {
1316 ide_transfer_stop(s);
1317 ide_atapi_io_error(s, ret);
1318 return;
1319 }
1320 s->lba++;
1321 s->io_buffer_index = 0;
1322 }
1323 if (s->elementary_transfer_size > 0) {
1324 /* there are some data left to transmit in this elementary
1325 transfer */
1326 size = s->cd_sector_size - s->io_buffer_index;
1327 if (size > s->elementary_transfer_size)
1328 size = s->elementary_transfer_size;
1329 ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
1330 size, ide_atapi_cmd_reply_end);
1331 s->packet_transfer_size -= size;
1332 s->elementary_transfer_size -= size;
1333 s->io_buffer_index += size;
1334 } else {
1335 /* a new transfer is needed */
1336 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
1337 byte_count_limit = s->lcyl | (s->hcyl << 8);
1338 #ifdef DEBUG_IDE_ATAPI
1339 printf("byte_count_limit=%d\n", byte_count_limit);
1340 #endif
1341 if (byte_count_limit == 0xffff)
1342 byte_count_limit--;
1343 size = s->packet_transfer_size;
1344 if (size > byte_count_limit) {
1345 /* byte count limit must be even if this case */
1346 if (byte_count_limit & 1)
1347 byte_count_limit--;
1348 size = byte_count_limit;
1349 }
1350 s->lcyl = size;
1351 s->hcyl = size >> 8;
1352 s->elementary_transfer_size = size;
1353 /* we cannot transmit more than one sector at a time */
1354 if (s->lba != -1) {
1355 if (size > (s->cd_sector_size - s->io_buffer_index))
1356 size = (s->cd_sector_size - s->io_buffer_index);
1357 }
1358 ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
1359 size, ide_atapi_cmd_reply_end);
1360 s->packet_transfer_size -= size;
1361 s->elementary_transfer_size -= size;
1362 s->io_buffer_index += size;
1363 ide_set_irq(s);
1364 #ifdef DEBUG_IDE_ATAPI
1365 printf("status=0x%x\n", s->status);
1366 #endif
1367 }
1368 }
1369 }
1370
1371 /* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
1372 static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
1373 {
1374 if (size > max_size)
1375 size = max_size;
1376 s->lba = -1; /* no sector read */
1377 s->packet_transfer_size = size;
1378 s->io_buffer_size = size; /* dma: send the reply data as one chunk */
1379 s->elementary_transfer_size = 0;
1380 s->io_buffer_index = 0;
1381
1382 if (s->atapi_dma) {
1383 s->status = READY_STAT | SEEK_STAT | DRQ_STAT;
1384 ide_dma_start(s, ide_atapi_cmd_read_dma_cb);
1385 } else {
1386 s->status = READY_STAT | SEEK_STAT;
1387 ide_atapi_cmd_reply_end(s);
1388 }
1389 }
1390
1391 /* start a CD-CDROM read command */
1392 static void ide_atapi_cmd_read_pio(IDEState *s, int lba, int nb_sectors,
1393 int sector_size)
1394 {
1395 s->lba = lba;
1396 s->packet_transfer_size = nb_sectors * sector_size;
1397 s->elementary_transfer_size = 0;
1398 s->io_buffer_index = sector_size;
1399 s->cd_sector_size = sector_size;
1400
1401 s->status = READY_STAT | SEEK_STAT;
1402 ide_atapi_cmd_reply_end(s);
1403 }
1404
1405 /* ATAPI DMA support */
1406
1407 /* XXX: handle read errors */
1408 static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
1409 {
1410 BMDMAState *bm = opaque;
1411 IDEState *s = bm->ide_if;
1412 int data_offset, n;
1413
1414 if (ret < 0) {
1415 ide_atapi_io_error(s, ret);
1416 goto eot;
1417 }
1418
1419 if (s->io_buffer_size > 0) {
1420 /*
1421 * For a cdrom read sector command (s->lba != -1),
1422 * adjust the lba for the next s->io_buffer_size chunk
1423 * and dma the current chunk.
1424 * For a command != read (s->lba == -1), just transfer
1425 * the reply data.
1426 */
1427 if (s->lba != -1) {
1428 if (s->cd_sector_size == 2352) {
1429 n = 1;
1430 cd_data_to_raw(s->io_buffer, s->lba);
1431 } else {
1432 n = s->io_buffer_size >> 11;
1433 }
1434 s->lba += n;
1435 }
1436 s->packet_transfer_size -= s->io_buffer_size;
1437 if (dma_buf_rw(bm, 1) == 0)
1438 goto eot;
1439 }
1440
1441 if (s->packet_transfer_size <= 0) {
1442 s->status = READY_STAT | SEEK_STAT;
1443 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
1444 ide_set_irq(s);
1445 eot:
1446 bm->status &= ~BM_STATUS_DMAING;
1447 bm->status |= BM_STATUS_INT;
1448 bm->dma_cb = NULL;
1449 bm->ide_if = NULL;
1450 bm->aiocb = NULL;
1451 return;
1452 }
1453
1454 s->io_buffer_index = 0;
1455 if (s->cd_sector_size == 2352) {
1456 n = 1;
1457 s->io_buffer_size = s->cd_sector_size;
1458 data_offset = 16;
1459 } else {
1460 n = s->packet_transfer_size >> 11;
1461 if (n > (IDE_DMA_BUF_SECTORS / 4))
1462 n = (IDE_DMA_BUF_SECTORS / 4);
1463 s->io_buffer_size = n * 2048;
1464 data_offset = 0;
1465 }
1466 #ifdef DEBUG_AIO
1467 printf("aio_read_cd: lba=%u n=%d\n", s->lba, n);
1468 #endif
1469 bm->aiocb = bdrv_aio_read(s->bs, (int64_t)s->lba << 2,
1470 s->io_buffer + data_offset, n * 4,
1471 ide_atapi_cmd_read_dma_cb, bm);
1472 if (!bm->aiocb) {
1473 /* Note: media not present is the most likely case */
1474 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1475 ASC_MEDIUM_NOT_PRESENT);
1476 goto eot;
1477 }
1478 }
1479
1480 /* start a CD-CDROM read command with DMA */
1481 /* XXX: test if DMA is available */
1482 static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors,
1483 int sector_size)
1484 {
1485 s->lba = lba;
1486 s->packet_transfer_size = nb_sectors * sector_size;
1487 s->io_buffer_index = 0;
1488 s->io_buffer_size = 0;
1489 s->cd_sector_size = sector_size;
1490
1491 /* XXX: check if BUSY_STAT should be set */
1492 s->status = READY_STAT | SEEK_STAT | DRQ_STAT | BUSY_STAT;
1493 ide_dma_start(s, ide_atapi_cmd_read_dma_cb);
1494 }
1495
1496 static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors,
1497 int sector_size)
1498 {
1499 #ifdef DEBUG_IDE_ATAPI
1500 printf("read %s: LBA=%d nb_sectors=%d\n", s->atapi_dma ? "dma" : "pio",
1501 lba, nb_sectors);
1502 #endif
1503 if (s->atapi_dma) {
1504 ide_atapi_cmd_read_dma(s, lba, nb_sectors, sector_size);
1505 } else {
1506 ide_atapi_cmd_read_pio(s, lba, nb_sectors, sector_size);
1507 }
1508 }
1509
1510 static inline uint8_t ide_atapi_set_profile(uint8_t *buf, uint8_t *index,
1511 uint16_t profile)
1512 {
1513 uint8_t *buf_profile = buf + 12; /* start of profiles */
1514
1515 buf_profile += ((*index) * 4); /* start of indexed profile */
1516 cpu_to_ube16 (buf_profile, profile);
1517 buf_profile[2] = ((buf_profile[0] == buf[6]) && (buf_profile[1] == buf[7]));
1518
1519 /* each profile adds 4 bytes to the response */
1520 (*index)++;
1521 buf[11] += 4; /* Additional Length */
1522
1523 return 4;
1524 }
1525
1526 static int ide_dvd_read_structure(IDEState *s, int format,
1527 const uint8_t *packet, uint8_t *buf)
1528 {
1529 switch (format) {
1530 case 0x0: /* Physical format information */
1531 {
1532 int layer = packet[6];
1533 uint64_t total_sectors;
1534
1535 if (layer != 0)
1536 return -ASC_INV_FIELD_IN_CMD_PACKET;
1537
1538 bdrv_get_geometry(s->bs, &total_sectors);
1539 total_sectors >>= 2;
1540 if (total_sectors == 0)
1541 return -ASC_MEDIUM_NOT_PRESENT;
1542
1543 buf[4] = 1; /* DVD-ROM, part version 1 */
1544 buf[5] = 0xf; /* 120mm disc, minimum rate unspecified */
1545 buf[6] = 1; /* one layer, read-only (per MMC-2 spec) */
1546 buf[7] = 0; /* default densities */
1547
1548 /* FIXME: 0x30000 per spec? */
1549 cpu_to_ube32(buf + 8, 0); /* start sector */
1550 cpu_to_ube32(buf + 12, total_sectors - 1); /* end sector */
1551 cpu_to_ube32(buf + 16, total_sectors - 1); /* l0 end sector */
1552
1553 /* Size of buffer, not including 2 byte size field */
1554 cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
1555
1556 /* 2k data + 4 byte header */
1557 return (2048 + 4);
1558 }
1559
1560 case 0x01: /* DVD copyright information */
1561 buf[4] = 0; /* no copyright data */
1562 buf[5] = 0; /* no region restrictions */
1563
1564 /* Size of buffer, not including 2 byte size field */
1565 cpu_to_be16wu((uint16_t *)buf, 4 + 2);
1566
1567 /* 4 byte header + 4 byte data */
1568 return (4 + 4);
1569
1570 case 0x03: /* BCA information - invalid field for no BCA info */
1571 return -ASC_INV_FIELD_IN_CMD_PACKET;
1572
1573 case 0x04: /* DVD disc manufacturing information */
1574 /* Size of buffer, not including 2 byte size field */
1575 cpu_to_be16wu((uint16_t *)buf, 2048 + 2);
1576
1577 /* 2k data + 4 byte header */
1578 return (2048 + 4);
1579
1580 case 0xff:
1581 /*
1582 * This lists all the command capabilities above. Add new ones
1583 * in order and update the length and buffer return values.
1584 */
1585
1586 buf[4] = 0x00; /* Physical format */
1587 buf[5] = 0x40; /* Not writable, is readable */
1588 cpu_to_be16wu((uint16_t *)(buf + 6), 2048 + 4);
1589
1590 buf[8] = 0x01; /* Copyright info */
1591 buf[9] = 0x40; /* Not writable, is readable */
1592 cpu_to_be16wu((uint16_t *)(buf + 10), 4 + 4);
1593
1594 buf[12] = 0x03; /* BCA info */
1595 buf[13] = 0x40; /* Not writable, is readable */
1596 cpu_to_be16wu((uint16_t *)(buf + 14), 188 + 4);
1597
1598 buf[16] = 0x04; /* Manufacturing info */
1599 buf[17] = 0x40; /* Not writable, is readable */
1600 cpu_to_be16wu((uint16_t *)(buf + 18), 2048 + 4);
1601
1602 /* Size of buffer, not including 2 byte size field */
1603 cpu_to_be16wu((uint16_t *)buf, 16 + 2);
1604
1605 /* data written + 4 byte header */
1606 return (16 + 4);
1607
1608 default: /* TODO: formats beyond DVD-ROM requires */
1609 return -ASC_INV_FIELD_IN_CMD_PACKET;
1610 }
1611 }
1612
1613 static void ide_atapi_cmd(IDEState *s)
1614 {
1615 const uint8_t *packet;
1616 uint8_t *buf;
1617 int max_len;
1618
1619 packet = s->io_buffer;
1620 buf = s->io_buffer;
1621 #ifdef DEBUG_IDE_ATAPI
1622 {
1623 int i;
1624 printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8));
1625 for(i = 0; i < ATAPI_PACKET_SIZE; i++) {
1626 printf(" %02x", packet[i]);
1627 }
1628 printf("\n");
1629 }
1630 #endif
1631 /* If there's a UNIT_ATTENTION condition pending, only
1632 REQUEST_SENSE and INQUIRY commands are allowed to complete. */
1633 if (s->sense_key == SENSE_UNIT_ATTENTION &&
1634 s->io_buffer[0] != GPCMD_REQUEST_SENSE &&
1635 s->io_buffer[0] != GPCMD_INQUIRY) {
1636 ide_atapi_cmd_check_status(s);
1637 return;
1638 }
1639 switch(s->io_buffer[0]) {
1640 case GPCMD_TEST_UNIT_READY:
1641 if (bdrv_is_inserted(s->bs)) {
1642 ide_atapi_cmd_ok(s);
1643 } else {
1644 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1645 ASC_MEDIUM_NOT_PRESENT);
1646 }
1647 break;
1648 case GPCMD_MODE_SENSE_6:
1649 case GPCMD_MODE_SENSE_10:
1650 {
1651 int action, code;
1652 if (packet[0] == GPCMD_MODE_SENSE_10)
1653 max_len = ube16_to_cpu(packet + 7);
1654 else
1655 max_len = packet[4];
1656 action = packet[2] >> 6;
1657 code = packet[2] & 0x3f;
1658 switch(action) {
1659 case 0: /* current values */
1660 switch(code) {
1661 case 0x01: /* error recovery */
1662 cpu_to_ube16(&buf[0], 16 + 6);
1663 buf[2] = 0x70;
1664 buf[3] = 0;
1665 buf[4] = 0;
1666 buf[5] = 0;
1667 buf[6] = 0;
1668 buf[7] = 0;
1669
1670 buf[8] = 0x01;
1671 buf[9] = 0x06;
1672 buf[10] = 0x00;
1673 buf[11] = 0x05;
1674 buf[12] = 0x00;
1675 buf[13] = 0x00;
1676 buf[14] = 0x00;
1677 buf[15] = 0x00;
1678 ide_atapi_cmd_reply(s, 16, max_len);
1679 break;
1680 case 0x2a:
1681 cpu_to_ube16(&buf[0], 28 + 6);
1682 buf[2] = 0x70;
1683 buf[3] = 0;
1684 buf[4] = 0;
1685 buf[5] = 0;
1686 buf[6] = 0;
1687 buf[7] = 0;
1688
1689 buf[8] = 0x2a;
1690 buf[9] = 0x12;
1691 buf[10] = 0x00;
1692 buf[11] = 0x00;
1693
1694 /* Claim PLAY_AUDIO capability (0x01) since some Linux
1695 code checks for this to automount media. */
1696 buf[12] = 0x71;
1697 buf[13] = 3 << 5;
1698 buf[14] = (1 << 0) | (1 << 3) | (1 << 5);
1699 if (bdrv_is_locked(s->bs))
1700 buf[6] |= 1 << 1;
1701 buf[15] = 0x00;
1702 cpu_to_ube16(&buf[16], 706);
1703 buf[18] = 0;
1704 buf[19] = 2;
1705 cpu_to_ube16(&buf[20], 512);
1706 cpu_to_ube16(&buf[22], 706);
1707 buf[24] = 0;
1708 buf[25] = 0;
1709 buf[26] = 0;
1710 buf[27] = 0;
1711 ide_atapi_cmd_reply(s, 28, max_len);
1712 break;
1713 default:
1714 goto error_cmd;
1715 }
1716 break;
1717 case 1: /* changeable values */
1718 goto error_cmd;
1719 case 2: /* default values */
1720 goto error_cmd;
1721 default:
1722 case 3: /* saved values */
1723 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1724 ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
1725 break;
1726 }
1727 }
1728 break;
1729 case GPCMD_REQUEST_SENSE:
1730 max_len = packet[4];
1731 memset(buf, 0, 18);
1732 buf[0] = 0x70 | (1 << 7);
1733 buf[2] = s->sense_key;
1734 buf[7] = 10;
1735 buf[12] = s->asc;
1736 if (s->sense_key == SENSE_UNIT_ATTENTION)
1737 s->sense_key = SENSE_NONE;
1738 ide_atapi_cmd_reply(s, 18, max_len);
1739 break;
1740 case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
1741 if (bdrv_is_inserted(s->bs)) {
1742 bdrv_set_locked(s->bs, packet[4] & 1);
1743 ide_atapi_cmd_ok(s);
1744 } else {
1745 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1746 ASC_MEDIUM_NOT_PRESENT);
1747 }
1748 break;
1749 case GPCMD_READ_10:
1750 case GPCMD_READ_12:
1751 {
1752 int nb_sectors, lba;
1753
1754 if (packet[0] == GPCMD_READ_10)
1755 nb_sectors = ube16_to_cpu(packet + 7);
1756 else
1757 nb_sectors = ube32_to_cpu(packet + 6);
1758 lba = ube32_to_cpu(packet + 2);
1759 if (nb_sectors == 0) {
1760 ide_atapi_cmd_ok(s);
1761 break;
1762 }
1763 ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
1764 }
1765 break;
1766 case GPCMD_READ_CD:
1767 {
1768 int nb_sectors, lba, transfer_request;
1769
1770 nb_sectors = (packet[6] << 16) | (packet[7] << 8) | packet[8];
1771 lba = ube32_to_cpu(packet + 2);
1772 if (nb_sectors == 0) {
1773 ide_atapi_cmd_ok(s);
1774 break;
1775 }
1776 transfer_request = packet[9];
1777 switch(transfer_request & 0xf8) {
1778 case 0x00:
1779 /* nothing */
1780 ide_atapi_cmd_ok(s);
1781 break;
1782 case 0x10:
1783 /* normal read */
1784 ide_atapi_cmd_read(s, lba, nb_sectors, 2048);
1785 break;
1786 case 0xf8:
1787 /* read all data */
1788 ide_atapi_cmd_read(s, lba, nb_sectors, 2352);
1789 break;
1790 default:
1791 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1792 ASC_INV_FIELD_IN_CMD_PACKET);
1793 break;
1794 }
1795 }
1796 break;
1797 case GPCMD_SEEK:
1798 {
1799 unsigned int lba;
1800 uint64_t total_sectors;
1801
1802 bdrv_get_geometry(s->bs, &total_sectors);
1803 total_sectors >>= 2;
1804 if (total_sectors == 0) {
1805 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1806 ASC_MEDIUM_NOT_PRESENT);
1807 break;
1808 }
1809 lba = ube32_to_cpu(packet + 2);
1810 if (lba >= total_sectors) {
1811 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1812 ASC_LOGICAL_BLOCK_OOR);
1813 break;
1814 }
1815 ide_atapi_cmd_ok(s);
1816 }
1817 break;
1818 case GPCMD_START_STOP_UNIT:
1819 {
1820 int start, eject;
1821 start = packet[4] & 1;
1822 eject = (packet[4] >> 1) & 1;
1823
1824 if (eject && !start) {
1825 /* eject the disk */
1826 bdrv_eject(s->bs, 1);
1827 } else if (eject && start) {
1828 /* close the tray */
1829 bdrv_eject(s->bs, 0);
1830 }
1831 ide_atapi_cmd_ok(s);
1832 }
1833 break;
1834 case GPCMD_MECHANISM_STATUS:
1835 {
1836 max_len = ube16_to_cpu(packet + 8);
1837 cpu_to_ube16(buf, 0);
1838 /* no current LBA */
1839 buf[2] = 0;
1840 buf[3] = 0;
1841 buf[4] = 0;
1842 buf[5] = 1;
1843 cpu_to_ube16(buf + 6, 0);
1844 ide_atapi_cmd_reply(s, 8, max_len);
1845 }
1846 break;
1847 case GPCMD_READ_TOC_PMA_ATIP:
1848 {
1849 int format, msf, start_track, len;
1850 uint64_t total_sectors;
1851
1852 bdrv_get_geometry(s->bs, &total_sectors);
1853 total_sectors >>= 2;
1854 if (total_sectors == 0) {
1855 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1856 ASC_MEDIUM_NOT_PRESENT);
1857 break;
1858 }
1859 max_len = ube16_to_cpu(packet + 7);
1860 format = packet[9] >> 6;
1861 msf = (packet[1] >> 1) & 1;
1862 start_track = packet[6];
1863 switch(format) {
1864 case 0:
1865 len = cdrom_read_toc(total_sectors, buf, msf, start_track);
1866 if (len < 0)
1867 goto error_cmd;
1868 ide_atapi_cmd_reply(s, len, max_len);
1869 break;
1870 case 1:
1871 /* multi session : only a single session defined */
1872 memset(buf, 0, 12);
1873 buf[1] = 0x0a;
1874 buf[2] = 0x01;
1875 buf[3] = 0x01;
1876 ide_atapi_cmd_reply(s, 12, max_len);
1877 break;
1878 case 2:
1879 len = cdrom_read_toc_raw(total_sectors, buf, msf, start_track);
1880 if (len < 0)
1881 goto error_cmd;
1882 ide_atapi_cmd_reply(s, len, max_len);
1883 break;
1884 default:
1885 error_cmd:
1886 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1887 ASC_INV_FIELD_IN_CMD_PACKET);
1888 break;
1889 }
1890 }
1891 break;
1892 case GPCMD_READ_CDVD_CAPACITY:
1893 {
1894 uint64_t total_sectors;
1895
1896 bdrv_get_geometry(s->bs, &total_sectors);
1897 total_sectors >>= 2;
1898 if (total_sectors == 0) {
1899 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1900 ASC_MEDIUM_NOT_PRESENT);
1901 break;
1902 }
1903 /* NOTE: it is really the number of sectors minus 1 */
1904 cpu_to_ube32(buf, total_sectors - 1);
1905 cpu_to_ube32(buf + 4, 2048);
1906 ide_atapi_cmd_reply(s, 8, 8);
1907 }
1908 break;
1909 case GPCMD_READ_DVD_STRUCTURE:
1910 {
1911 int media = packet[1];
1912 int format = packet[7];
1913 int ret;
1914
1915 max_len = ube16_to_cpu(packet + 8);
1916
1917 if (format < 0xff) {
1918 if (media_is_cd(s)) {
1919 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1920 ASC_INCOMPATIBLE_FORMAT);
1921 break;
1922 } else if (!media_present(s)) {
1923 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1924 ASC_INV_FIELD_IN_CMD_PACKET);
1925 break;
1926 }
1927 }
1928
1929 memset(buf, 0, max_len > IDE_DMA_BUF_SECTORS * 512 + 4 ?
1930 IDE_DMA_BUF_SECTORS * 512 + 4 : max_len);
1931
1932 switch (format) {
1933 case 0x00 ... 0x7f:
1934 case 0xff:
1935 if (media == 0) {
1936 ret = ide_dvd_read_structure(s, format, packet, buf);
1937
1938 if (ret < 0)
1939 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST, -ret);
1940 else
1941 ide_atapi_cmd_reply(s, ret, max_len);
1942
1943 break;
1944 }
1945 /* TODO: BD support, fall through for now */
1946
1947 /* Generic disk structures */
1948 case 0x80: /* TODO: AACS volume identifier */
1949 case 0x81: /* TODO: AACS media serial number */
1950 case 0x82: /* TODO: AACS media identifier */
1951 case 0x83: /* TODO: AACS media key block */
1952 case 0x90: /* TODO: List of recognized format layers */
1953 case 0xc0: /* TODO: Write protection status */
1954 default:
1955 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1956 ASC_INV_FIELD_IN_CMD_PACKET);
1957 break;
1958 }
1959 }
1960 break;
1961 case GPCMD_SET_SPEED:
1962 ide_atapi_cmd_ok(s);
1963 break;
1964 case GPCMD_INQUIRY:
1965 max_len = packet[4];
1966 buf[0] = 0x05; /* CD-ROM */
1967 buf[1] = 0x80; /* removable */
1968 buf[2] = 0x00; /* ISO */
1969 buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1970 buf[4] = 31; /* additional length */
1971 buf[5] = 0; /* reserved */
1972 buf[6] = 0; /* reserved */
1973 buf[7] = 0; /* reserved */
1974 padstr8(buf + 8, 8, "QEMU");
1975 padstr8(buf + 16, 16, "QEMU DVD-ROM");
1976 padstr8(buf + 32, 4, QEMU_VERSION);
1977 ide_atapi_cmd_reply(s, 36, max_len);
1978 break;
1979 case GPCMD_GET_CONFIGURATION:
1980 {
1981 uint32_t len;
1982 uint8_t index = 0;
1983
1984 /* only feature 0 is supported */
1985 if (packet[2] != 0 || packet[3] != 0) {
1986 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
1987 ASC_INV_FIELD_IN_CMD_PACKET);
1988 break;
1989 }
1990
1991 /* XXX: could result in alignment problems in some architectures */
1992 max_len = ube16_to_cpu(packet + 7);
1993
1994 /*
1995 * XXX: avoid overflow for io_buffer if max_len is bigger than
1996 * the size of that buffer (dimensioned to max number of
1997 * sectors to transfer at once)
1998 *
1999 * Only a problem if the feature/profiles grow.
2000 */
2001 if (max_len > 512) /* XXX: assume 1 sector */
2002 max_len = 512;
2003
2004 memset(buf, 0, max_len);
2005 /*
2006 * the number of sectors from the media tells us which profile
2007 * to use as current. 0 means there is no media
2008 */
2009 if (media_is_dvd(s))
2010 cpu_to_ube16(buf + 6, MMC_PROFILE_DVD_ROM);
2011 else if (media_is_cd(s))
2012 cpu_to_ube16(buf + 6, MMC_PROFILE_CD_ROM);
2013
2014 buf[10] = 0x02 | 0x01; /* persistent and current */
2015 len = 12; /* headers: 8 + 4 */
2016 len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_DVD_ROM);
2017 len += ide_atapi_set_profile(buf, &index, MMC_PROFILE_CD_ROM);
2018 cpu_to_ube32(buf, len - 4); /* data length */
2019
2020 ide_atapi_cmd_reply(s, len, max_len);
2021 break;
2022 }
2023 default:
2024 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
2025 ASC_ILLEGAL_OPCODE);
2026 break;
2027 }
2028 }
2029
2030 static void ide_cfata_metadata_inquiry(IDEState *s)
2031 {
2032 uint16_t *p;
2033 uint32_t spd;
2034
2035 p = (uint16_t *) s->io_buffer;
2036 memset(p, 0, 0x200);
2037 spd = ((s->mdata_size - 1) >> 9) + 1;
2038
2039 put_le16(p + 0, 0x0001); /* Data format revision */
2040 put_le16(p + 1, 0x0000); /* Media property: silicon */
2041 put_le16(p + 2, s->media_changed); /* Media status */
2042 put_le16(p + 3, s->mdata_size & 0xffff); /* Capacity in bytes (low) */
2043 put_le16(p + 4, s->mdata_size >> 16); /* Capacity in bytes (high) */
2044 put_le16(p + 5, spd & 0xffff); /* Sectors per device (low) */
2045 put_le16(p + 6, spd >> 16); /* Sectors per device (high) */
2046 }
2047
2048 static void ide_cfata_metadata_read(IDEState *s)
2049 {
2050 uint16_t *p;
2051
2052 if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
2053 s->status = ERR_STAT;
2054 s->error = ABRT_ERR;
2055 return;
2056 }
2057
2058 p = (uint16_t *) s->io_buffer;
2059 memset(p, 0, 0x200);
2060
2061 put_le16(p + 0, s->media_changed); /* Media status */
2062 memcpy(p + 1, s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
2063 MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
2064 s->nsector << 9), 0x200 - 2));
2065 }
2066
2067 static void ide_cfata_metadata_write(IDEState *s)
2068 {
2069 if (((s->hcyl << 16) | s->lcyl) << 9 > s->mdata_size + 2) {
2070 s->status = ERR_STAT;
2071 s->error = ABRT_ERR;
2072 return;
2073 }
2074
2075 s->media_changed = 0;
2076
2077 memcpy(s->mdata_storage + (((s->hcyl << 16) | s->lcyl) << 9),
2078 s->io_buffer + 2,
2079 MIN(MIN(s->mdata_size - (((s->hcyl << 16) | s->lcyl) << 9),
2080 s->nsector << 9), 0x200 - 2));
2081 }
2082
2083 /* called when the inserted state of the media has changed */
2084 static void cdrom_change_cb(void *opaque)
2085 {
2086 IDEState *s = opaque;
2087 uint64_t nb_sectors;
2088
2089 bdrv_get_geometry(s->bs, &nb_sectors);
2090 s->nb_sectors = nb_sectors;
2091
2092 s->sense_key = SENSE_UNIT_ATTENTION;
2093 s->asc = ASC_MEDIUM_MAY_HAVE_CHANGED;
2094
2095 ide_set_irq(s);
2096 }
2097
2098 static void ide_cmd_lba48_transform(IDEState *s, int lba48)
2099 {
2100 s->lba48 = lba48;
2101
2102 /* handle the 'magic' 0 nsector count conversion here. to avoid
2103 * fiddling with the rest of the read logic, we just store the
2104 * full sector count in ->nsector and ignore ->hob_nsector from now
2105 */
2106 if (!s->lba48) {
2107 if (!s->nsector)
2108 s->nsector = 256;
2109 } else {
2110 if (!s->nsector && !s->hob_nsector)
2111 s->nsector = 65536;
2112 else {
2113 int lo = s->nsector;
2114 int hi = s->hob_nsector;
2115
2116 s->nsector = (hi << 8) | lo;
2117 }
2118 }
2119 }
2120
2121 static void ide_clear_hob(IDEState *ide_if)
2122 {
2123 /* any write clears HOB high bit of device control register */
2124 ide_if[0].select &= ~(1 << 7);
2125 ide_if[1].select &= ~(1 << 7);
2126 }
2127
2128 static void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
2129 {
2130 IDEState *ide_if = opaque;
2131 IDEState *s;
2132 int unit, n;
2133 int lba48 = 0;
2134
2135 #ifdef DEBUG_IDE
2136 printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
2137 #endif
2138
2139 addr &= 7;
2140
2141 /* ignore writes to command block while busy with previous command */
2142 if (addr != 7 && (ide_if->cur_drive->status & (BUSY_STAT|DRQ_STAT)))
2143 return;
2144
2145 switch(addr) {
2146 case 0:
2147 break;
2148 case 1:
2149 ide_clear_hob(ide_if);
2150 /* NOTE: data is written to the two drives */
2151 ide_if[0].hob_feature = ide_if[0].feature;
2152 ide_if[1].hob_feature = ide_if[1].feature;
2153 ide_if[0].feature = val;
2154 ide_if[1].feature = val;
2155 break;
2156 case 2:
2157 ide_clear_hob(ide_if);
2158 ide_if[0].hob_nsector = ide_if[0].nsector;
2159 ide_if[1].hob_nsector = ide_if[1].nsector;
2160 ide_if[0].nsector = val;
2161 ide_if[1].nsector = val;
2162 break;
2163 case 3:
2164 ide_clear_hob(ide_if);
2165 ide_if[0].hob_sector = ide_if[0].sector;
2166 ide_if[1].hob_sector = ide_if[1].sector;
2167 ide_if[0].sector = val;
2168 ide_if[1].sector = val;
2169 break;
2170 case 4:
2171 ide_clear_hob(ide_if);
2172 ide_if[0].hob_lcyl = ide_if[0].lcyl;
2173 ide_if[1].hob_lcyl = ide_if[1].lcyl;
2174 ide_if[0].lcyl = val;
2175 ide_if[1].lcyl = val;
2176 break;
2177 case 5:
2178 ide_clear_hob(ide_if);
2179 ide_if[0].hob_hcyl = ide_if[0].hcyl;
2180 ide_if[1].hob_hcyl = ide_if[1].hcyl;
2181 ide_if[0].hcyl = val;
2182 ide_if[1].hcyl = val;
2183 break;
2184 case 6:
2185 /* FIXME: HOB readback uses bit 7 */
2186 ide_if[0].select = (val & ~0x10) | 0xa0;
2187 ide_if[1].select = (val | 0x10) | 0xa0;
2188 /* select drive */
2189 unit = (val >> 4) & 1;
2190 s = ide_if + unit;
2191 ide_if->cur_drive = s;
2192 break;
2193 default:
2194 case 7:
2195 /* command */
2196 #if defined(DEBUG_IDE)
2197 printf("ide: CMD=%02x\n", val);
2198 #endif
2199 s = ide_if->cur_drive;
2200 /* ignore commands to non existant slave */
2201 if (s != ide_if && !s->bs)
2202 break;
2203
2204 /* Only DEVICE RESET is allowed while BSY or/and DRQ are set */
2205 if ((s->status & (BUSY_STAT|DRQ_STAT)) && val != WIN_DEVICE_RESET)
2206 break;
2207
2208 switch(val) {
2209 case WIN_IDENTIFY:
2210 if (s->bs && !s->is_cdrom) {
2211 if (!s->is_cf)
2212 ide_identify(s);
2213 else
2214 ide_cfata_identify(s);
2215 s->status = READY_STAT | SEEK_STAT;
2216 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
2217 } else {
2218 if (s->is_cdrom) {
2219 ide_set_signature(s);
2220 }
2221 ide_abort_command(s);
2222 }
2223 ide_set_irq(s);
2224 break;
2225 case WIN_SPECIFY:
2226 case WIN_RECAL:
2227 s->error = 0;
2228 s->status = READY_STAT | SEEK_STAT;
2229 ide_set_irq(s);
2230 break;
2231 case WIN_SETMULT:
2232 if (s->is_cf && s->nsector == 0) {
2233 /* Disable Read and Write Multiple */
2234 s->mult_sectors = 0;
2235 s->status = READY_STAT | SEEK_STAT;
2236 } else if ((s->nsector & 0xff) != 0 &&
2237 ((s->nsector & 0xff) > MAX_MULT_SECTORS ||
2238 (s->nsector & (s->nsector - 1)) != 0)) {
2239 ide_abort_command(s);
2240 } else {
2241 s->mult_sectors = s->nsector & 0xff;
2242 s->status = READY_STAT | SEEK_STAT;
2243 }
2244 ide_set_irq(s);
2245 break;
2246 case WIN_VERIFY_EXT:
2247 lba48 = 1;
2248 case WIN_VERIFY:
2249 case WIN_VERIFY_ONCE:
2250 /* do sector number check ? */
2251 ide_cmd_lba48_transform(s, lba48);
2252 s->status = READY_STAT | SEEK_STAT;
2253 ide_set_irq(s);
2254 break;
2255 case WIN_READ_EXT:
2256 lba48 = 1;
2257 case WIN_READ:
2258 case WIN_READ_ONCE:
2259 if (!s->bs)
2260 goto abort_cmd;
2261 ide_cmd_lba48_transform(s, lba48);
2262 s->req_nb_sectors = 1;
2263 ide_sector_read(s);
2264 break;
2265 case WIN_WRITE_EXT:
2266 lba48 = 1;
2267 case WIN_WRITE:
2268 case WIN_WRITE_ONCE:
2269 case CFA_WRITE_SECT_WO_ERASE:
2270 case WIN_WRITE_VERIFY:
2271 ide_cmd_lba48_transform(s, lba48);
2272 s->error = 0;
2273 s->status = SEEK_STAT | READY_STAT;
2274 s->req_nb_sectors = 1;
2275 ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
2276 s->media_changed = 1;
2277 break;
2278 case WIN_MULTREAD_EXT:
2279 lba48 = 1;
2280 case WIN_MULTREAD:
2281 if (!s->mult_sectors)
2282 goto abort_cmd;
2283 ide_cmd_lba48_transform(s, lba48);
2284 s->req_nb_sectors = s->mult_sectors;
2285 ide_sector_read(s);
2286 break;
2287 case WIN_MULTWRITE_EXT:
2288 lba48 = 1;
2289 case WIN_MULTWRITE:
2290 case CFA_WRITE_MULTI_WO_ERASE:
2291 if (!s->mult_sectors)
2292 goto abort_cmd;
2293 ide_cmd_lba48_transform(s, lba48);
2294 s->error = 0;
2295 s->status = SEEK_STAT | READY_STAT;
2296 s->req_nb_sectors = s->mult_sectors;
2297 n = s->nsector;
2298 if (n > s->req_nb_sectors)
2299 n = s->req_nb_sectors;
2300 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
2301 s->media_changed = 1;
2302 break;
2303 case WIN_READDMA_EXT:
2304 lba48 = 1;
2305 case WIN_READDMA:
2306 case WIN_READDMA_ONCE:
2307 if (!s->bs)
2308 goto abort_cmd;
2309 ide_cmd_lba48_transform(s, lba48);
2310 ide_sector_read_dma(s);
2311 break;
2312 case WIN_WRITEDMA_EXT:
2313 lba48 = 1;
2314 case WIN_WRITEDMA:
2315 case WIN_WRITEDMA_ONCE:
2316 if (!s->bs)
2317 goto abort_cmd;
2318 ide_cmd_lba48_transform(s, lba48);
2319 ide_sector_write_dma(s);
2320 s->media_changed = 1;
2321 break;
2322 case WIN_READ_NATIVE_MAX_EXT:
2323 lba48 = 1;
2324 case WIN_READ_NATIVE_MAX:
2325 ide_cmd_lba48_transform(s, lba48);
2326 ide_set_sector(s, s->nb_sectors - 1);
2327 s->status = READY_STAT | SEEK_STAT;
2328 ide_set_irq(s);
2329 break;
2330 case WIN_CHECKPOWERMODE1:
2331 case WIN_CHECKPOWERMODE2:
2332 s->nsector = 0xff; /* device active or idle */
2333 s->status = READY_STAT | SEEK_STAT;
2334 ide_set_irq(s);
2335 break;
2336 case WIN_SETFEATURES:
2337 if (!s->bs)
2338 goto abort_cmd;
2339 /* XXX: valid for CDROM ? */
2340 switch(s->feature) {
2341 case 0xcc: /* reverting to power-on defaults enable */
2342 case 0x66: /* reverting to power-on defaults disable */
2343 case 0x02: /* write cache enable */
2344 case 0x82: /* write cache disable */
2345 case 0xaa: /* read look-ahead enable */
2346 case 0x55: /* read look-ahead disable */
2347 case 0x05: /* set advanced power management mode */
2348 case 0x85: /* disable advanced power management mode */
2349 case 0x69: /* NOP */
2350 case 0x67: /* NOP */
2351 case 0x96: /* NOP */
2352 case 0x9a: /* NOP */
2353 case 0x42: /* enable Automatic Acoustic Mode */
2354 case 0xc2: /* disable Automatic Acoustic Mode */
2355 s->status = READY_STAT | SEEK_STAT;
2356 ide_set_irq(s);
2357 break;
2358 case 0x03: { /* set transfer mode */
2359 uint8_t val = s->nsector & 0x07;
2360
2361 switch (s->nsector >> 3) {
2362 case 0x00: /* pio default */
2363 case 0x01: /* pio mode */
2364 put_le16(s->identify_data + 62,0x07);
2365 put_le16(s->identify_data + 63,0x07);
2366 put_le16(s->identify_data + 88,0x3f);
2367 break;
2368 case 0x02: /* sigle word dma mode*/
2369 put_le16(s->identify_data + 62,0x07 | (1 << (val + 8)));
2370 put_le16(s->identify_data + 63,0x07);
2371 put_le16(s->identify_data + 88,0x3f);
2372 break;
2373 case 0x04: /* mdma mode */
2374 put_le16(s->identify_data + 62,0x07);
2375 put_le16(s->identify_data + 63,0x07 | (1 << (val + 8)));
2376 put_le16(s->identify_data + 88,0x3f);
2377 break;
2378 case 0x08: /* udma mode */
2379 put_le16(s->identify_data + 62,0x07);
2380 put_le16(s->identify_data + 63,0x07);
2381 put_le16(s->identify_data + 88,0x3f | (1 << (val + 8)));
2382 break;
2383 default:
2384 goto abort_cmd;
2385 }
2386 s->status = READY_STAT | SEEK_STAT;
2387 ide_set_irq(s);
2388 break;
2389 }
2390 default:
2391 goto abort_cmd;
2392 }
2393 break;
2394 case WIN_FLUSH_CACHE:
2395 case WIN_FLUSH_CACHE_EXT:
2396 if (s->bs)
2397 bdrv_flush(s->bs);
2398 s->status = READY_STAT | SEEK_STAT;
2399 ide_set_irq(s);
2400 break;
2401 case WIN_STANDBY:
2402 case WIN_STANDBY2:
2403 case WIN_STANDBYNOW1:
2404 case WIN_STANDBYNOW2:
2405 case WIN_IDLEIMMEDIATE:
2406 case CFA_IDLEIMMEDIATE:
2407 case WIN_SETIDLE1:
2408 case WIN_SETIDLE2:
2409 case WIN_SLEEPNOW1:
2410 case WIN_SLEEPNOW2:
2411 s->status = READY_STAT;
2412 ide_set_irq(s);
2413 break;
2414 case WIN_SEEK:
2415 if(s->is_cdrom)
2416 goto abort_cmd;
2417 /* XXX: Check that seek is within bounds */
2418 s->status = READY_STAT | SEEK_STAT;
2419 ide_set_irq(s);
2420 break;
2421 /* ATAPI commands */
2422 case WIN_PIDENTIFY:
2423 if (s->is_cdrom) {
2424 ide_atapi_identify(s);
2425 s->status = READY_STAT | SEEK_STAT;
2426 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
2427 } else {
2428 ide_abort_command(s);
2429 }
2430 ide_set_irq(s);
2431 break;
2432 case WIN_DIAGNOSE:
2433 ide_set_signature(s);
2434 if (s->is_cdrom)
2435 s->status = 0; /* ATAPI spec (v6) section 9.10 defines packet
2436 * devices to return a clear status register
2437 * with READY_STAT *not* set. */
2438 else
2439 s->status = READY_STAT | SEEK_STAT;
2440 s->error = 0x01; /* Device 0 passed, Device 1 passed or not
2441 * present.
2442 */
2443 ide_set_irq(s);
2444 break;
2445 case WIN_SRST:
2446 if (!s->is_cdrom)
2447 goto abort_cmd;
2448 ide_set_signature(s);
2449 s->status = 0x00; /* NOTE: READY is _not_ set */
2450 s->error = 0x01;
2451 break;
2452 case WIN_PACKETCMD:
2453 if (!s->is_cdrom)
2454 goto abort_cmd;
2455 /* overlapping commands not supported */
2456 if (s->feature & 0x02)
2457 goto abort_cmd;
2458 s->status = READY_STAT | SEEK_STAT;
2459 s->atapi_dma = s->feature & 1;
2460 s->nsector = 1;
2461 ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
2462 ide_atapi_cmd);
2463 break;
2464 /* CF-ATA commands */
2465 case CFA_REQ_EXT_ERROR_CODE:
2466 if (!s->is_cf)
2467 goto abort_cmd;
2468 s->error = 0x09; /* miscellaneous error */
2469 s->status = READY_STAT | SEEK_STAT;
2470 ide_set_irq(s);
2471 break;
2472 case CFA_ERASE_SECTORS:
2473 case CFA_WEAR_LEVEL:
2474 if (!s->is_cf)
2475 goto abort_cmd;
2476 if (val == CFA_WEAR_LEVEL)
2477 s->nsector = 0;
2478 if (val == CFA_ERASE_SECTORS)
2479 s->media_changed = 1;
2480 s->error = 0x00;
2481 s->status = READY_STAT | SEEK_STAT;
2482 ide_set_irq(s);
2483 break;
2484 case CFA_TRANSLATE_SECTOR:
2485 if (!s->is_cf)
2486 goto abort_cmd;
2487 s->error = 0x00;
2488 s->status = READY_STAT | SEEK_STAT;
2489 memset(s->io_buffer, 0, 0x200);
2490 s->io_buffer[0x00] = s->hcyl; /* Cyl MSB */
2491 s->io_buffer[0x01] = s->lcyl; /* Cyl LSB */
2492 s->io_buffer[0x02] = s->select; /* Head */
2493 s->io_buffer[0x03] = s->sector; /* Sector */
2494 s->io_buffer[0x04] = ide_get_sector(s) >> 16; /* LBA MSB */
2495 s->io_buffer[0x05] = ide_get_sector(s) >> 8; /* LBA */
2496 s->io_buffer[0x06] = ide_get_sector(s) >> 0; /* LBA LSB */
2497 s->io_buffer[0x13] = 0x00; /* Erase flag */
2498 s->io_buffer[0x18] = 0x00; /* Hot count */
2499 s->io_buffer[0x19] = 0x00; /* Hot count */
2500 s->io_buffer[0x1a] = 0x01; /* Hot count */
2501 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2502 ide_set_irq(s);
2503 break;
2504 case CFA_ACCESS_METADATA_STORAGE:
2505 if (!s->is_cf)
2506 goto abort_cmd;
2507 switch (s->feature) {
2508 case 0x02: /* Inquiry Metadata Storage */
2509 ide_cfata_metadata_inquiry(s);
2510 break;
2511 case 0x03: /* Read Metadata Storage */
2512 ide_cfata_metadata_read(s);
2513 break;
2514 case 0x04: /* Write Metadata Storage */
2515 ide_cfata_metadata_write(s);
2516 break;
2517 default:
2518 goto abort_cmd;
2519 }
2520 ide_transfer_start(s, s->io_buffer, 0x200, ide_transfer_stop);
2521 s->status = 0x00; /* NOTE: READY is _not_ set */
2522 ide_set_irq(s);
2523 break;
2524 case IBM_SENSE_CONDITION:
2525 if (!s->is_cf)
2526 goto abort_cmd;
2527 switch (s->feature) {
2528 case 0x01: /* sense temperature in device */
2529 s->nsector = 0x50; /* +20 C */
2530 break;
2531 default:
2532 goto abort_cmd;
2533 }
2534 s->status = READY_STAT | SEEK_STAT;
2535 ide_set_irq(s);
2536 break;
2537 default:
2538 abort_cmd:
2539 ide_abort_command(s);
2540 ide_set_irq(s);
2541 break;
2542 }
2543 }
2544 }
2545
2546 static uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
2547 {
2548 IDEState *ide_if = opaque;
2549 IDEState *s = ide_if->cur_drive;
2550 uint32_t addr;
2551 int ret, hob;
2552
2553 addr = addr1 & 7;
2554 /* FIXME: HOB readback uses bit 7, but it's always set right now */
2555 //hob = s->select & (1 << 7);
2556 hob = 0;
2557 switch(addr) {
2558 case 0:
2559 ret = 0xff;
2560 break;
2561 case 1:
2562 if ((!ide_if[0].bs && !ide_if[1].bs) ||
2563 (s != ide_if && !s->bs))
2564 ret = 0;
2565 else if (!hob)
2566 ret = s->error;
2567 else
2568 ret = s->hob_feature;
2569 break;
2570 case 2:
2571 if (!ide_if[0].bs && !ide_if[1].bs)
2572 ret = 0;
2573 else if (!hob)
2574 ret = s->nsector & 0xff;
2575 else
2576 ret = s->hob_nsector;
2577 break;
2578 case 3:
2579 if (!ide_if[0].bs && !ide_if[1].bs)
2580 ret = 0;
2581 else if (!hob)
2582 ret = s->sector;
2583 else
2584 ret = s->hob_sector;
2585 break;
2586 case 4:
2587 if (!ide_if[0].bs && !ide_if[1].bs)
2588 ret = 0;
2589 else if (!hob)
2590 ret = s->lcyl;
2591 else
2592 ret = s->hob_lcyl;
2593 break;
2594 case 5:
2595 if (!ide_if[0].bs && !ide_if[1].bs)
2596 ret = 0;
2597 else if (!hob)
2598 ret = s->hcyl;
2599 else
2600 ret = s->hob_hcyl;
2601 break;
2602 case 6:
2603 if (!ide_if[0].bs && !ide_if[1].bs)
2604 ret = 0;
2605 else
2606 ret = s->select;
2607 break;
2608 default:
2609 case 7:
2610 if ((!ide_if[0].bs && !ide_if[1].bs) ||
2611 (s != ide_if && !s->bs))
2612 ret = 0;
2613 else
2614 ret = s->status;
2615 qemu_irq_lower(s->irq);
2616 break;
2617 }
2618 #ifdef DEBUG_IDE
2619 printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
2620 #endif
2621 return ret;
2622 }
2623
2624 static uint32_t ide_status_read(void *opaque, uint32_t addr)
2625 {
2626 IDEState *ide_if = opaque;
2627 IDEState *s = ide_if->cur_drive;
2628 int ret;
2629
2630 if ((!ide_if[0].bs && !ide_if[1].bs) ||
2631 (s != ide_if && !s->bs))
2632 ret = 0;
2633 else
2634 ret = s->status;
2635 #ifdef DEBUG_IDE
2636 printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
2637 #endif
2638 return ret;
2639 }
2640
2641 static void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
2642 {
2643 IDEState *ide_if = opaque;
2644 IDEState *s;
2645 int i;
2646
2647 #ifdef DEBUG_IDE
2648 printf("ide: write control addr=0x%x val=%02x\n", addr, val);
2649 #endif
2650 /* common for both drives */
2651 if (!(ide_if[0].cmd & IDE_CMD_RESET) &&
2652 (val & IDE_CMD_RESET)) {
2653 /* reset low to high */
2654 for(i = 0;i < 2; i++) {
2655 s = &ide_if[i];
2656 s->status = BUSY_STAT | SEEK_STAT;
2657 s->error = 0x01;
2658 }
2659 } else if ((ide_if[0].cmd & IDE_CMD_RESET) &&
2660 !(val & IDE_CMD_RESET)) {
2661 /* high to low */
2662 for(i = 0;i < 2; i++) {
2663 s = &ide_if[i];
2664 if (s->is_cdrom)
2665 s->status = 0x00; /* NOTE: READY is _not_ set */
2666 else
2667 s->status = READY_STAT | SEEK_STAT;
2668 ide_set_signature(s);
2669 }
2670 }
2671
2672 ide_if[0].cmd = val;
2673 ide_if[1].cmd = val;
2674 }
2675
2676 static void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
2677 {
2678 IDEState *s = ((IDEState *)opaque)->cur_drive;
2679 uint8_t *p;
2680
2681 /* PIO data access allowed only when DRQ bit is set */
2682 if (!(s->status & DRQ_STAT))
2683 return;
2684
2685 p = s->data_ptr;
2686 *(uint16_t *)p = le16_to_cpu(val);
2687 p += 2;
2688 s->data_ptr = p;
2689 if (p >= s->data_end)
2690 s->end_transfer_func(s);
2691 }
2692
2693 static uint32_t ide_data_readw(void *opaque, uint32_t addr)
2694 {
2695 IDEState *s = ((IDEState *)opaque)->cur_drive;
2696 uint8_t *p;
2697 int ret;
2698
2699 /* PIO data access allowed only when DRQ bit is set */
2700 if (!(s->status & DRQ_STAT))
2701 return 0;
2702
2703 p = s->data_ptr;
2704 ret = cpu_to_le16(*(uint16_t *)p);
2705 p += 2;
2706 s->data_ptr = p;
2707 if (p >= s->data_end)
2708 s->end_transfer_func(s);
2709 return ret;
2710 }
2711
2712 static void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
2713 {
2714 IDEState *s = ((IDEState *)opaque)->cur_drive;
2715 uint8_t *p;
2716
2717 /* PIO data access allowed only when DRQ bit is set */
2718 if (!(s->status & DRQ_STAT))
2719 return;
2720
2721 p = s->data_ptr;
2722 *(uint32_t *)p = le32_to_cpu(val);
2723 p += 4;
2724 s->data_ptr = p;
2725 if (p >= s->data_end)
2726 s->end_transfer_func(s);
2727 }
2728
2729 static uint32_t ide_data_readl(void *opaque, uint32_t addr)
2730 {
2731 IDEState *s = ((IDEState *)opaque)->cur_drive;
2732 uint8_t *p;
2733 int ret;
2734
2735 /* PIO data access allowed only when DRQ bit is set */
2736 if (!(s->status & DRQ_STAT))
2737 return 0;
2738
2739 p = s->data_ptr;
2740 ret = cpu_to_le32(*(uint32_t *)p);
2741 p += 4;
2742 s->data_ptr = p;
2743 if (p >= s->data_end)
2744 s->end_transfer_func(s);
2745 return ret;
2746 }
2747
2748 static void ide_dummy_transfer_stop(IDEState *s)
2749 {
2750 s->data_ptr = s->io_buffer;
2751 s->data_end = s->io_buffer;
2752 s->io_buffer[0] = 0xff;
2753 s->io_buffer[1] = 0xff;
2754 s->io_buffer[2] = 0xff;
2755 s->io_buffer[3] = 0xff;
2756 }
2757
2758 static void ide_reset(IDEState *s)
2759 {
2760 if (s->is_cf)
2761 s->mult_sectors = 0;
2762 else
2763 s->mult_sectors = MAX_MULT_SECTORS;
2764 s->cur_drive = s;
2765 s->select = 0xa0;
2766 s->status = READY_STAT | SEEK_STAT;
2767 ide_set_signature(s);
2768 /* init the transfer handler so that 0xffff is returned on data
2769 accesses */
2770 s->end_transfer_func = ide_dummy_transfer_stop;
2771 ide_dummy_transfer_stop(s);
2772 s->media_changed = 0;
2773 }
2774
2775 static void ide_init2(IDEState *ide_state,
2776 BlockDriverState *hd0, BlockDriverState *hd1,
2777 qemu_irq irq)
2778 {
2779 IDEState *s;
2780 static int drive_serial = 1;
2781 int i, cylinders, heads, secs;
2782 uint64_t nb_sectors;
2783
2784 for(i = 0; i < 2; i++) {
2785 s = ide_state + i;
2786 s->io_buffer = qemu_memalign(512, IDE_DMA_BUF_SECTORS*512 + 4);
2787 if (i == 0)
2788 s->bs = hd0;
2789 else
2790 s->bs = hd1;
2791 if (s->bs) {
2792 bdrv_get_geometry(s->bs, &nb_sectors);
2793 bdrv_guess_geometry(s->bs, &cylinders, &heads, &secs);
2794 s->cylinders = cylinders;
2795 s->heads = heads;
2796 s->sectors = secs;
2797 s->nb_sectors = nb_sectors;
2798
2799 if (bdrv_get_type_hint(s->bs) == BDRV_TYPE_CDROM) {
2800 s->is_cdrom = 1;
2801 bdrv_set_change_cb(s->bs, cdrom_change_cb, s);
2802 }
2803 }
2804 s->drive_serial = drive_serial++;
2805 strncpy(s->drive_serial_str, drive_get_serial(s->bs),
2806 sizeof(s->drive_serial_str));
2807 if (strlen(s->drive_serial_str) == 0)
2808 snprintf(s->drive_serial_str, sizeof(s->drive_serial_str),
2809 "QM%05d", s->drive_serial);
2810 s->irq = irq;
2811 s->sector_write_timer = qemu_new_timer(vm_clock,
2812 ide_sector_write_timer_cb, s);
2813 ide_reset(s);
2814 }
2815 }
2816
2817 static void ide_init_ioport(IDEState *ide_state, int iobase, int iobase2)
2818 {
2819 register_ioport_write(iobase, 8, 1, ide_ioport_write, ide_state);
2820 register_ioport_read(iobase, 8, 1, ide_ioport_read, ide_state);
2821 if (iobase2) {
2822 register_ioport_read(iobase2, 1, 1, ide_status_read, ide_state);
2823 register_ioport_write(iobase2, 1, 1, ide_cmd_write, ide_state);
2824 }
2825
2826 /* data ports */
2827 register_ioport_write(iobase, 2, 2, ide_data_writew, ide_state);
2828 register_ioport_read(iobase, 2, 2, ide_data_readw, ide_state);
2829 register_ioport_write(iobase, 4, 4, ide_data_writel, ide_state);
2830 register_ioport_read(iobase, 4, 4, ide_data_readl, ide_state);
2831 }
2832
2833 /* save per IDE drive data */
2834 static void ide_save(QEMUFile* f, IDEState *s)
2835 {
2836 qemu_put_be32(f, s->mult_sectors);
2837 qemu_put_be32(f, s->identify_set);
2838 if (s->identify_set) {
2839 qemu_put_buffer(f, (const uint8_t *)s->identify_data, 512);
2840 }
2841 qemu_put_8s(f, &s->feature);
2842 qemu_put_8s(f, &s->error);
2843 qemu_put_be32s(f, &s->nsector);
2844 qemu_put_8s(f, &s->sector);
2845 qemu_put_8s(f, &s->lcyl);
2846 qemu_put_8s(f, &s->hcyl);
2847 qemu_put_8s(f, &s->hob_feature);
2848 qemu_put_8s(f, &s->hob_nsector);
2849 qemu_put_8s(f, &s->hob_sector);
2850 qemu_put_8s(f, &s->hob_lcyl);
2851 qemu_put_8s(f, &s->hob_hcyl);
2852 qemu_put_8s(f, &s->select);
2853 qemu_put_8s(f, &s->status);
2854 qemu_put_8s(f, &s->lba48);
2855
2856 qemu_put_8s(f, &s->sense_key);
2857 qemu_put_8s(f, &s->asc);
2858 /* XXX: if a transfer is pending, we do not save it yet */
2859 }
2860
2861 /* load per IDE drive data */
2862 static void ide_load(QEMUFile* f, IDEState *s)
2863 {
2864 s->mult_sectors=qemu_get_be32(f);
2865 s->identify_set=qemu_get_be32(f);
2866 if (s->identify_set) {
2867 qemu_get_buffer(f, (uint8_t *)s->identify_data, 512);
2868 }
2869 qemu_get_8s(f, &s->feature);
2870 qemu_get_8s(f, &s->error);
2871 qemu_get_be32s(f, &s->nsector);
2872 qemu_get_8s(f, &s->sector);
2873 qemu_get_8s(f, &s->lcyl);
2874 qemu_get_8s(f, &s->hcyl);
2875 qemu_get_8s(f, &s->hob_feature);
2876 qemu_get_8s(f, &s->hob_nsector);
2877 qemu_get_8s(f, &s->hob_sector);
2878 qemu_get_8s(f, &s->hob_lcyl);
2879 qemu_get_8s(f, &s->hob_hcyl);
2880 qemu_get_8s(f, &s->select);
2881 qemu_get_8s(f, &s->status);
2882 qemu_get_8s(f, &s->lba48);
2883
2884 qemu_get_8s(f, &s->sense_key);
2885 qemu_get_8s(f, &s->asc);
2886 /* XXX: if a transfer is pending, we do not save it yet */
2887 }
2888
2889 /***********************************************************/
2890 /* ISA IDE definitions */
2891
2892 void isa_ide_init(int iobase, int iobase2, qemu_irq irq,
2893 BlockDriverState *hd0, BlockDriverState *hd1)
2894 {
2895 IDEState *ide_state;
2896
2897 ide_state = qemu_mallocz(sizeof(IDEState) * 2);
2898 if (!ide_state)
2899 return;
2900
2901 ide_init2(ide_state, hd0, hd1, irq);
2902 ide_init_ioport(ide_state, iobase, iobase2);
2903 }
2904
2905 /***********************************************************/
2906 /* PCI IDE definitions */
2907
2908 static void cmd646_update_irq(PCIIDEState *d);
2909
2910 static void ide_map(PCIDevice *pci_dev, int region_num,
2911 uint32_t addr, uint32_t size, int type)
2912 {
2913 PCIIDEState *d = (PCIIDEState *)pci_dev;
2914 IDEState *ide_state;
2915
2916 if (region_num <= 3) {
2917 ide_state = &d->ide_if[(region_num >> 1) * 2];
2918 if (region_num & 1) {
2919 register_ioport_read(addr + 2, 1, 1, ide_status_read, ide_state);
2920 register_ioport_write(addr + 2, 1, 1, ide_cmd_write, ide_state);
2921 } else {
2922 register_ioport_write(addr, 8, 1, ide_ioport_write, ide_state);
2923 register_ioport_read(addr, 8, 1, ide_ioport_read, ide_state);
2924
2925 /* data ports */
2926 register_ioport_write(addr, 2, 2, ide_data_writew, ide_state);
2927 register_ioport_read(addr, 2, 2, ide_data_readw, ide_state);
2928 register_ioport_write(addr, 4, 4, ide_data_writel, ide_state);
2929 register_ioport_read(addr, 4, 4, ide_data_readl, ide_state);
2930 }
2931 }
2932 }
2933
2934 static void ide_dma_start(IDEState *s, BlockDriverCompletionFunc *dma_cb)
2935 {
2936 BMDMAState *bm = s->bmdma;
2937 if(!bm)
2938 return;
2939 bm->ide_if = s;
2940 bm->dma_cb = dma_cb;
2941 bm->cur_prd_last = 0;
2942 bm->cur_prd_addr = 0;
2943 bm->cur_prd_len = 0;
2944 bm->sector_num = ide_get_sector(s);
2945 bm->nsector = s->nsector;
2946 if (bm->status & BM_STATUS_DMAING) {
2947 bm->dma_cb(bm, 0);
2948 }
2949 }
2950
2951 static void ide_dma_restart(IDEState *s)
2952 {
2953 BMDMAState *bm = s->bmdma;
2954 ide_set_sector(s, bm->sector_num);
2955 s->io_buffer_index = 0;
2956 s->io_buffer_size = 0;
2957 s->nsector = bm->nsector;
2958 bm->cur_addr = bm->addr;
2959 bm->dma_cb = ide_write_dma_cb;
2960 ide_dma_start(s, bm->dma_cb);
2961 }
2962
2963 static void ide_dma_cancel(BMDMAState *bm)
2964 {
2965 if (bm->status & BM_STATUS_DMAING) {
2966 bm->status &= ~BM_STATUS_DMAING;
2967 /* cancel DMA request */
2968 bm->ide_if = NULL;
2969 bm->dma_cb = NULL;
2970 if (bm->aiocb) {
2971 #ifdef DEBUG_AIO
2972 printf("aio_cancel\n");
2973 #endif
2974 bdrv_aio_cancel(bm->aiocb);
2975 bm->aiocb = NULL;
2976 }
2977 }
2978 }
2979
2980 static void bmdma_cmd_writeb(void *opaque, uint32_t addr, uint32_t val)
2981 {
2982 BMDMAState *bm = opaque;
2983 #ifdef DEBUG_IDE
2984 printf("%s: 0x%08x\n", __func__, val);
2985 #endif
2986 if (!(val & BM_CMD_START)) {
2987 /* XXX: do it better */
2988 ide_dma_cancel(bm);
2989 bm->cmd = val & 0x09;
2990 } else {
2991 if (!(bm->status & BM_STATUS_DMAING)) {
2992 bm->status |= BM_STATUS_DMAING;
2993 /* start dma transfer if possible */
2994 if (bm->dma_cb)
2995 bm->dma_cb(bm, 0);
2996 }
2997 bm->cmd = val & 0x09;
2998 }
2999 }
3000
3001 static uint32_t bmdma_readb(void *opaque, uint32_t addr)
3002 {
3003 BMDMAState *bm = opaque;
3004 PCIIDEState *pci_dev;
3005 uint32_t val;
3006
3007 switch(addr & 3) {
3008 case 0:
3009 val = bm->cmd;
3010 break;
3011 case 1:
3012 pci_dev = bm->pci_dev;
3013 if (pci_dev->type == IDE_TYPE_CMD646) {
3014 val = pci_dev->dev.config[MRDMODE];
3015 } else {
3016 val = 0xff;
3017 }
3018 break;
3019 case 2:
3020 val = bm->status;
3021 break;
3022 case 3:
3023 pci_dev = bm->pci_dev;
3024 if (pci_dev->type == IDE_TYPE_CMD646) {
3025 if (bm == &pci_dev->bmdma[0])
3026 val = pci_dev->dev.config[UDIDETCR0];
3027 else
3028 val = pci_dev->dev.config[UDIDETCR1];
3029 } else {
3030 val = 0xff;
3031 }
3032 break;
3033 default:
3034 val = 0xff;
3035 break;
3036 }
3037 #ifdef DEBUG_IDE
3038 printf("bmdma: readb 0x%02x : 0x%02x\n", addr, val);
3039 #endif
3040 return val;
3041 }
3042
3043 static void bmdma_writeb(void *opaque, uint32_t addr, uint32_t val)
3044 {
3045 BMDMAState *bm = opaque;
3046 PCIIDEState *pci_dev;
3047 #ifdef DEBUG_IDE
3048 printf("bmdma: writeb 0x%02x : 0x%02x\n", addr, val);
3049 #endif
3050 switch(addr & 3) {
3051 case 1:
3052 pci_dev = bm->pci_dev;
3053 if (pci_dev->type == IDE_TYPE_CMD646) {
3054 pci_dev->dev.config[MRDMODE] =
3055 (pci_dev->dev.config[MRDMODE] & ~0x30) | (val & 0x30);
3056 cmd646_update_irq(pci_dev);
3057 }
3058 break;
3059 case 2:
3060 bm->status = (val & 0x60) | (bm->status & 1) | (bm->status & ~val & 0x06);
3061 break;
3062 case 3:
3063 pci_dev = bm->pci_dev;
3064 if (pci_dev->type == IDE_TYPE_CMD646) {
3065 if (bm == &pci_dev->bmdma[0])
3066 pci_dev->dev.config[UDIDETCR0] = val;
3067 else
3068 pci_dev->dev.config[UDIDETCR1] = val;
3069 }
3070 break;
3071 }
3072 }
3073
3074 static uint32_t bmdma_addr_readb(void *opaque, uint32_t addr)
3075 {
3076 BMDMAState *bm = opaque;
3077 uint32_t val;
3078 val = (bm->addr >> ((addr & 3) * 8)) & 0xff;
3079 #ifdef DEBUG_IDE
3080 printf("%s: 0x%08x\n", __func__, val);
3081 #endif
3082 return val;
3083 }
3084
3085 static void bmdma_addr_writeb(void *opaque, uint32_t addr, uint32_t val)
3086 {
3087 BMDMAState *bm = opaque;
3088 int shift = (addr & 3) * 8;
3089 #ifdef DEBUG_IDE
3090 printf("%s: 0x%08x\n", __func__, val);
3091 #endif
3092 bm->addr &= ~(0xFF << shift);
3093 bm->addr |= ((val & 0xFF) << shift) & ~3;
3094 bm->cur_addr = bm->addr;
3095 }
3096
3097 static uint32_t bmdma_addr_readw(void *opaque, uint32_t addr)
3098 {
3099 BMDMAState *bm = opaque;
3100 uint32_t val;
3101 val = (bm->addr >> ((addr & 3) * 8)) & 0xffff;
3102 #ifdef DEBUG_IDE
3103 printf("%s: 0x%08x\n", __func__, val);
3104 #endif
3105 return val;
3106 }
3107
3108 static void bmdma_addr_writew(void *opaque, uint32_t addr, uint32_t val)
3109 {
3110 BMDMAState *bm = opaque;
3111 int shift = (addr & 3) * 8;
3112 #ifdef DEBUG_IDE
3113 printf("%s: 0x%08x\n", __func__, val);
3114 #endif
3115 bm->addr &= ~(0xFFFF << shift);
3116 bm->addr |= ((val & 0xFFFF) << shift) & ~3;
3117 bm->cur_addr = bm->addr;
3118 }
3119
3120 static uint32_t bmdma_addr_readl(void *opaque, uint32_t addr)
3121 {
3122 BMDMAState *bm = opaque;
3123 uint32_t val;
3124 val = bm->addr;
3125 #ifdef DEBUG_IDE
3126 printf("%s: 0x%08x\n", __func__, val);
3127 #endif
3128 return val;
3129 }
3130
3131 static void bmdma_addr_writel(void *opaque, uint32_t addr, uint32_t val)
3132 {
3133 BMDMAState *bm = opaque;
3134 #ifdef DEBUG_IDE
3135 printf("%s: 0x%08x\n", __func__, val);
3136 #endif
3137 bm->addr = val & ~3;
3138 bm->cur_addr = bm->addr;
3139 }
3140
3141 static void bmdma_map(PCIDevice *pci_dev, int region_num,
3142 uint32_t addr, uint32_t size, int type)
3143 {
3144 PCIIDEState *d = (PCIIDEState *)pci_dev;
3145 int i;
3146
3147 for(i = 0;i < 2; i++) {
3148 BMDMAState *bm = &d->bmdma[i];
3149 d->ide_if[2 * i].bmdma = bm;
3150 d->ide_if[2 * i + 1].bmdma = bm;
3151 bm->pci_dev = (PCIIDEState *)pci_dev;
3152 qemu_add_vm_change_state_handler(ide_dma_restart_cb, bm);
3153
3154 register_ioport_write(addr, 1, 1, bmdma_cmd_writeb, bm);
3155
3156 register_ioport_write(addr + 1, 3, 1, bmdma_writeb, bm);
3157 register_ioport_read(addr, 4, 1, bmdma_readb, bm);
3158
3159 register_ioport_write(addr + 4, 4, 1, bmdma_addr_writeb, bm);
3160 register_ioport_read(addr + 4, 4, 1, bmdma_addr_readb, bm);
3161 register_ioport_write(addr + 4, 4, 2, bmdma_addr_writew, bm);
3162 register_ioport_read(addr + 4, 4, 2, bmdma_addr_readw, bm);
3163 register_ioport_write(addr + 4, 4, 4, bmdma_addr_writel, bm);
3164 register_ioport_read(addr + 4, 4, 4, bmdma_addr_readl, bm);
3165 addr += 8;
3166 }
3167 }
3168
3169 static void pci_ide_save(QEMUFile* f, void *opaque)
3170 {
3171 PCIIDEState *d = opaque;
3172 int i;
3173
3174 pci_device_save(&d->dev, f);
3175
3176 for(i = 0; i < 2; i++) {
3177 BMDMAState *bm = &d->bmdma[i];
3178 uint8_t ifidx;
3179 qemu_put_8s(f, &bm->cmd);
3180 qemu_put_8s(f, &bm->status);
3181 qemu_put_be32s(f, &bm->addr);
3182 qemu_put_sbe64s(f, &bm->sector_num);
3183 qemu_put_be32s(f, &bm->nsector);
3184 ifidx = bm->ide_if ? bm->ide_if - d->ide_if : 0;
3185 qemu_put_8s(f, &ifidx);
3186 /* XXX: if a transfer is pending, we do not save it yet */
3187 }
3188
3189 /* per IDE interface data */
3190 for(i = 0; i < 2; i++) {
3191 IDEState *s = &d->ide_if[i * 2];
3192 uint8_t drive1_selected;
3193 qemu_put_8s(f, &s->cmd);
3194 drive1_selected = (s->cur_drive != s);
3195 qemu_put_8s(f, &drive1_selected);
3196 }
3197
3198 /* per IDE drive data */
3199 for(i = 0; i < 4; i++) {
3200 ide_save(f, &d->ide_if[i]);
3201 }
3202 }
3203
3204 static int pci_ide_load(QEMUFile* f, void *opaque, int version_id)
3205 {
3206 PCIIDEState *d = opaque;
3207 int ret, i;
3208
3209 if (version_id != 2)
3210 return -EINVAL;
3211 ret = pci_device_load(&d->dev, f);
3212 if (ret < 0)
3213 return ret;
3214
3215 for(i = 0; i < 2; i++) {
3216 BMDMAState *bm = &d->bmdma[i];
3217 uint8_t ifidx;
3218 qemu_get_8s(f, &bm->cmd);
3219 qemu_get_8s(f, &bm->status);
3220 qemu_get_be32s(f, &bm->addr);
3221 qemu_get_sbe64s(f, &bm->sector_num);
3222 qemu_get_be32s(f, &bm->nsector);
3223 qemu_get_8s(f, &ifidx);
3224 bm->ide_if = &d->ide_if[ifidx];
3225 /* XXX: if a transfer is pending, we do not save it yet */
3226 }
3227
3228 /* per IDE interface data */
3229 for(i = 0; i < 2; i++) {
3230 IDEState *s = &d->ide_if[i * 2];
3231 uint8_t drive1_selected;
3232 qemu_get_8s(f, &s->cmd);
3233 qemu_get_8s(f, &drive1_selected);
3234 s->cur_drive = &d->ide_if[i * 2 + (drive1_selected != 0)];
3235 }
3236
3237 /* per IDE drive data */
3238 for(i = 0; i < 4; i++) {
3239 ide_load(f, &d->ide_if[i]);
3240 }
3241 return 0;
3242 }
3243
3244 /* XXX: call it also when the MRDMODE is changed from the PCI config
3245 registers */
3246 static void cmd646_update_irq(PCIIDEState *d)
3247 {
3248 int pci_level;
3249 pci_level = ((d->dev.config[MRDMODE] & MRDMODE_INTR_CH0) &&
3250 !(d->dev.config[MRDMODE] & MRDMODE_BLK_CH0)) ||
3251 ((d->dev.config[MRDMODE] & MRDMODE_INTR_CH1) &&
3252 !(d->dev.config[MRDMODE] & MRDMODE_BLK_CH1));
3253 qemu_set_irq(d->dev.irq[0], pci_level);
3254 }
3255
3256 /* the PCI irq level is the logical OR of the two channels */
3257 static void cmd646_set_irq(void *opaque, int channel, int level)
3258 {
3259 PCIIDEState *d = opaque;
3260 int irq_mask;
3261
3262 irq_mask = MRDMODE_INTR_CH0 << channel;
3263 if (level)
3264 d->dev.config[MRDMODE] |= irq_mask;
3265 else
3266 d->dev.config[MRDMODE] &= ~irq_mask;
3267 cmd646_update_irq(d);
3268 }
3269
3270 static void cmd646_reset(void *opaque)
3271 {
3272 PCIIDEState *d = opaque;
3273 unsigned int i;
3274
3275 for (i = 0; i < 2; i++)
3276 ide_dma_cancel(&d->bmdma[i]);
3277 }
3278
3279 /* CMD646 PCI IDE controller */
3280 void pci_cmd646_ide_init(PCIBus *bus, BlockDriverState **hd_table,
3281 int secondary_ide_enabled)
3282 {
3283 PCIIDEState *d;
3284 uint8_t *pci_conf;
3285 int i;
3286 qemu_irq *irq;
3287
3288 d = (PCIIDEState *)pci_register_device(bus, "CMD646 IDE",
3289 sizeof(PCIIDEState),
3290 -1,
3291 NULL, NULL);
3292 d->type = IDE_TYPE_CMD646;
3293 pci_conf = d->dev.config;
3294 pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_CMD);
3295 pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_CMD_646);
3296
3297 pci_conf[0x08] = 0x07; // IDE controller revision
3298 pci_conf[0x09] = 0x8f;
3299
3300 pci_config_set_class(pci_conf, PCI_CLASS_STORAGE_IDE);
3301 pci_conf[0x0e] = 0x00; // header_type
3302
3303 pci_conf[0x51] = 0x04; // enable IDE0
3304 if (secondary_ide_enabled) {
3305 /* XXX: if not enabled, really disable the seconday IDE controller */
3306 pci_conf[0x51] |= 0x08; /* enable IDE1 */
3307 }
3308
3309 pci_register_io_region((PCIDevice *)d, 0, 0x8,
3310 PCI_ADDRESS_SPACE_IO, ide_map);
3311 pci_register_io_region((PCIDevice *)d, 1, 0x4,
3312 PCI_ADDRESS_SPACE_IO, ide_map);
3313 pci_register_io_region((PCIDevice *)d, 2, 0x8,
3314 PCI_ADDRESS_SPACE_IO, ide_map);
3315 pci_register_io_region((PCIDevice *)d, 3, 0x4,
3316 PCI_ADDRESS_SPACE_IO, ide_map);
3317 pci_register_io_region((PCIDevice *)d, 4, 0x10,
3318 PCI_ADDRESS_SPACE_IO, bmdma_map);
3319
3320 pci_conf[0x3d] = 0x01; // interrupt on pin 1
3321
3322 for(i = 0; i < 4; i++)
3323 d->ide_if[i].pci_dev = (PCIDevice *)d;
3324
3325 irq = qemu_allocate_irqs(cmd646_set_irq, d, 2);
3326 ide_init2(&d->ide_if[0], hd_table[0], hd_table[1], irq[0]);
3327 ide_init2(&d->ide_if[2], hd_table[2], hd_table[3], irq[1]);
3328
3329 register_savevm("ide", 0, 2, pci_ide_save, pci_ide_load, d);
3330 qemu_register_reset(cmd646_reset, d);
3331 cmd646_reset(d);
3332 }
3333
3334 static void piix3_reset(void *opaque)
3335 {
3336 PCIIDEState *d = opaque;
3337 uint8_t *pci_conf = d->dev.config;
3338 int i;
3339
3340 for (i = 0; i < 2; i++)
3341 ide_dma_cancel(&d->bmdma[i]);
3342
3343 pci_conf[0x04] = 0x00;
3344 pci_conf[0x05] = 0x00;
3345 pci_conf[0x06] = 0x80; /* FBC */
3346 pci_conf[0x07] = 0x02; // PCI_status_devsel_medium
3347 pci_conf[0x20] = 0x01; /* BMIBA: 20-23h */
3348 }
3349
3350 /* hd_table must contain 4 block drivers */
3351 /* NOTE: for the PIIX3, the IRQs and IOports are hardcoded */
3352 void pci_piix3_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn,
3353 qemu_irq *pic)
3354 {
3355 PCIIDEState *d;
3356 uint8_t *pci_conf;
3357
3358 /* register a function 1 of PIIX3 */
3359 d = (PCIIDEState *)pci_register_device(bus, "PIIX3 IDE",
3360 sizeof(PCIIDEState),
3361 devfn,
3362 NULL, NULL);
3363 d->type = IDE_TYPE_PIIX3;
3364
3365 pci_conf = d->dev.config;
3366 pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);
3367 pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_INTEL_82371SB_1);
3368 pci_conf[0x09] = 0x80; // legacy ATA mode
3369 pci_config_set_class(pci_conf, PCI_CLASS_STORAGE_IDE);
3370 pci_conf[0x0e] = 0x00; // header_type
3371
3372 qemu_register_reset(piix3_reset, d);
3373 piix3_reset(d);
3374
3375 pci_register_io_region((PCIDevice *)d, 4, 0x10,
3376 PCI_ADDRESS_SPACE_IO, bmdma_map);
3377
3378 ide_init2(&d->ide_if[0], hd_table[0], hd_table[1], pic[14]);
3379 ide_init2(&d->ide_if[2], hd_table[2], hd_table[3], pic[15]);
3380 ide_init_ioport(&d->ide_if[0], 0x1f0, 0x3f6);
3381 ide_init_ioport(&d->ide_if[2], 0x170, 0x376);
3382
3383 register_savevm("ide", 0, 2, pci_ide_save, pci_ide_load, d);
3384 }
3385
3386 /* hd_table must contain 4 block drivers */
3387 /* NOTE: for the PIIX4, the IRQs and IOports are hardcoded */
3388 void pci_piix4_ide_init(PCIBus *bus, BlockDriverState **hd_table, int devfn,
3389 qemu_irq *pic)
3390 {
3391 PCIIDEState *d;
3392 uint8_t *pci_conf;
3393
3394 /* register a function 1 of PIIX4 */
3395 d = (PCIIDEState *)pci_register_device(bus, "PIIX4 IDE",
3396 sizeof(PCIIDEState),
3397 devfn,
3398 NULL, NULL);
3399 d->type = IDE_TYPE_PIIX4;
3400
3401 pci_conf = d->dev.config;
3402 pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);
3403 pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_INTEL_82371AB);
3404 pci_conf[0x09] = 0x80; // legacy ATA mode
3405 pci_config_set_class(pci_conf, PCI_CLASS_STORAGE_IDE);
3406 pci_conf[0x0e] = 0x00; // header_type
3407
3408 qemu_register_reset(piix3_reset, d);
3409 piix3_reset(d);
3410
3411 pci_register_io_region((PCIDevice *)d, 4, 0x10,
3412 PCI_ADDRESS_SPACE_IO, bmdma_map);
3413
3414 ide_init2(&d->ide_if[0], hd_table[0], hd_table[1], pic[14]);
3415 ide_init2(&d->ide_if[2], hd_table[2], hd_table[3], pic[15]);
3416 ide_init_ioport(&d->ide_if[0], 0x1f0, 0x3f6);
3417 ide_init_ioport(&d->ide_if[2], 0x170, 0x376);
3418
3419 register_savevm("ide", 0, 2, pci_ide_save, pci_ide_load, d);
3420 }
3421
3422 #if defined(TARGET_PPC)
3423 /***********************************************************/
3424 /* MacIO based PowerPC IDE */
3425
3426 typedef struct MACIOIDEState {
3427 IDEState ide_if[2];
3428 void *dbdma;
3429 int stream_index;
3430 } MACIOIDEState;
3431
3432 static int pmac_atapi_read(DBDMA_transfer *info, DBDMA_transfer_cb cb)
3433 {
3434 MACIOIDEState *m = info->opaque;
3435 IDEState *s = m->ide_if->cur_drive;
3436 int ret;
3437
3438 if (s->lba == -1)
3439 return 0;
3440
3441 info->buf_pos = 0;
3442
3443 while (info->buf_pos < info->len && s->packet_transfer_size > 0) {
3444
3445 ret = cd_read_sector(s->bs, s->lba, s->io_buffer, s->cd_sector_size);
3446 if (ret < 0) {
3447 ide_transfer_stop(s);
3448 ide_atapi_io_error(s, ret);
3449 return info->buf_pos;
3450 }
3451
3452 info->buf = s->io_buffer + m->stream_index;
3453
3454 info->buf_len = s->cd_sector_size;
3455 if (info->buf_pos + info->buf_len > info->len)
3456 info->buf_len = info->len - info->buf_pos;
3457
3458 cb(info);
3459
3460 /* db-dma can ask for 512 bytes whereas block size is 2048... */
3461
3462 m->stream_index += info->buf_len;
3463 s->lba += m->stream_index / s->cd_sector_size;
3464 m->stream_index %= s->cd_sector_size;
3465
3466 info->buf_pos += info->buf_len;
3467 s->packet_transfer_size -= info->buf_len;
3468 }
3469 if (s->packet_transfer_size <= 0) {
3470 s->status = READY_STAT | SEEK_STAT;
3471 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO
3472 | ATAPI_INT_REASON_CD;
3473 ide_set_irq(s);
3474 }
3475
3476 return info->buf_pos;
3477 }
3478
3479 static int pmac_ide_transfer(DBDMA_transfer *info,
3480 DBDMA_transfer_cb cb)
3481 {
3482 MACIOIDEState *m = info->opaque;
3483 IDEState *s = m->ide_if->cur_drive;
3484 int64_t sector_num;
3485 int ret, n;
3486
3487 if (s->is_cdrom)
3488 return pmac_atapi_read(info, cb);
3489
3490 info->buf = s->io_buffer;
3491 info->buf_pos = 0;
3492 while (info->buf_pos < info->len && s->nsector > 0) {
3493
3494 sector_num = ide_get_sector(s);
3495
3496 n = s->nsector;
3497 if (n > IDE_DMA_BUF_SECTORS)
3498 n = IDE_DMA_BUF_SECTORS;
3499
3500 info->buf_len = n << 9;
3501 if (info->buf_pos + info->buf_len > info->len)
3502 info->buf_len = info->len - info->buf_pos;
3503 n = info->buf_len >> 9;
3504
3505 if (s->is_read) {
3506 ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
3507 if (ret == 0)
3508 cb(info);
3509 } else {
3510 cb(info);
3511 ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
3512 }
3513
3514 if (ret != 0) {
3515 ide_rw_error(s);
3516 return info->buf_pos;
3517 }
3518
3519 info->buf_pos += n << 9;
3520 ide_set_sector(s, sector_num + n);
3521 s->nsector -= n;
3522 }
3523
3524 if (s->nsector <= 0) {
3525 s->status = READY_STAT | SEEK_STAT;
3526 ide_set_irq(s);
3527 }
3528
3529 return info->buf_pos;
3530 }
3531
3532 /* PowerMac IDE memory IO */
3533 static void pmac_ide_writeb (void *opaque,
3534 target_phys_addr_t addr, uint32_t val)
3535 {
3536 MACIOIDEState *d = opaque;
3537
3538 addr = (addr & 0xFFF) >> 4;
3539 switch (addr) {
3540 case 1 ... 7:
3541 ide_ioport_write(d->ide_if, addr, val);
3542 break;
3543 case 8:
3544 case 22:
3545 ide_cmd_write(d->ide_if, 0, val);
3546 break;
3547 default:
3548 break;
3549 }
3550 }
3551
3552 static uint32_t pmac_ide_readb (void *opaque,target_phys_addr_t addr)
3553 {
3554 uint8_t retval;
3555 MACIOIDEState *d = opaque;
3556
3557 addr = (addr & 0xFFF) >> 4;
3558 switch (addr) {
3559 case 1 ... 7:
3560 retval = ide_ioport_read(d->ide_if, addr);
3561 break;
3562 case 8:
3563 case 22:
3564 retval = ide_status_read(d->ide_if, 0);
3565 break;
3566 default:
3567 retval = 0xFF;
3568 break;
3569 }
3570 return retval;
3571 }
3572
3573 static void pmac_ide_writew (void *opaque,
3574 target_phys_addr_t addr, uint32_t val)
3575 {
3576 MACIOIDEState *d = opaque;
3577
3578 addr = (addr & 0xFFF) >> 4;
3579 #ifdef TARGET_WORDS_BIGENDIAN
3580 val = bswap16(val);
3581 #endif
3582 if (addr == 0) {
3583 ide_data_writew(d->ide_if, 0, val);
3584 }
3585 }
3586
3587 static uint32_t pmac_ide_readw (void *opaque,target_phys_addr_t addr)
3588 {
3589 uint16_t retval;
3590 MACIOIDEState *d = opaque;
3591
3592 addr = (addr & 0xFFF) >> 4;
3593 if (addr == 0) {
3594 retval = ide_data_readw(d->ide_if, 0);
3595 } else {
3596 retval = 0xFFFF;
3597 }
3598 #ifdef TARGET_WORDS_BIGENDIAN
3599 retval = bswap16(retval);
3600 #endif
3601 return retval;
3602 }
3603
3604 static void pmac_ide_writel (void *opaque,
3605 target_phys_addr_t addr, uint32_t val)
3606 {
3607 MACIOIDEState *d = opaque;
3608
3609 addr = (addr & 0xFFF) >> 4;
3610 #ifdef TARGET_WORDS_BIGENDIAN
3611 val = bswap32(val);
3612 #endif
3613 if (addr == 0) {
3614 ide_data_writel(d->ide_if, 0, val);
3615 }
3616 }
3617
3618 static uint32_t pmac_ide_readl (void *opaque,target_phys_addr_t addr)
3619 {
3620 uint32_t retval;
3621 MACIOIDEState *d = opaque;
3622
3623 addr = (addr & 0xFFF) >> 4;
3624 if (addr == 0) {
3625 retval = ide_data_readl(d->ide_if, 0);
3626 } else {
3627 retval = 0xFFFFFFFF;
3628 }
3629 #ifdef TARGET_WORDS_BIGENDIAN
3630 retval = bswap32(retval);
3631 #endif
3632 return retval;
3633 }
3634
3635 static CPUWriteMemoryFunc *pmac_ide_write[] = {
3636 pmac_ide_writeb,
3637 pmac_ide_writew,
3638 pmac_ide_writel,
3639 };
3640
3641 static CPUReadMemoryFunc *pmac_ide_read[] = {
3642 pmac_ide_readb,
3643 pmac_ide_readw,
3644 pmac_ide_readl,
3645 };
3646
3647 static void pmac_ide_save(QEMUFile *f, void *opaque)
3648 {
3649 MACIOIDEState *d = opaque;
3650 IDEState *s = d->ide_if;
3651 uint8_t drive1_selected;
3652 unsigned int i;
3653
3654 /* per IDE interface data */
3655 qemu_put_8s(f, &s->cmd);
3656 drive1_selected = (s->cur_drive != s);
3657 qemu_put_8s(f, &drive1_selected);
3658
3659 /* per IDE drive data */
3660 for(i = 0; i < 2; i++) {
3661 ide_save(f, &s[i]);
3662 }
3663 }
3664
3665 static int pmac_ide_load(QEMUFile *f, void *opaque, int version_id)
3666 {
3667 MACIOIDEState *d = opaque;
3668 IDEState *s = d->ide_if;
3669 uint8_t drive1_selected;
3670 unsigned int i;
3671
3672 if (version_id != 1)
3673 return -EINVAL;
3674
3675 /* per IDE interface data */
3676 qemu_get_8s(f, &s->cmd);
3677 qemu_get_8s(f, &drive1_selected);
3678 s->cur_drive = &s[(drive1_selected != 0)];
3679
3680 /* per IDE drive data */
3681 for(i = 0; i < 2; i++) {
3682 ide_load(f, &s[i]);
3683 }
3684 return 0;
3685 }
3686
3687 static void pmac_ide_reset(void *opaque)
3688 {
3689 MACIOIDEState *d = opaque;
3690 IDEState *s = d->ide_if;
3691
3692 ide_reset(&s[0]);
3693 ide_reset(&s[1]);
3694 }
3695
3696 /* hd_table must contain 4 block drivers */
3697 /* PowerMac uses memory mapped registers, not I/O. Return the memory
3698 I/O index to access the ide. */
3699 int pmac_ide_init (BlockDriverState **hd_table, qemu_irq irq,
3700 void *dbdma, int channel, qemu_irq dma_irq)
3701 {
3702 MACIOIDEState *d;
3703 int pmac_ide_memory;
3704
3705 d = qemu_mallocz(sizeof(MACIOIDEState));
3706 ide_init2(d->ide_if, hd_table[0], hd_table[1], irq);
3707
3708 if (dbdma) {
3709 d->dbdma = dbdma;
3710 DBDMA_register_channel(dbdma, channel, dma_irq, pmac_ide_transfer, d);
3711 }
3712
3713 pmac_ide_memory = cpu_register_io_memory(0, pmac_ide_read,
3714 pmac_ide_write, d);
3715 register_savevm("ide", 0, 1, pmac_ide_save, pmac_ide_load, d);
3716 qemu_register_reset(pmac_ide_reset, d);
3717 pmac_ide_reset(d);
3718
3719 return pmac_ide_memory;
3720 }
3721 #endif /* TARGET_PPC */
3722
3723 /***********************************************************/
3724 /* MMIO based ide port
3725 * This emulates IDE device connected directly to the CPU bus without
3726 * dedicated ide controller, which is often seen on embedded boards.
3727 */
3728
3729 typedef struct {
3730 void *dev;
3731 int shift;
3732 } MMIOState;
3733
3734 static uint32_t mmio_ide_read (void *opaque, target_phys_addr_t addr)
3735 {
3736 MMIOState *s = (MMIOState*)opaque;
3737 IDEState *ide = (IDEState*)s->dev;
3738 addr >>= s->shift;
3739 if (addr & 7)
3740 return ide_ioport_read(ide, addr);
3741 else
3742 return ide_data_readw(ide, 0);
3743 }
3744
3745 static void mmio_ide_write (void *opaque, target_phys_addr_t addr,
3746 uint32_t val)
3747 {
3748 MMIOState *s = (MMIOState*)opaque;
3749 IDEState *ide = (IDEState*)s->dev;
3750 addr >>= s->shift;
3751 if (addr & 7)
3752 ide_ioport_write(ide, addr, val);
3753 else
3754 ide_data_writew(ide, 0, val);
3755 }
3756
3757 static CPUReadMemoryFunc *mmio_ide_reads[] = {
3758 mmio_ide_read,
3759 mmio_ide_read,
3760 mmio_ide_read,
3761 };
3762
3763 static CPUWriteMemoryFunc *mmio_ide_writes[] = {
3764 mmio_ide_write,
3765 mmio_ide_write,
3766 mmio_ide_write,
3767 };
3768
3769 static uint32_t mmio_ide_status_read (void *opaque, target_phys_addr_t addr)
3770 {
3771 MMIOState *s= (MMIOState*)opaque;
3772 IDEState *ide = (IDEState*)s->dev;
3773 return ide_status_read(ide, 0);
3774 }
3775
3776 static void mmio_ide_cmd_write (void *opaque, target_phys_addr_t addr,
3777 uint32_t val)
3778 {
3779 MMIOState *s = (MMIOState*)opaque;
3780 IDEState *ide = (IDEState*)s->dev;
3781 ide_cmd_write(ide, 0, val);
3782 }
3783
3784 static CPUReadMemoryFunc *mmio_ide_status[] = {
3785 mmio_ide_status_read,
3786 mmio_ide_status_read,
3787 mmio_ide_status_read,
3788 };
3789
3790 static CPUWriteMemoryFunc *mmio_ide_cmd[] = {
3791 mmio_ide_cmd_write,
3792 mmio_ide_cmd_write,
3793 mmio_ide_cmd_write,
3794 };
3795
3796 void mmio_ide_init (target_phys_addr_t membase, target_phys_addr_t membase2,
3797 qemu_irq irq, int shift,
3798 BlockDriverState *hd0, BlockDriverState *hd1)
3799 {
3800 MMIOState *s = qemu_mallocz(sizeof(MMIOState));
3801 IDEState *ide = qemu_mallocz(sizeof(IDEState) * 2);
3802 int mem1, mem2;
3803
3804 ide_init2(ide, hd0, hd1, irq);
3805
3806 s->dev = ide;
3807 s->shift = shift;
3808
3809 mem1 = cpu_register_io_memory(0, mmio_ide_reads, mmio_ide_writes, s);
3810 mem2 = cpu_register_io_memory(0, mmio_ide_status, mmio_ide_cmd, s);
3811 cpu_register_physical_memory(membase, 16 << shift, mem1);
3812 cpu_register_physical_memory(membase2, 2 << shift, mem2);
3813 }
3814
3815 /***********************************************************/
3816 /* CF-ATA Microdrive */
3817
3818 #define METADATA_SIZE 0x20
3819
3820 /* DSCM-1XXXX Microdrive hard disk with CF+ II / PCMCIA interface. */
3821 struct md_s {
3822 IDEState ide[2];
3823 struct pcmcia_card_s card;
3824 uint32_t attr_base;
3825 uint32_t io_base;
3826
3827 /* Card state */
3828 uint8_t opt;
3829 uint8_t stat;
3830 uint8_t pins;
3831
3832 uint8_t ctrl;
3833 uint16_t io;
3834 int cycle;
3835 };
3836
3837 /* Register bitfields */
3838 enum md_opt {
3839 OPT_MODE_MMAP = 0,
3840 OPT_MODE_IOMAP16 = 1,
3841 OPT_MODE_IOMAP1 = 2,
3842 OPT_MODE_IOMAP2 = 3,
3843 OPT_MODE = 0x3f,
3844 OPT_LEVIREQ = 0x40,
3845 OPT_SRESET = 0x80,
3846 };
3847 enum md_cstat {
3848 STAT_INT = 0x02,
3849 STAT_PWRDWN = 0x04,
3850 STAT_XE = 0x10,
3851 STAT_IOIS8 = 0x20,
3852 STAT_SIGCHG = 0x40,
3853 STAT_CHANGED = 0x80,
3854 };
3855 enum md_pins {
3856 PINS_MRDY = 0x02,
3857 PINS_CRDY = 0x20,
3858 };
3859 enum md_ctrl {
3860 CTRL_IEN = 0x02,
3861 CTRL_SRST = 0x04,
3862 };
3863
3864 static inline void md_interrupt_update(struct md_s *s)
3865 {
3866 if (!s->card.slot)
3867 return;
3868
3869 qemu_set_irq(s->card.slot->irq,
3870 !(s->stat & STAT_INT) && /* Inverted */
3871 !(s->ctrl & (CTRL_IEN | CTRL_SRST)) &&
3872 !(s->opt & OPT_SRESET));
3873 }
3874
3875 static void md_set_irq(void *opaque, int irq, int level)
3876 {
3877 struct md_s *s = (struct md_s *) opaque;
3878 if (level)
3879 s->stat |= STAT_INT;
3880 else
3881 s->stat &= ~STAT_INT;
3882
3883 md_interrupt_update(s);
3884 }
3885
3886 static void md_reset(struct md_s *s)
3887 {
3888 s->opt = OPT_MODE_MMAP;
3889 s->stat = 0;
3890 s->pins = 0;
3891 s->cycle = 0;
3892 s->ctrl = 0;
3893 ide_reset(s->ide);
3894 }
3895
3896 static uint8_t md_attr_read(void *opaque, uint32_t at)
3897 {
3898 struct md_s *s = (struct md_s *) opaque;
3899 if (at < s->attr_base) {
3900 if (at < s->card.cis_len)
3901 return s->card.cis[at];
3902 else
3903 return 0x00;
3904 }
3905
3906 at -= s->attr_base;
3907
3908 switch (at) {
3909 case 0x00: /* Configuration Option Register */
3910 return s->opt;
3911 case 0x02: /* Card Configuration Status Register */
3912 if (s->ctrl & CTRL_IEN)
3913 return s->stat & ~STAT_INT;
3914 else
3915 return s->stat;
3916 case 0x04: /* Pin Replacement Register */
3917 return (s->pins & PINS_CRDY) | 0x0c;
3918 case 0x06: /* Socket and Copy Register */
3919 return 0x00;
3920 #ifdef VERBOSE
3921 default:
3922 printf("%s: Bad attribute space register %02x\n", __FUNCTION__, at);
3923 #endif
3924 }
3925
3926 return 0;
3927 }
3928
3929 static void md_attr_write(void *opaque, uint32_t at, uint8_t value)
3930 {
3931 struct md_s *s = (struct md_s *) opaque;
3932 at -= s->attr_base;
3933
3934 switch (at) {
3935 case 0x00: /* Configuration Option Register */
3936 s->opt = value & 0xcf;
3937 if (value & OPT_SRESET)
3938 md_reset(s);
3939 md_interrupt_update(s);
3940 break;
3941 case 0x02: /* Card Configuration Status Register */
3942 if ((s->stat ^ value) & STAT_PWRDWN)
3943 s->pins |= PINS_CRDY;
3944 s->stat &= 0x82;
3945 s->stat |= value & 0x74;
3946 md_interrupt_update(s);
3947 /* Word 170 in Identify Device must be equal to STAT_XE */
3948 break;
3949 case 0x04: /* Pin Replacement Register */
3950 s->pins &= PINS_CRDY;
3951 s->pins |= value & PINS_MRDY;
3952 break;
3953 case 0x06: /* Socket and Copy Register */
3954 break;
3955 default:
3956 printf("%s: Bad attribute space register %02x\n", __FUNCTION__, at);
3957 }
3958 }
3959
3960 static uint16_t md_common_read(void *opaque, uint32_t at)
3961 {
3962 struct md_s *s = (struct md_s *) opaque;
3963 uint16_t ret;
3964 at -= s->io_base;
3965
3966 switch (s->opt & OPT_MODE) {
3967 case OPT_MODE_MMAP:
3968 if ((at & ~0x3ff) == 0x400)
3969 at = 0;
3970 break;
3971 case OPT_MODE_IOMAP16:
3972 at &= 0xf;
3973 break;
3974 case OPT_MODE_IOMAP1:
3975 if ((at & ~0xf) == 0x3f0)
3976 at -= 0x3e8;
3977 else if ((at & ~0xf) == 0x1f0)
3978 at -= 0x1f0;
3979 break;
3980 case OPT_MODE_IOMAP2:
3981 if ((at & ~0xf) == 0x370)
3982 at -= 0x368;
3983 else if ((at & ~0xf) == 0x170)
3984 at -= 0x170;
3985 }
3986
3987 switch (at) {
3988 case 0x0: /* Even RD Data */
3989 case 0x8:
3990 return ide_data_readw(s->ide, 0);
3991
3992 /* TODO: 8-bit accesses */
3993 if (s->cycle)
3994 ret = s->io >> 8;
3995 else {
3996 s->io = ide_data_readw(s->ide, 0);
3997 ret = s->io & 0xff;
3998 }
3999 s->cycle = !s->cycle;
4000 return ret;
4001 case 0x9: /* Odd RD Data */
4002 return s->io >> 8;
4003 case 0xd: /* Error */
4004 return ide_ioport_read(s->ide, 0x1);
4005 case 0xe: /* Alternate Status */
4006 if (s->ide->cur_drive->bs)
4007 return s->ide->cur_drive->status;
4008 else
4009 return 0;
4010 case 0xf: /* Device Address */
4011 return 0xc2 | ((~s->ide->select << 2) & 0x3c);
4012 default:
4013 return ide_ioport_read(s->ide, at);
4014 }
4015
4016 return 0;
4017 }
4018
4019 static void md_common_write(void *opaque, uint32_t at, uint16_t value)
4020 {
4021 struct md_s *s = (struct md_s *) opaque;
4022 at -= s->io_base;
4023
4024 switch (s->opt & OPT_MODE) {
4025 case OPT_MODE_MMAP:
4026 if ((at & ~0x3ff) == 0x400)
4027 at = 0;
4028 break;
4029 case OPT_MODE_IOMAP16:
4030 at &= 0xf;
4031 break;
4032 case OPT_MODE_IOMAP1:
4033 if ((at & ~0xf) == 0x3f0)
4034 at -= 0x3e8;
4035 else if ((at & ~0xf) == 0x1f0)
4036 at -= 0x1f0;
4037 break;
4038 case OPT_MODE_IOMAP2:
4039 if ((at & ~0xf) == 0x370)
4040 at -= 0x368;
4041 else if ((at & ~0xf) == 0x170)
4042 at -= 0x170;
4043 }
4044
4045 switch (at) {
4046 case 0x0: /* Even WR Data */
4047 case 0x8:
4048 ide_data_writew(s->ide, 0, value);
4049 break;
4050
4051 /* TODO: 8-bit accesses */
4052 if (s->cycle)
4053 ide_data_writew(s->ide, 0, s->io | (value << 8));
4054 else
4055 s->io = value & 0xff;
4056 s->cycle = !s->cycle;
4057 break;
4058 case 0x9:
4059 s->io = value & 0xff;
4060 s->cycle = !s->cycle;
4061 break;
4062 case 0xd: /* Features */
4063 ide_ioport_write(s->ide, 0x1, value);
4064 break;
4065 case 0xe: /* Device Control */
4066 s->ctrl = value;
4067 if (value & CTRL_SRST)
4068 md_reset(s);
4069 md_interrupt_update(s);
4070 break;
4071 default:
4072 if (s->stat & STAT_PWRDWN) {
4073 s->pins |= PINS_CRDY;
4074 s->stat &= ~STAT_PWRDWN;
4075 }
4076 ide_ioport_write(s->ide, at, value);
4077 }
4078 }
4079
4080 static void md_save(QEMUFile *f, void *opaque)
4081 {
4082 struct md_s *s = (struct md_s *) opaque;
4083 int i;
4084 uint8_t drive1_selected;
4085
4086 qemu_put_8s(f, &s->opt);
4087 qemu_put_8s(f, &s->stat);
4088 qemu_put_8s(f, &s->pins);
4089
4090 qemu_put_8s(f, &s->ctrl);
4091 qemu_put_be16s(f, &s->io);
4092 qemu_put_byte(f, s->cycle);
4093
4094 drive1_selected = (s->ide->cur_drive != s->ide);
4095 qemu_put_8s(f, &s->ide->cmd);
4096 qemu_put_8s(f, &drive1_selected);
4097
4098 for (i = 0; i < 2; i ++)
4099 ide_save(f, &s->ide[i]);
4100 }
4101
4102 static int md_load(QEMUFile *f, void *opaque, int version_id)
4103 {
4104 struct md_s *s = (struct md_s *) opaque;
4105 int i;
4106 uint8_t drive1_selected;
4107
4108 qemu_get_8s(f, &s->opt);
4109 qemu_get_8s(f, &s->stat);
4110 qemu_get_8s(f, &s->pins);
4111
4112 qemu_get_8s(f, &s->ctrl);
4113 qemu_get_be16s(f, &s->io);
4114 s->cycle = qemu_get_byte(f);
4115
4116 qemu_get_8s(f, &s->ide->cmd);
4117 qemu_get_8s(f, &drive1_selected);
4118 s->ide->cur_drive = &s->ide[(drive1_selected != 0)];
4119
4120 for (i = 0; i < 2; i ++)
4121 ide_load(f, &s->ide[i]);
4122
4123 return 0;
4124 }
4125
4126 static const uint8_t dscm1xxxx_cis[0x14a] = {
4127 [0x000] = CISTPL_DEVICE, /* 5V Device Information */
4128 [0x002] = 0x03, /* Tuple length = 4 bytes */
4129 [0x004] = 0xdb, /* ID: DTYPE_FUNCSPEC, non WP, DSPEED_150NS */
4130 [0x006] = 0x01, /* Size = 2K bytes */
4131 [0x008] = CISTPL_ENDMARK,
4132
4133 [0x00a] = CISTPL_DEVICE_OC, /* Additional Device Information */
4134 [0x00c] = 0x04, /* Tuple length = 4 byest */
4135 [0x00e] = 0x03, /* Conditions: Ext = 0, Vcc 3.3V, MWAIT = 1 */
4136 [0x010] = 0xdb, /* ID: DTYPE_FUNCSPEC, non WP, DSPEED_150NS */
4137 [0x012] = 0x01, /* Size = 2K bytes */
4138 [0x014] = CISTPL_ENDMARK,
4139
4140 [0x016] = CISTPL_JEDEC_C, /* JEDEC ID */
4141 [0x018] = 0x02, /* Tuple length = 2 bytes */
4142 [0x01a] = 0xdf, /* PC Card ATA with no Vpp required */
4143 [0x01c] = 0x01,
4144
4145 [0x01e] = CISTPL_MANFID, /* Manufacture ID */
4146 [0x020] = 0x04, /* Tuple length = 4 bytes */
4147 [0x022] = 0xa4, /* TPLMID_MANF = 00a4 (IBM) */
4148 [0x024] = 0x00,
4149 [0x026] = 0x00, /* PLMID_CARD = 0000 */
4150 [0x028] = 0x00,
4151
4152 [0x02a] = CISTPL_VERS_1, /* Level 1 Version */
4153 [0x02c] = 0x12, /* Tuple length = 23 bytes */
4154 [0x02e] = 0x04, /* Major Version = JEIDA 4.2 / PCMCIA 2.1 */
4155 [0x030] = 0x01, /* Minor Version = 1 */
4156 [0x032] = 'I',
4157 [0x034] = 'B',
4158 [0x036] = 'M',
4159 [0x038] = 0x00,
4160 [0x03a] = 'm',
4161 [0x03c] = 'i',
4162 [0x03e] = 'c',
4163 [0x040] = 'r',
4164 [0x042] = 'o',
4165 [0x044] = 'd',
4166 [0x046] = 'r',
4167 [0x048] = 'i',
4168 [0x04a] = 'v',
4169 [0x04c] = 'e',
4170 [0x04e] = 0x00,
4171 [0x050] = CISTPL_ENDMARK,
4172
4173 [0x052] = CISTPL_FUNCID, /* Function ID */
4174 [0x054] = 0x02, /* Tuple length = 2 bytes */
4175 [0x056] = 0x04, /* TPLFID_FUNCTION = Fixed Disk */
4176 [0x058] = 0x01, /* TPLFID_SYSINIT: POST = 1, ROM = 0 */
4177
4178 [0x05a] = CISTPL_FUNCE, /* Function Extension */
4179 [0x05c] = 0x02, /* Tuple length = 2 bytes */
4180 [0x05e] = 0x01, /* TPLFE_TYPE = Disk Device Interface */
4181 [0x060] = 0x01, /* TPLFE_DATA = PC Card ATA Interface */
4182
4183 [0x062] = CISTPL_FUNCE, /* Function Extension */
4184 [0x064] = 0x03, /* Tuple length = 3 bytes */
4185 [0x066] = 0x02, /* TPLFE_TYPE = Basic PC Card ATA Interface */
4186 [0x068] = 0x08, /* TPLFE_DATA: Rotating, Unique, Single */
4187 [0x06a] = 0x0f, /* TPLFE_DATA: Sleep, Standby, Idle, Auto */
4188
4189 [0x06c] = CISTPL_CONFIG, /* Configuration */
4190 [0x06e] = 0x05, /* Tuple length = 5 bytes */
4191 [0x070] = 0x01, /* TPCC_RASZ = 2 bytes, TPCC_RMSZ = 1 byte */
4192 [0x072] = 0x07, /* TPCC_LAST = 7 */
4193 [0x074] = 0x00, /* TPCC_RADR = 0200 */
4194 [0x076] = 0x02,
4195 [0x078] = 0x0f, /* TPCC_RMSK = 200, 202, 204, 206 */
4196
4197 [0x07a] = CISTPL_CFTABLE_ENTRY, /* 16-bit PC Card Configuration */
4198 [0x07c] = 0x0b, /* Tuple length = 11 bytes */
4199 [0x07e] = 0xc0, /* TPCE_INDX = Memory Mode, Default, Iface */
4200 [0x080] = 0xc0, /* TPCE_IF = Memory, no BVDs, no WP, READY */
4201 [0x082] = 0xa1, /* TPCE_FS = Vcc only, no I/O, Memory, Misc */
4202 [0x084] = 0x27, /* NomV = 1, MinV = 1, MaxV = 1, Peakl = 1 */
4203 [0x086] = 0x55, /* NomV: 5.0 V */
4204 [0x088] = 0x4d, /* MinV: 4.5 V */
4205 [0x08a] = 0x5d, /* MaxV: 5.5 V */
4206 [0x08c] = 0x4e, /* Peakl: 450 mA */
4207 [0x08e] = 0x08, /* TPCE_MS = 1 window, 1 byte, Host address */
4208 [0x090] = 0x00, /* Window descriptor: Window length = 0 */
4209 [0x092] = 0x20, /* TPCE_MI: support power down mode, RW */
4210
4211 [0x094] = CISTPL_CFTABLE_ENTRY, /* 16-bit PC Card Configuration */
4212 [0x096] = 0x06, /* Tuple length = 6 bytes */
4213 [0x098] = 0x00, /* TPCE_INDX = Memory Mode, no Default */
4214 [0x09a] = 0x01, /* TPCE_FS = Vcc only, no I/O, no Memory */
4215 [0x09c] = 0x21, /* NomV = 1, MinV = 0, MaxV = 0, Peakl = 1 */
4216 [0x09e] = 0xb5, /* NomV: 3.3 V */
4217 [0x0a0] = 0x1e,
4218 [0x0a2] = 0x3e, /* Peakl: 350 mA */
4219
4220 [0x0a4] = CISTPL_CFTABLE_ENTRY, /* 16-bit PC Card Configuration */
4221 [0x0a6] = 0x0d, /* Tuple length = 13 bytes */
4222 [0x0a8] = 0xc1, /* TPCE_INDX = I/O and Memory Mode, Default */
4223 [0x0aa] = 0x41, /* TPCE_IF = I/O and Memory, no BVD, no WP */
4224 [0x0ac] = 0x99, /* TPCE_FS = Vcc only, I/O, Interrupt, Misc */
4225 [0x0ae] = 0x27, /* NomV = 1, MinV = 1, MaxV = 1, Peakl = 1 */
4226 [0x0b0] = 0x55, /* NomV: 5.0 V */
4227 [0x0b2] = 0x4d, /* MinV: 4.5 V */
4228 [0x0b4] = 0x5d, /* MaxV: 5.5 V */
4229 [0x0b6] = 0x4e, /* Peakl: 450 mA */
4230 [0x0b8] = 0x64, /* TPCE_IO = 16-byte boundary, 16/8 accesses */
4231 [0x0ba] = 0xf0, /* TPCE_IR = MASK, Level, Pulse, Share */
4232 [0x0bc] = 0xff, /* IRQ0..IRQ7 supported */
4233 [0x0be] = 0xff, /* IRQ8..IRQ15 supported */
4234 [0x0c0] = 0x20, /* TPCE_MI = support power down mode */
4235
4236 [0x0c2] = CISTPL_CFTABLE_ENTRY, /* 16-bit PC Card Configuration */
4237 [0x0c4] = 0x06, /* Tuple length = 6 bytes */
4238 [0x0c6] = 0x01, /* TPCE_INDX = I/O and Memory Mode */
4239 [0x0c8] = 0x01, /* TPCE_FS = Vcc only, no I/O, no Memory */
4240 [0x0ca] = 0x21, /* NomV = 1, MinV = 0, MaxV = 0, Peakl = 1 */
4241 [0x0cc] = 0xb5, /* NomV: 3.3 V */
4242 [0x0ce] = 0x1e,
4243 [0x0d0] = 0x3e, /* Peakl: 350 mA */
4244
4245 [0x0d2] = CISTPL_CFTABLE_ENTRY, /* 16-bit PC Card Configuration */
4246 [0x0d4] = 0x12, /* Tuple length = 18 bytes */
4247 [0x0d6] = 0xc2, /* TPCE_INDX = I/O Primary Mode */
4248 [0x0d8] = 0x41, /* TPCE_IF = I/O and Memory, no BVD, no WP */
4249 [0x0da] = 0x99, /* TPCE_FS = Vcc only, I/O, Interrupt, Misc */
4250 [0x0dc] = 0x27, /* NomV = 1, MinV = 1, MaxV = 1, Peakl = 1 */
4251 [0x0de] = 0x55, /* NomV: 5.0 V */
4252 [0x0e0] = 0x4d, /* MinV: 4.5 V */
4253 [0x0e2] = 0x5d, /* MaxV: 5.5 V */
4254 [0x0e4] = 0x4e, /* Peakl: 450 mA */
4255 [0x0e6] = 0xea, /* TPCE_IO = 1K boundary, 16/8 access, Range */
4256 [0x0e8] = 0x61, /* Range: 2 fields, 2 bytes addr, 1 byte len */
4257 [0x0ea] = 0xf0, /* Field 1 address = 0x01f0 */
4258 [0x0ec] = 0x01,
4259 [0x0ee] = 0x07, /* Address block length = 8 */
4260 [0x0f0] = 0xf6, /* Field 2 address = 0x03f6 */
4261 [0x0f2] = 0x03,
4262 [0x0f4] = 0x01, /* Address block length = 2 */
4263 [0x0f6] = 0xee, /* TPCE_IR = IRQ E, Level, Pulse, Share */
4264 [0x0f8] = 0x20, /* TPCE_MI = support power down mode */
4265
4266 [0x0fa] = CISTPL_CFTABLE_ENTRY, /* 16-bit PC Card Configuration */
4267 [0x0fc] = 0x06, /* Tuple length = 6 bytes */
4268 [0x0fe] = 0x02, /* TPCE_INDX = I/O Primary Mode, no Default */
4269 [0x100] = 0x01, /* TPCE_FS = Vcc only, no I/O, no Memory */
4270 [0x102] = 0x21, /* NomV = 1, MinV = 0, MaxV = 0, Peakl = 1 */
4271 [0x104] = 0xb5, /* NomV: 3.3 V */
4272 [0x106] = 0x1e,
4273 [0x108] = 0x3e, /* Peakl: 350 mA */
4274
4275 [0x10a] = CISTPL_CFTABLE_ENTRY, /* 16-bit PC Card Configuration */
4276 [0x10c] = 0x12, /* Tuple length = 18 bytes */
4277 [0x10e] = 0xc3, /* TPCE_INDX = I/O Secondary Mode, Default */
4278 [0x110] = 0x41, /* TPCE_IF = I/O and Memory, no BVD, no WP */
4279 [0x112] = 0x99, /* TPCE_FS = Vcc only, I/O, Interrupt, Misc */
4280 [0x114] = 0x27, /* NomV = 1, MinV = 1, MaxV = 1, Peakl = 1 */
4281 [0x116] = 0x55, /* NomV: 5.0 V */
4282 [0x118] = 0x4d, /* MinV: 4.5 V */
4283 [0x11a] = 0x5d, /* MaxV: 5.5 V */
4284 [0x11c] = 0x4e, /* Peakl: 450 mA */
4285 [0x11e] = 0xea, /* TPCE_IO = 1K boundary, 16/8 access, Range */
4286 [0x120] = 0x61, /* Range: 2 fields, 2 byte addr, 1 byte len */
4287 [0x122] = 0x70, /* Field 1 address = 0x0170 */
4288 [0x124] = 0x01,
4289 [0x126] = 0x07, /* Address block length = 8 */
4290 [0x128] = 0x76, /* Field 2 address = 0x0376 */
4291 [0x12a] = 0x03,
4292 [0x12c] = 0x01, /* Address block length = 2 */
4293 [0x12e] = 0xee, /* TPCE_IR = IRQ E, Level, Pulse, Share */
4294 [0x130] = 0x20, /* TPCE_MI = support power down mode */
4295
4296 [0x132] = CISTPL_CFTABLE_ENTRY, /* 16-bit PC Card Configuration */
4297 [0x134] = 0x06, /* Tuple length = 6 bytes */
4298 [0x136] = 0x03, /* TPCE_INDX = I/O Secondary Mode */
4299 [0x138] = 0x01, /* TPCE_FS = Vcc only, no I/O, no Memory */
4300 [0x13a] = 0x21, /* NomV = 1, MinV = 0, MaxV = 0, Peakl = 1 */
4301 [0x13c] = 0xb5, /* NomV: 3.3 V */
4302 [0x13e] = 0x1e,
4303 [0x140] = 0x3e, /* Peakl: 350 mA */
4304
4305 [0x142] = CISTPL_NO_LINK, /* No Link */
4306 [0x144] = 0x00, /* Tuple length = 0 bytes */
4307
4308 [0x146] = CISTPL_END, /* Tuple End */
4309 };
4310
4311 static int dscm1xxxx_attach(void *opaque)
4312 {
4313 struct md_s *md = (struct md_s *) opaque;
4314 md->card.attr_read = md_attr_read;
4315 md->card.attr_write = md_attr_write;
4316 md->card.common_read = md_common_read;
4317 md->card.common_write = md_common_write;
4318 md->card.io_read = md_common_read;
4319 md->card.io_write = md_common_write;
4320
4321 md->attr_base = md->card.cis[0x74] | (md->card.cis[0x76] << 8);
4322 md->io_base = 0x0;
4323
4324 md_reset(md);
4325 md_interrupt_update(md);
4326
4327 md->card.slot->card_string = "DSCM-1xxxx Hitachi Microdrive";
4328 return 0;
4329 }
4330
4331 static int dscm1xxxx_detach(void *opaque)
4332 {
4333 struct md_s *md = (struct md_s *) opaque;
4334 md_reset(md);
4335 return 0;
4336 }
4337
4338 struct pcmcia_card_s *dscm1xxxx_init(BlockDriverState *bdrv)
4339 {
4340 struct md_s *md = (struct md_s *) qemu_mallocz(sizeof(struct md_s));
4341 md->card.state = md;
4342 md->card.attach = dscm1xxxx_attach;
4343 md->card.detach = dscm1xxxx_detach;
4344 md->card.cis = dscm1xxxx_cis;
4345 md->card.cis_len = sizeof(dscm1xxxx_cis);
4346
4347 ide_init2(md->ide, bdrv, 0, qemu_allocate_irqs(md_set_irq, md, 1)[0]);
4348 md->ide->is_cf = 1;
4349 md->ide->mdata_size = METADATA_SIZE;
4350 md->ide->mdata_storage = (uint8_t *) qemu_mallocz(METADATA_SIZE);
4351
4352 register_savevm("microdrive", -1, 0, md_save, md_load, md);
4353
4354 return &md->card;
4355 }
QEmu