]> git.proxmox.com Git - qemu.git/blame - hw/ide.c
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
preserve partition table when using -linux option
[qemu.git] / hw / ide.c
CommitLineData
5391d806
FB		 1/*
2 * QEMU IDE disk and CD-ROM Emulator
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
5391d806
FB		 24#include "vl.h"
25
5391d806
FB		 26/* debug IDE devices */
27//#define DEBUG_IDE
28//#define DEBUG_IDE_ATAPI
29
30/* Bits of HD_STATUS */
31#define ERR_STAT 0x01
32#define INDEX_STAT 0x02
33#define ECC_STAT 0x04 /* Corrected error */
34#define DRQ_STAT 0x08
35#define SEEK_STAT 0x10
36#define SRV_STAT 0x10
37#define WRERR_STAT 0x20
38#define READY_STAT 0x40
39#define BUSY_STAT 0x80
40
41/* Bits for HD_ERROR */
42#define MARK_ERR 0x01 /* Bad address mark */
43#define TRK0_ERR 0x02 /* couldn't find track 0 */
44#define ABRT_ERR 0x04 /* Command aborted */
45#define MCR_ERR 0x08 /* media change request */
46#define ID_ERR 0x10 /* ID field not found */
47#define MC_ERR 0x20 /* media changed */
48#define ECC_ERR 0x40 /* Uncorrectable ECC error */
49#define BBD_ERR 0x80 /* pre-EIDE meaning: block marked bad */
50#define ICRC_ERR 0x80 /* new meaning: CRC error during transfer */
51
52/* Bits of HD_NSECTOR */
53#define CD 0x01
54#define IO 0x02
55#define REL 0x04
56#define TAG_MASK 0xf8
57
58#define IDE_CMD_RESET 0x04
59#define IDE_CMD_DISABLE_IRQ 0x02
60
61/* ATA/ATAPI Commands pre T13 Spec */
62#define WIN_NOP 0x00
63/*
64 * 0x01->0x02 Reserved
65 */
66#define CFA_REQ_EXT_ERROR_CODE 0x03 /* CFA Request Extended Error Code */
67/*
68 * 0x04->0x07 Reserved
69 */
70#define WIN_SRST 0x08 /* ATAPI soft reset command */
71#define WIN_DEVICE_RESET 0x08
72/*
73 * 0x09->0x0F Reserved
74 */
75#define WIN_RECAL 0x10
76#define WIN_RESTORE WIN_RECAL
77/*
78 * 0x10->0x1F Reserved
79 */
80#define WIN_READ 0x20 /* 28-Bit */
81#define WIN_READ_ONCE 0x21 /* 28-Bit without retries */
82#define WIN_READ_LONG 0x22 /* 28-Bit */
83#define WIN_READ_LONG_ONCE 0x23 /* 28-Bit without retries */
84#define WIN_READ_EXT 0x24 /* 48-Bit */
85#define WIN_READDMA_EXT 0x25 /* 48-Bit */
86#define WIN_READDMA_QUEUED_EXT 0x26 /* 48-Bit */
87#define WIN_READ_NATIVE_MAX_EXT 0x27 /* 48-Bit */
88/*
89 * 0x28
90 */
91#define WIN_MULTREAD_EXT 0x29 /* 48-Bit */
92/*
93 * 0x2A->0x2F Reserved
94 */
95#define WIN_WRITE 0x30 /* 28-Bit */
96#define WIN_WRITE_ONCE 0x31 /* 28-Bit without retries */
97#define WIN_WRITE_LONG 0x32 /* 28-Bit */
98#define WIN_WRITE_LONG_ONCE 0x33 /* 28-Bit without retries */
99#define WIN_WRITE_EXT 0x34 /* 48-Bit */
100#define WIN_WRITEDMA_EXT 0x35 /* 48-Bit */
101#define WIN_WRITEDMA_QUEUED_EXT 0x36 /* 48-Bit */
102#define WIN_SET_MAX_EXT 0x37 /* 48-Bit */
103#define CFA_WRITE_SECT_WO_ERASE 0x38 /* CFA Write Sectors without erase */
104#define WIN_MULTWRITE_EXT 0x39 /* 48-Bit */
105/*
106 * 0x3A->0x3B Reserved
107 */
108#define WIN_WRITE_VERIFY 0x3C /* 28-Bit */
109/*
110 * 0x3D->0x3F Reserved
111 */
112#define WIN_VERIFY 0x40 /* 28-Bit - Read Verify Sectors */
113#define WIN_VERIFY_ONCE 0x41 /* 28-Bit - without retries */
114#define WIN_VERIFY_EXT 0x42 /* 48-Bit */
115/*
116 * 0x43->0x4F Reserved
117 */
118#define WIN_FORMAT 0x50
119/*
120 * 0x51->0x5F Reserved
121 */
122#define WIN_INIT 0x60
123/*
124 * 0x61->0x5F Reserved
125 */
126#define WIN_SEEK 0x70 /* 0x70-0x7F Reserved */
127#define CFA_TRANSLATE_SECTOR 0x87 /* CFA Translate Sector */
128#define WIN_DIAGNOSE 0x90
129#define WIN_SPECIFY 0x91 /* set drive geometry translation */
130#define WIN_DOWNLOAD_MICROCODE 0x92
131#define WIN_STANDBYNOW2 0x94
132#define WIN_STANDBY2 0x96
133#define WIN_SETIDLE2 0x97
134#define WIN_CHECKPOWERMODE2 0x98
135#define WIN_SLEEPNOW2 0x99
136/*
137 * 0x9A VENDOR
138 */
139#define WIN_PACKETCMD 0xA0 /* Send a packet command. */
140#define WIN_PIDENTIFY 0xA1 /* identify ATAPI device */
141#define WIN_QUEUED_SERVICE 0xA2
142#define WIN_SMART 0xB0 /* self-monitoring and reporting */
143#define CFA_ERASE_SECTORS 0xC0
144#define WIN_MULTREAD 0xC4 /* read sectors using multiple mode*/
145#define WIN_MULTWRITE 0xC5 /* write sectors using multiple mode */
146#define WIN_SETMULT 0xC6 /* enable/disable multiple mode */
147#define WIN_READDMA_QUEUED 0xC7 /* read sectors using Queued DMA transfers */
148#define WIN_READDMA 0xC8 /* read sectors using DMA transfers */
149#define WIN_READDMA_ONCE 0xC9 /* 28-Bit - without retries */
150#define WIN_WRITEDMA 0xCA /* write sectors using DMA transfers */
151#define WIN_WRITEDMA_ONCE 0xCB /* 28-Bit - without retries */
152#define WIN_WRITEDMA_QUEUED 0xCC /* write sectors using Queued DMA transfers */
153#define CFA_WRITE_MULTI_WO_ERASE 0xCD /* CFA Write multiple without erase */
154#define WIN_GETMEDIASTATUS 0xDA
155#define WIN_ACKMEDIACHANGE 0xDB /* ATA-1, ATA-2 vendor */
156#define WIN_POSTBOOT 0xDC
157#define WIN_PREBOOT 0xDD
158#define WIN_DOORLOCK 0xDE /* lock door on removable drives */
159#define WIN_DOORUNLOCK 0xDF /* unlock door on removable drives */
160#define WIN_STANDBYNOW1 0xE0
161#define WIN_IDLEIMMEDIATE 0xE1 /* force drive to become "ready" */
162#define WIN_STANDBY 0xE2 /* Set device in Standby Mode */
163#define WIN_SETIDLE1 0xE3
164#define WIN_READ_BUFFER 0xE4 /* force read only 1 sector */
165#define WIN_CHECKPOWERMODE1 0xE5
166#define WIN_SLEEPNOW1 0xE6
167#define WIN_FLUSH_CACHE 0xE7
168#define WIN_WRITE_BUFFER 0xE8 /* force write only 1 sector */
169#define WIN_WRITE_SAME 0xE9 /* read ata-2 to use */
170 /* SET_FEATURES 0x22 or 0xDD */
171#define WIN_FLUSH_CACHE_EXT 0xEA /* 48-Bit */
172#define WIN_IDENTIFY 0xEC /* ask drive to identify itself */
173#define WIN_MEDIAEJECT 0xED
174#define WIN_IDENTIFY_DMA 0xEE /* same as WIN_IDENTIFY, but DMA */
175#define WIN_SETFEATURES 0xEF /* set special drive features */
176#define EXABYTE_ENABLE_NEST 0xF0
177#define WIN_SECURITY_SET_PASS 0xF1
178#define WIN_SECURITY_UNLOCK 0xF2
179#define WIN_SECURITY_ERASE_PREPARE 0xF3
180#define WIN_SECURITY_ERASE_UNIT 0xF4
181#define WIN_SECURITY_FREEZE_LOCK 0xF5
182#define WIN_SECURITY_DISABLE 0xF6
183#define WIN_READ_NATIVE_MAX 0xF8 /* return the native maximum address */
184#define WIN_SET_MAX 0xF9
185#define DISABLE_SEAGATE 0xFB
186
187/* set to 1 set disable mult support */
188#define MAX_MULT_SECTORS 8
189
190/* ATAPI defines */
191
192#define ATAPI_PACKET_SIZE 12
193
194/* The generic packet command opcodes for CD/DVD Logical Units,
195 * From Table 57 of the SFF8090 Ver. 3 (Mt. Fuji) draft standard. */
196#define GPCMD_BLANK 0xa1
197#define GPCMD_CLOSE_TRACK 0x5b
198#define GPCMD_FLUSH_CACHE 0x35
199#define GPCMD_FORMAT_UNIT 0x04
200#define GPCMD_GET_CONFIGURATION 0x46
201#define GPCMD_GET_EVENT_STATUS_NOTIFICATION 0x4a
202#define GPCMD_GET_PERFORMANCE 0xac
203#define GPCMD_INQUIRY 0x12
204#define GPCMD_LOAD_UNLOAD 0xa6
205#define GPCMD_MECHANISM_STATUS 0xbd
206#define GPCMD_MODE_SELECT_10 0x55
207#define GPCMD_MODE_SENSE_10 0x5a
208#define GPCMD_PAUSE_RESUME 0x4b
209#define GPCMD_PLAY_AUDIO_10 0x45
210#define GPCMD_PLAY_AUDIO_MSF 0x47
211#define GPCMD_PLAY_AUDIO_TI 0x48
212#define GPCMD_PLAY_CD 0xbc
213#define GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL 0x1e
214#define GPCMD_READ_10 0x28
215#define GPCMD_READ_12 0xa8
216#define GPCMD_READ_CDVD_CAPACITY 0x25
217#define GPCMD_READ_CD 0xbe
218#define GPCMD_READ_CD_MSF 0xb9
219#define GPCMD_READ_DISC_INFO 0x51
220#define GPCMD_READ_DVD_STRUCTURE 0xad
221#define GPCMD_READ_FORMAT_CAPACITIES 0x23
222#define GPCMD_READ_HEADER 0x44
223#define GPCMD_READ_TRACK_RZONE_INFO 0x52
224#define GPCMD_READ_SUBCHANNEL 0x42
225#define GPCMD_READ_TOC_PMA_ATIP 0x43
226#define GPCMD_REPAIR_RZONE_TRACK 0x58
227#define GPCMD_REPORT_KEY 0xa4
228#define GPCMD_REQUEST_SENSE 0x03
229#define GPCMD_RESERVE_RZONE_TRACK 0x53
230#define GPCMD_SCAN 0xba
231#define GPCMD_SEEK 0x2b
232#define GPCMD_SEND_DVD_STRUCTURE 0xad
233#define GPCMD_SEND_EVENT 0xa2
234#define GPCMD_SEND_KEY 0xa3
235#define GPCMD_SEND_OPC 0x54
236#define GPCMD_SET_READ_AHEAD 0xa7
237#define GPCMD_SET_STREAMING 0xb6
238#define GPCMD_START_STOP_UNIT 0x1b
239#define GPCMD_STOP_PLAY_SCAN 0x4e
240#define GPCMD_TEST_UNIT_READY 0x00
241#define GPCMD_VERIFY_10 0x2f
242#define GPCMD_WRITE_10 0x2a
243#define GPCMD_WRITE_AND_VERIFY_10 0x2e
244/* This is listed as optional in ATAPI 2.6, but is (curiously)
245 * missing from Mt. Fuji, Table 57. It _is_ mentioned in Mt. Fuji
246 * Table 377 as an MMC command for SCSi devices though... Most ATAPI
247 * drives support it. */
248#define GPCMD_SET_SPEED 0xbb
249/* This seems to be a SCSI specific CD-ROM opcode
250 * to play data at track/index */
251#define GPCMD_PLAYAUDIO_TI 0x48
252/*
253 * From MS Media Status Notification Support Specification. For
254 * older drives only.
255 */
256#define GPCMD_GET_MEDIA_STATUS 0xda
257
258/* Mode page codes for mode sense/set */
259#define GPMODE_R_W_ERROR_PAGE 0x01
260#define GPMODE_WRITE_PARMS_PAGE 0x05
261#define GPMODE_AUDIO_CTL_PAGE 0x0e
262#define GPMODE_POWER_PAGE 0x1a
263#define GPMODE_FAULT_FAIL_PAGE 0x1c
264#define GPMODE_TO_PROTECT_PAGE 0x1d
265#define GPMODE_CAPABILITIES_PAGE 0x2a
266#define GPMODE_ALL_PAGES 0x3f
267/* Not in Mt. Fuji, but in ATAPI 2.6 -- depricated now in favor
268 * of MODE_SENSE_POWER_PAGE */
269#define GPMODE_CDROM_PAGE 0x0d
270
271#define ATAPI_INT_REASON_CD 0x01 /* 0 = data transfer */
272#define ATAPI_INT_REASON_IO 0x02 /* 1 = transfer to the host */
273#define ATAPI_INT_REASON_REL 0x04
274#define ATAPI_INT_REASON_TAG 0xf8
275
276/* same constants as bochs */
7f777bf3 277#define ASC_ILLEGAL_OPCODE 0x20
5391d806
FB		 278#define ASC_LOGICAL_BLOCK_OOR 0x21
279#define ASC_INV_FIELD_IN_CMD_PACKET 0x24
280#define ASC_MEDIUM_NOT_PRESENT 0x3a
281#define ASC_SAVING_PARAMETERS_NOT_SUPPORTED 0x39
282
283#define SENSE_NONE 0
284#define SENSE_NOT_READY 2
285#define SENSE_ILLEGAL_REQUEST 5
286#define SENSE_UNIT_ATTENTION 6
287
288struct IDEState;
289
290typedef void EndTransferFunc(struct IDEState *);
291
caed8802 292/* NOTE: IDEState represents in fact one drive */
5391d806
FB		 293typedef struct IDEState {
294 /* ide config */
295 int is_cdrom;
5391d806
FB		 296 int cylinders, heads, sectors;
297 int64_t nb_sectors;
298 int mult_sectors;
299 int irq;
300 /* ide regs */
301 uint8_t feature;
302 uint8_t error;
303 uint16_t nsector; /* 0 is 256 to ease computations */
304 uint8_t sector;
305 uint8_t lcyl;
306 uint8_t hcyl;
307 uint8_t select;
308 uint8_t status;
309 /* 0x3f6 command, only meaningful for drive 0 */
310 uint8_t cmd;
311 /* depends on bit 4 in select, only meaningful for drive 0 */
312 struct IDEState *cur_drive;
313 BlockDriverState *bs;
314 /* ATAPI specific */
315 uint8_t sense_key;
316 uint8_t asc;
317 int packet_transfer_size;
318 int elementary_transfer_size;
319 int io_buffer_index;
320 int lba;
321 /* transfer handling */
322 int req_nb_sectors; /* number of sectors per interrupt */
323 EndTransferFunc *end_transfer_func;
324 uint8_t *data_ptr;
325 uint8_t *data_end;
326 uint8_t io_buffer[MAX_MULT_SECTORS*512 + 4];
327} IDEState;
328
5391d806
FB		 329static void padstr(char *str, const char *src, int len)
330{
331 int i, v;
332 for(i = 0; i < len; i++) {
333 if (*src)
334 v = *src++;
335 else
336 v = ' ';
337 *(char *)((long)str ^ 1) = v;
338 str++;
339 }
340}
341
bd0d90b2
FB		 342static void padstr8(uint8_t *buf, int buf_size, const char *src)
343{
344 int i;
345 for(i = 0; i < buf_size; i++) {
346 if (*src)
347 buf[i] = *src++;
348 else
349 buf[i] = ' ';
350 }
351}
352
67b915a5
FB		 353static void put_le16(uint16_t *p, unsigned int v)
354{
355#ifdef WORDS_BIGENDIAN
356 *p = bswap16(v);
357#else
358 *p = v;
359#endif
360}
361
5391d806
FB		 362static void ide_identify(IDEState *s)
363{
364 uint16_t *p;
365 unsigned int oldsize;
366
367 memset(s->io_buffer, 0, 512);
368 p = (uint16_t *)s->io_buffer;
67b915a5
FB		 369 put_le16(p + 0, 0x0040);
370 put_le16(p + 1, s->cylinders);
371 put_le16(p + 3, s->heads);
372 put_le16(p + 4, 512 * s->sectors); /* XXX: retired, remove ? */
373 put_le16(p + 5, 512); /* XXX: retired, remove ? */
374 put_le16(p + 6, s->sectors);
5391d806 375 padstr((uint8_t *)(p + 10), "QM00001", 20); /* serial number */
67b915a5
FB		 376 put_le16(p + 20, 3); /* XXX: retired, remove ? */
377 put_le16(p + 21, 512); /* cache size in sectors */
378 put_le16(p + 22, 4); /* ecc bytes */
5391d806
FB		 379 padstr((uint8_t *)(p + 23), QEMU_VERSION, 8); /* firmware version */
380 padstr((uint8_t *)(p + 27), "QEMU HARDDISK", 40); /* model */
381#if MAX_MULT_SECTORS > 1
67b915a5 382 put_le16(p + 47, 0x8000 | MAX_MULT_SECTORS);
5391d806 383#endif
67b915a5
FB		 384 put_le16(p + 48, 1); /* dword I/O */
385 put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
386 put_le16(p + 51, 0x200); /* PIO transfer cycle */
387 put_le16(p + 52, 0x200); /* DMA transfer cycle */
388 put_le16(p + 53, 1); /* words 54-58 are valid */
389 put_le16(p + 54, s->cylinders);
390 put_le16(p + 55, s->heads);
391 put_le16(p + 56, s->sectors);
5391d806 392 oldsize = s->cylinders * s->heads * s->sectors;
67b915a5
FB		 393 put_le16(p + 57, oldsize);
394 put_le16(p + 58, oldsize >> 16);
5391d806 395 if (s->mult_sectors)
67b915a5
FB		 396 put_le16(p + 59, 0x100 | s->mult_sectors);
397 put_le16(p + 60, s->nb_sectors);
398 put_le16(p + 61, s->nb_sectors >> 16);
399 put_le16(p + 80, (1 << 1) | (1 << 2));
400 put_le16(p + 82, (1 << 14));
401 put_le16(p + 83, (1 << 14));
402 put_le16(p + 84, (1 << 14));
403 put_le16(p + 85, (1 << 14));
404 put_le16(p + 86, 0);
405 put_le16(p + 87, (1 << 14));
5391d806
FB		 406}
407
408static void ide_atapi_identify(IDEState *s)
409{
410 uint16_t *p;
411
412 memset(s->io_buffer, 0, 512);
413 p = (uint16_t *)s->io_buffer;
414 /* Removable CDROM, 50us response, 12 byte packets */
67b915a5
FB		 415 put_le16(p + 0, (2 << 14) | (5 << 8) | (1 << 7) | (2 << 5) | (0 << 0));
416 put_le16(p + 1, s->cylinders);
417 put_le16(p + 3, s->heads);
418 put_le16(p + 4, 512 * s->sectors); /* sectors */
419 put_le16(p + 5, 512); /* sector size */
420 put_le16(p + 6, s->sectors);
5391d806 421 padstr((uint8_t *)(p + 10), "QM00001", 20); /* serial number */
67b915a5
FB		 422 put_le16(p + 20, 3); /* buffer type */
423 put_le16(p + 21, 512); /* cache size in sectors */
424 put_le16(p + 22, 4); /* ecc bytes */
5391d806
FB		 425 padstr((uint8_t *)(p + 23), QEMU_VERSION, 8); /* firmware version */
426 padstr((uint8_t *)(p + 27), "QEMU CD-ROM", 40); /* model */
67b915a5
FB		 427 put_le16(p + 48, 1); /* dword I/O (XXX: should not be set on CDROM) */
428 put_le16(p + 49, 1 << 9); /* LBA supported, no DMA */
429 put_le16(p + 53, 3); /* words 64-70, 54-58 valid */
430 put_le16(p + 63, 0x103); /* DMA modes XXX: may be incorrect */
431 put_le16(p + 64, 1); /* PIO modes */
432 put_le16(p + 65, 0xb4); /* minimum DMA multiword tx cycle time */
433 put_le16(p + 66, 0xb4); /* recommended DMA multiword tx cycle time */
434 put_le16(p + 67, 0x12c); /* minimum PIO cycle time without flow control */
435 put_le16(p + 68, 0xb4); /* minimum PIO cycle time with IORDY flow control */
5391d806 436
67b915a5
FB		 437 put_le16(p + 71, 30); /* in ns */
438 put_le16(p + 72, 30); /* in ns */
5391d806 439
67b915a5 440 put_le16(p + 80, 0x1e); /* support up to ATA/ATAPI-4 */
5391d806
FB		 441}
442
443static void ide_set_signature(IDEState *s)
444{
445 s->select &= 0xf0; /* clear head */
446 /* put signature */
447 s->nsector = 1;
448 s->sector = 1;
449 if (s->is_cdrom) {
450 s->lcyl = 0x14;
451 s->hcyl = 0xeb;
452 } else if (s->bs) {
453 s->lcyl = 0;
454 s->hcyl = 0;
455 } else {
456 s->lcyl = 0xff;
457 s->hcyl = 0xff;
458 }
459}
460
461static inline void ide_abort_command(IDEState *s)
462{
463 s->status = READY_STAT | ERR_STAT;
464 s->error = ABRT_ERR;
465}
466
467static inline void ide_set_irq(IDEState *s)
468{
469 if (!(s->cmd & IDE_CMD_DISABLE_IRQ)) {
470 pic_set_irq(s->irq, 1);
471 }
472}
473
474/* prepare data transfer and tell what to do after */
475static void ide_transfer_start(IDEState *s, uint8_t *buf, int size,
476 EndTransferFunc *end_transfer_func)
477{
478 s->end_transfer_func = end_transfer_func;
479 s->data_ptr = buf;
480 s->data_end = buf + size;
481 s->status |= DRQ_STAT;
482}
483
484static void ide_transfer_stop(IDEState *s)
485{
486 s->end_transfer_func = ide_transfer_stop;
487 s->data_ptr = s->io_buffer;
488 s->data_end = s->io_buffer;
489 s->status &= ~DRQ_STAT;
490}
491
492static int64_t ide_get_sector(IDEState *s)
493{
494 int64_t sector_num;
495 if (s->select & 0x40) {
496 /* lba */
497 sector_num = ((s->select & 0x0f) << 24) | (s->hcyl << 16) |
498 (s->lcyl << 8) | s->sector;
499 } else {
500 sector_num = ((s->hcyl << 8) | s->lcyl) * s->heads * s->sectors +
501 (s->select & 0x0f) * s->sectors +
502 (s->sector - 1);
503 }
504 return sector_num;
505}
506
507static void ide_set_sector(IDEState *s, int64_t sector_num)
508{
509 unsigned int cyl, r;
510 if (s->select & 0x40) {
511 s->select = (s->select & 0xf0) | (sector_num >> 24);
512 s->hcyl = (sector_num >> 16);
513 s->lcyl = (sector_num >> 8);
514 s->sector = (sector_num);
515 } else {
516 cyl = sector_num / (s->heads * s->sectors);
517 r = sector_num % (s->heads * s->sectors);
518 s->hcyl = cyl >> 8;
519 s->lcyl = cyl;
520 s->select = (s->select & 0xf0) | (r / s->sectors);
521 s->sector = (r % s->sectors) + 1;
522 }
523}
524
525static void ide_sector_read(IDEState *s)
526{
527 int64_t sector_num;
528 int ret, n;
529
530 s->status = READY_STAT | SEEK_STAT;
a136e5a8 531 s->error = 0; /* not needed by IDE spec, but needed by Windows */
5391d806
FB		 532 sector_num = ide_get_sector(s);
533 n = s->nsector;
534 if (n == 0) {
535 /* no more sector to read from disk */
536 ide_transfer_stop(s);
537 } else {
538#if defined(DEBUG_IDE)
539 printf("read sector=%Ld\n", sector_num);
540#endif
541 if (n > s->req_nb_sectors)
542 n = s->req_nb_sectors;
543 ret = bdrv_read(s->bs, sector_num, s->io_buffer, n);
544 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_read);
545 ide_set_irq(s);
546 ide_set_sector(s, sector_num + n);
547 s->nsector -= n;
548 }
549}
550
551static void ide_sector_write(IDEState *s)
552{
553 int64_t sector_num;
554 int ret, n, n1;
555
556 s->status = READY_STAT | SEEK_STAT;
557 sector_num = ide_get_sector(s);
558#if defined(DEBUG_IDE)
559 printf("write sector=%Ld\n", sector_num);
560#endif
561 n = s->nsector;
562 if (n > s->req_nb_sectors)
563 n = s->req_nb_sectors;
564 ret = bdrv_write(s->bs, sector_num, s->io_buffer, n);
565 s->nsector -= n;
566 if (s->nsector == 0) {
567 /* no more sector to write */
568 ide_transfer_stop(s);
569 } else {
570 n1 = s->nsector;
571 if (n1 > s->req_nb_sectors)
572 n1 = s->req_nb_sectors;
573 ide_transfer_start(s, s->io_buffer, 512 * n1, ide_sector_write);
574 }
575 ide_set_sector(s, sector_num + n);
576 ide_set_irq(s);
577}
578
579static void ide_atapi_cmd_ok(IDEState *s)
580{
581 s->error = 0;
582 s->status = READY_STAT;
583 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
584 ide_set_irq(s);
585}
586
587static void ide_atapi_cmd_error(IDEState *s, int sense_key, int asc)
588{
589#ifdef DEBUG_IDE_ATAPI
590 printf("atapi_cmd_error: sense=0x%x asc=0x%x\n", sense_key, asc);
591#endif
592 s->error = sense_key << 4;
593 s->status = READY_STAT | ERR_STAT;
594 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
595 s->sense_key = sense_key;
596 s->asc = asc;
597 ide_set_irq(s);
598}
599
600static inline void cpu_to_ube16(uint8_t *buf, int val)
601{
602 buf[0] = val >> 8;
603 buf[1] = val;
604}
605
606static inline void cpu_to_ube32(uint8_t *buf, unsigned int val)
607{
608 buf[0] = val >> 24;
609 buf[1] = val >> 16;
610 buf[2] = val >> 8;
611 buf[3] = val;
612}
613
614static inline int ube16_to_cpu(const uint8_t *buf)
615{
616 return (buf[0] << 8) | buf[1];
617}
618
619static inline int ube32_to_cpu(const uint8_t *buf)
620{
621 return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
622}
623
624/* The whole ATAPI transfer logic is handled in this function */
625static void ide_atapi_cmd_reply_end(IDEState *s)
626{
627 int byte_count_limit, size;
628#ifdef DEBUG_IDE_ATAPI
629 printf("reply: tx_size=%d elem_tx_size=%d index=%d\n",
630 s->packet_transfer_size,
631 s->elementary_transfer_size,
632 s->io_buffer_index);
633#endif
634 if (s->packet_transfer_size <= 0) {
635 /* end of transfer */
636 ide_transfer_stop(s);
637 s->status = READY_STAT;
638 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO | ATAPI_INT_REASON_CD;
639 ide_set_irq(s);
640#ifdef DEBUG_IDE_ATAPI
641 printf("status=0x%x\n", s->status);
642#endif
643 } else {
644 /* see if a new sector must be read */
645 if (s->lba != -1 && s->io_buffer_index >= 2048) {
646 bdrv_read(s->bs, (int64_t)s->lba << 2, s->io_buffer, 4);
647 s->lba++;
648 s->io_buffer_index = 0;
649 }
650 if (s->elementary_transfer_size > 0) {
651 /* there are some data left to transmit in this elementary
652 transfer */
653 size = 2048 - s->io_buffer_index;
654 if (size > s->elementary_transfer_size)
655 size = s->elementary_transfer_size;
656 ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
657 size, ide_atapi_cmd_reply_end);
658 s->packet_transfer_size -= size;
659 s->elementary_transfer_size -= size;
660 s->io_buffer_index += size;
661 } else {
662 /* a new transfer is needed */
663 s->nsector = (s->nsector & ~7) | ATAPI_INT_REASON_IO;
664 byte_count_limit = s->lcyl | (s->hcyl << 8);
665#ifdef DEBUG_IDE_ATAPI
666 printf("byte_count_limit=%d\n", byte_count_limit);
667#endif
668 if (byte_count_limit == 0xffff)
669 byte_count_limit--;
670 size = s->packet_transfer_size;
671 if (size > byte_count_limit) {
672 /* byte count limit must be even if this case */
673 if (byte_count_limit & 1)
674 byte_count_limit--;
675 size = byte_count_limit;
5391d806 676 }
a136e5a8
FB		 677 s->lcyl = size;
678 s->hcyl = size >> 8;
5391d806
FB		 679 s->elementary_transfer_size = size;
680 /* we cannot transmit more than one sector at a time */
681 if (s->lba != -1) {
682 if (size > (2048 - s->io_buffer_index))
683 size = (2048 - s->io_buffer_index);
684 }
685 ide_transfer_start(s, s->io_buffer + s->io_buffer_index,
686 size, ide_atapi_cmd_reply_end);
687 s->packet_transfer_size -= size;
688 s->elementary_transfer_size -= size;
689 s->io_buffer_index += size;
690 ide_set_irq(s);
691#ifdef DEBUG_IDE_ATAPI
692 printf("status=0x%x\n", s->status);
693#endif
694 }
695 }
696}
697
698/* send a reply of 'size' bytes in s->io_buffer to an ATAPI command */
699static void ide_atapi_cmd_reply(IDEState *s, int size, int max_size)
700{
701 if (size > max_size)
702 size = max_size;
703 s->lba = -1; /* no sector read */
704 s->packet_transfer_size = size;
705 s->elementary_transfer_size = 0;
706 s->io_buffer_index = 0;
707
708 s->status = READY_STAT;
709 ide_atapi_cmd_reply_end(s);
710}
711
712/* start a CD-CDROM read command */
713static void ide_atapi_cmd_read(IDEState *s, int lba, int nb_sectors)
714{
715#ifdef DEBUG_IDE_ATAPI
716 printf("read: LBA=%d nb_sectors=%d\n", lba, nb_sectors);
717#endif
718 s->lba = lba;
719 s->packet_transfer_size = nb_sectors * 2048;
720 s->elementary_transfer_size = 0;
721 s->io_buffer_index = 2048;
722
723 s->status = READY_STAT;
724 ide_atapi_cmd_reply_end(s);
725}
726
727/* same toc as bochs. Return -1 if error or the toc length */
728static int cdrom_read_toc(IDEState *s, uint8_t *buf, int msf, int start_track)
729{
730 uint8_t *q;
731 int nb_sectors, len;
732
733 if (start_track > 1 && start_track != 0xaa)
734 return -1;
735 q = buf + 2;
736 *q++ = 1;
737 *q++ = 1;
738 if (start_track <= 1) {
739 *q++ = 0; /* reserved */
740 *q++ = 0x14; /* ADR, control */
741 *q++ = 1; /* track number */
742 *q++ = 0; /* reserved */
743 if (msf) {
744 *q++ = 0; /* reserved */
745 *q++ = 0; /* minute */
746 *q++ = 2; /* second */
747 *q++ = 0; /* frame */
748 } else {
749 /* sector 0 */
750 cpu_to_ube32(q, 0);
751 q += 4;
752 }
753 }
754 /* lead out track */
755 *q++ = 0; /* reserved */
756 *q++ = 0x16; /* ADR, control */
757 *q++ = 0xaa; /* track number */
758 *q++ = 0; /* reserved */
759 nb_sectors = s->nb_sectors >> 2;
760 if (msf) {
761 *q++ = 0; /* reserved */
762 *q++ = ((nb_sectors + 150) / 75) / 60;
763 *q++ = ((nb_sectors + 150) / 75) % 60;
764 *q++ = (nb_sectors + 150) % 75;
765 } else {
766 cpu_to_ube32(q, nb_sectors);
767 q += 4;
768 }
769 len = q - buf;
770 cpu_to_ube16(buf, len - 2);
771 return len;
772}
773
774static void ide_atapi_cmd(IDEState *s)
775{
776 const uint8_t *packet;
777 uint8_t *buf;
778 int max_len;
779
780 packet = s->io_buffer;
781 buf = s->io_buffer;
782#ifdef DEBUG_IDE_ATAPI
783 {
784 int i;
785 printf("ATAPI limit=0x%x packet:", s->lcyl | (s->hcyl << 8));
786 for(i = 0; i < ATAPI_PACKET_SIZE; i++) {
787 printf(" %02x", packet[i]);
788 }
789 printf("\n");
790 }
791#endif
792 switch(s->io_buffer[0]) {
793 case GPCMD_TEST_UNIT_READY:
caed8802 794 if (bdrv_is_inserted(s->bs)) {
5391d806
FB		 795 ide_atapi_cmd_ok(s);
796 } else {
797 ide_atapi_cmd_error(s, SENSE_NOT_READY,
798 ASC_MEDIUM_NOT_PRESENT);
799 }
800 break;
801 case GPCMD_MODE_SENSE_10:
802 {
803 int action, code;
804 max_len = ube16_to_cpu(packet + 7);
805 action = packet[2] >> 6;
806 code = packet[2] & 0x3f;
807 switch(action) {
808 case 0: /* current values */
809 switch(code) {
810 case 0x01: /* error recovery */
811 cpu_to_ube16(&buf[0], 16 + 6);
812 buf[2] = 0x70;
813 buf[3] = 0;
814 buf[4] = 0;
815 buf[5] = 0;
816 buf[6] = 0;
817 buf[7] = 0;
818
819 buf[8] = 0x01;
820 buf[9] = 0x06;
821 buf[10] = 0x00;
822 buf[11] = 0x05;
823 buf[12] = 0x00;
824 buf[13] = 0x00;
825 buf[14] = 0x00;
826 buf[15] = 0x00;
827 ide_atapi_cmd_reply(s, 16, max_len);
828 break;
829 case 0x2a:
830 cpu_to_ube16(&buf[0], 28 + 6);
831 buf[2] = 0x70;
832 buf[3] = 0;
833 buf[4] = 0;
834 buf[5] = 0;
835 buf[6] = 0;
836 buf[7] = 0;
837
838 buf[8] = 0x2a;
839 buf[9] = 0x12;
840 buf[10] = 0x00;
841 buf[11] = 0x00;
842
843 buf[12] = 0x70;
844 buf[13] = 3 << 5;
845 buf[14] = (1 << 0) | (1 << 3) | (1 << 5);
caed8802 846 if (bdrv_is_locked(s->bs))
5391d806
FB		 847 buf[6] |= 1 << 1;
848 buf[15] = 0x00;
849 cpu_to_ube16(&buf[16], 706);
850 buf[18] = 0;
851 buf[19] = 2;
852 cpu_to_ube16(&buf[20], 512);
853 cpu_to_ube16(&buf[22], 706);
854 buf[24] = 0;
855 buf[25] = 0;
856 buf[26] = 0;
857 buf[27] = 0;
858 ide_atapi_cmd_reply(s, 28, max_len);
859 break;
860 default:
861 goto error_cmd;
862 }
863 break;
864 case 1: /* changeable values */
865 goto error_cmd;
866 case 2: /* default values */
867 goto error_cmd;
868 default:
869 case 3: /* saved values */
870 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
871 ASC_SAVING_PARAMETERS_NOT_SUPPORTED);
872 break;
873 }
874 }
875 break;
876 case GPCMD_REQUEST_SENSE:
877 max_len = packet[4];
878 memset(buf, 0, 18);
879 buf[0] = 0x70 | (1 << 7);
880 buf[2] = s->sense_key;
881 buf[7] = 10;
882 buf[12] = s->asc;
883 ide_atapi_cmd_reply(s, 18, max_len);
884 break;
885 case GPCMD_PREVENT_ALLOW_MEDIUM_REMOVAL:
caed8802
FB		 886 if (bdrv_is_inserted(s->bs)) {
887 bdrv_set_locked(s->bs, packet[4] & 1);
5391d806
FB		 888 ide_atapi_cmd_ok(s);
889 } else {
890 ide_atapi_cmd_error(s, SENSE_NOT_READY,
891 ASC_MEDIUM_NOT_PRESENT);
892 }
893 break;
894 case GPCMD_READ_10:
895 case GPCMD_READ_12:
896 {
897 int nb_sectors, lba;
898
caed8802 899 if (!bdrv_is_inserted(s->bs)) {
5391d806
FB		 900 ide_atapi_cmd_error(s, SENSE_NOT_READY,
901 ASC_MEDIUM_NOT_PRESENT);
902 break;
903 }
904 if (packet[0] == GPCMD_READ_10)
905 nb_sectors = ube16_to_cpu(packet + 7);
906 else
907 nb_sectors = ube32_to_cpu(packet + 6);
908 lba = ube32_to_cpu(packet + 2);
909 if (nb_sectors == 0) {
910 ide_atapi_cmd_ok(s);
911 break;
912 }
913 if (((int64_t)(lba + nb_sectors) << 2) > s->nb_sectors) {
914 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
915 ASC_LOGICAL_BLOCK_OOR);
916 break;
917 }
918 ide_atapi_cmd_read(s, lba, nb_sectors);
919 }
920 break;
921 case GPCMD_SEEK:
922 {
923 int lba;
caed8802 924 if (!bdrv_is_inserted(s->bs)) {
5391d806
FB		 925 ide_atapi_cmd_error(s, SENSE_NOT_READY,
926 ASC_MEDIUM_NOT_PRESENT);
927 break;
928 }
929 lba = ube32_to_cpu(packet + 2);
930 if (((int64_t)lba << 2) > s->nb_sectors) {
931 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
932 ASC_LOGICAL_BLOCK_OOR);
933 break;
934 }
935 ide_atapi_cmd_ok(s);
936 }
937 break;
938 case GPCMD_START_STOP_UNIT:
939 {
940 int start, eject;
941 start = packet[4] & 1;
942 eject = (packet[4] >> 1) & 1;
943
caed8802
FB		 944 if (eject && !start) {
945 /* eject the disk */
946 bdrv_close(s->bs);
947 }
5391d806
FB		 948 ide_atapi_cmd_ok(s);
949 }
950 break;
951 case GPCMD_MECHANISM_STATUS:
952 {
953 max_len = ube16_to_cpu(packet + 8);
954 cpu_to_ube16(buf, 0);
955 /* no current LBA */
956 buf[2] = 0;
957 buf[3] = 0;
958 buf[4] = 0;
959 buf[5] = 1;
960 cpu_to_ube16(buf + 6, 0);
961 ide_atapi_cmd_reply(s, 8, max_len);
962 }
963 break;
964 case GPCMD_READ_TOC_PMA_ATIP:
965 {
966 int format, msf, start_track, len;
967
caed8802 968 if (!bdrv_is_inserted(s->bs)) {
5391d806
FB		 969 ide_atapi_cmd_error(s, SENSE_NOT_READY,
970 ASC_MEDIUM_NOT_PRESENT);
971 break;
972 }
973 max_len = ube16_to_cpu(packet + 7);
974 format = packet[9] >> 6;
975 msf = (packet[1] >> 1) & 1;
976 start_track = packet[6];
977 switch(format) {
978 case 0:
979 len = cdrom_read_toc(s, buf, msf, start_track);
980 if (len < 0)
981 goto error_cmd;
982 ide_atapi_cmd_reply(s, len, max_len);
983 break;
984 case 1:
985 /* multi session : only a single session defined */
986 memset(buf, 0, 12);
987 buf[1] = 0x0a;
988 buf[2] = 0x01;
989 buf[3] = 0x01;
990 ide_atapi_cmd_reply(s, 12, max_len);
991 break;
992 default:
7f777bf3
FB		 993 error_cmd:
994 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
995 ASC_INV_FIELD_IN_CMD_PACKET);
996 break;
5391d806
FB		 997 }
998 }
999 break;
1000 case GPCMD_READ_CDVD_CAPACITY:
caed8802 1001 if (!bdrv_is_inserted(s->bs)) {
5391d806
FB		 1002 ide_atapi_cmd_error(s, SENSE_NOT_READY,
1003 ASC_MEDIUM_NOT_PRESENT);
1004 break;
1005 }
1006 /* NOTE: it is really the number of sectors minus 1 */
1007 cpu_to_ube32(buf, (s->nb_sectors >> 2) - 1);
1008 cpu_to_ube32(buf + 4, 2048);
1009 ide_atapi_cmd_reply(s, 8, 8);
1010 break;
bd0d90b2
FB		 1011 case GPCMD_INQUIRY:
1012 max_len = packet[4];
1013 buf[0] = 0x05; /* CD-ROM */
1014 buf[1] = 0x80; /* removable */
1015 buf[2] = 0x00; /* ISO */
1016 buf[3] = 0x21; /* ATAPI-2 (XXX: put ATAPI-4 ?) */
1017 buf[4] = 31; /* additionnal length */
1018 buf[5] = 0; /* reserved */
1019 buf[6] = 0; /* reserved */
1020 buf[7] = 0; /* reserved */
1021 padstr8(buf + 8, 8, "QEMU");
1022 padstr8(buf + 16, 16, "QEMU CD-ROM");
1023 padstr8(buf + 32, 4, QEMU_VERSION);
1024 ide_atapi_cmd_reply(s, 36, max_len);
1025 break;
5391d806 1026 default:
5391d806 1027 ide_atapi_cmd_error(s, SENSE_ILLEGAL_REQUEST,
7f777bf3 1028 ASC_ILLEGAL_OPCODE);
5391d806
FB		 1029 break;
1030 }
1031}
1032
caed8802
FB		 1033/* called when the inserted state of the media has changed */
1034static void cdrom_change_cb(void *opaque)
5391d806 1035{
caed8802
FB		 1036 IDEState *s = opaque;
1037 int64_t nb_sectors;
1038
1039 /* XXX: send interrupt too */
1040 bdrv_get_geometry(s->bs, &nb_sectors);
1041 s->nb_sectors = nb_sectors;
1042}
1043
1044static void ide_ioport_write(void *opaque, uint32_t addr, uint32_t val)
1045{
1046 IDEState *ide_if = opaque;
c45c3d00 1047 IDEState *s;
5391d806
FB		 1048 int unit, n;
1049
1050#ifdef DEBUG_IDE
1051 printf("IDE: write addr=0x%x val=0x%02x\n", addr, val);
1052#endif
1053 addr &= 7;
1054 switch(addr) {
1055 case 0:
1056 break;
1057 case 1:
c45c3d00
FB		 1058 /* NOTE: data is written to the two drives */
1059 ide_if[0].feature = val;
1060 ide_if[1].feature = val;
5391d806
FB		 1061 break;
1062 case 2:
1063 if (val == 0)
1064 val = 256;
c45c3d00
FB		 1065 ide_if[0].nsector = val;
1066 ide_if[1].nsector = val;
5391d806
FB		 1067 break;
1068 case 3:
c45c3d00
FB		 1069 ide_if[0].sector = val;
1070 ide_if[1].sector = val;
5391d806
FB		 1071 break;
1072 case 4:
c45c3d00
FB		 1073 ide_if[0].lcyl = val;
1074 ide_if[1].lcyl = val;
5391d806
FB		 1075 break;
1076 case 5:
c45c3d00
FB		 1077 ide_if[0].hcyl = val;
1078 ide_if[1].hcyl = val;
5391d806
FB		 1079 break;
1080 case 6:
c45c3d00
FB		 1081 ide_if[0].select = val & 0x4f;
1082 ide_if[1].select = val & 0x4f;
5391d806
FB		 1083 /* select drive */
1084 unit = (val >> 4) & 1;
1085 s = ide_if + unit;
1086 ide_if->cur_drive = s;
5391d806
FB		 1087 break;
1088 default:
1089 case 7:
1090 /* command */
1091#if defined(DEBUG_IDE)
1092 printf("ide: CMD=%02x\n", val);
1093#endif
c45c3d00 1094 s = ide_if->cur_drive;
5391d806
FB		 1095 switch(val) {
1096 case WIN_IDENTIFY:
1097 if (s->bs && !s->is_cdrom) {
1098 ide_identify(s);
1099 s->status = READY_STAT;
1100 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1101 } else {
1102 if (s->is_cdrom) {
1103 ide_set_signature(s);
1104 }
1105 ide_abort_command(s);
1106 }
1107 ide_set_irq(s);
1108 break;
1109 case WIN_SPECIFY:
1110 case WIN_RECAL:
a136e5a8 1111 s->error = 0;
5391d806
FB		 1112 s->status = READY_STAT;
1113 ide_set_irq(s);
1114 break;
1115 case WIN_SETMULT:
1116 if (s->nsector > MAX_MULT_SECTORS ||
1117 s->nsector == 0 ||
1118 (s->nsector & (s->nsector - 1)) != 0) {
1119 ide_abort_command(s);
1120 } else {
1121 s->mult_sectors = s->nsector;
1122 s->status = READY_STAT;
1123 }
1124 ide_set_irq(s);
1125 break;
4ce900b4
FB		 1126 case WIN_VERIFY:
1127 case WIN_VERIFY_ONCE:
1128 /* do sector number check ? */
1129 s->status = READY_STAT;
1130 ide_set_irq(s);
1131 break;
5391d806
FB		 1132 case WIN_READ:
1133 case WIN_READ_ONCE:
6b136f9e
FB		 1134 if (!s->bs)
1135 goto abort_cmd;
5391d806
FB		 1136 s->req_nb_sectors = 1;
1137 ide_sector_read(s);
1138 break;
1139 case WIN_WRITE:
1140 case WIN_WRITE_ONCE:
a136e5a8 1141 s->error = 0;
5391d806
FB		 1142 s->status = SEEK_STAT;
1143 s->req_nb_sectors = 1;
1144 ide_transfer_start(s, s->io_buffer, 512, ide_sector_write);
1145 break;
1146 case WIN_MULTREAD:
1147 if (!s->mult_sectors)
1148 goto abort_cmd;
1149 s->req_nb_sectors = s->mult_sectors;
1150 ide_sector_read(s);
1151 break;
1152 case WIN_MULTWRITE:
1153 if (!s->mult_sectors)
1154 goto abort_cmd;
a136e5a8 1155 s->error = 0;
5391d806
FB		 1156 s->status = SEEK_STAT;
1157 s->req_nb_sectors = s->mult_sectors;
1158 n = s->nsector;
1159 if (n > s->req_nb_sectors)
1160 n = s->req_nb_sectors;
1161 ide_transfer_start(s, s->io_buffer, 512 * n, ide_sector_write);
1162 break;
1163 case WIN_READ_NATIVE_MAX:
1164 ide_set_sector(s, s->nb_sectors - 1);
1165 s->status = READY_STAT;
1166 ide_set_irq(s);
1167 break;
a136e5a8
FB		 1168 case WIN_CHECKPOWERMODE1:
1169 s->nsector = 0xff; /* device active or idle */
1170 s->status = READY_STAT;
1171 ide_set_irq(s);
1172 break;
5391d806
FB		 1173
1174 /* ATAPI commands */
1175 case WIN_PIDENTIFY:
1176 if (s->is_cdrom) {
1177 ide_atapi_identify(s);
1178 s->status = READY_STAT;
1179 ide_transfer_start(s, s->io_buffer, 512, ide_transfer_stop);
1180 } else {
1181 ide_abort_command(s);
1182 }
1183 ide_set_irq(s);
1184 break;
1185 case WIN_SRST:
1186 if (!s->is_cdrom)
1187 goto abort_cmd;
1188 ide_set_signature(s);
6b136f9e 1189 s->status = 0x00; /* NOTE: READY is _not_ set */
5391d806
FB		 1190 s->error = 0x01;
1191 break;
1192 case WIN_PACKETCMD:
1193 if (!s->is_cdrom)
1194 goto abort_cmd;
1195 /* DMA or overlapping commands not supported */
1196 if ((s->feature & 0x03) != 0)
1197 goto abort_cmd;
1198 s->nsector = 1;
1199 ide_transfer_start(s, s->io_buffer, ATAPI_PACKET_SIZE,
1200 ide_atapi_cmd);
1201 break;
1202 default:
1203 abort_cmd:
1204 ide_abort_command(s);
1205 ide_set_irq(s);
1206 break;
1207 }
1208 }
1209}
1210
caed8802 1211static uint32_t ide_ioport_read(void *opaque, uint32_t addr1)
5391d806 1212{
caed8802 1213 IDEState *s = ((IDEState *)opaque)->cur_drive;
5391d806
FB		 1214 uint32_t addr;
1215 int ret;
1216
1217 addr = addr1 & 7;
1218 switch(addr) {
1219 case 0:
1220 ret = 0xff;
1221 break;
1222 case 1:
c45c3d00
FB		 1223 if (!s->bs)
1224 ret = 0;
1225 else
1226 ret = s->error;
5391d806
FB		 1227 break;
1228 case 2:
c45c3d00
FB		 1229 if (!s->bs)
1230 ret = 0;
1231 else
1232 ret = s->nsector & 0xff;
5391d806
FB		 1233 break;
1234 case 3:
c45c3d00
FB		 1235 if (!s->bs)
1236 ret = 0;
1237 else
1238 ret = s->sector;
5391d806
FB		 1239 break;
1240 case 4:
c45c3d00
FB		 1241 if (!s->bs)
1242 ret = 0;
1243 else
1244 ret = s->lcyl;
5391d806
FB		 1245 break;
1246 case 5:
c45c3d00
FB		 1247 if (!s->bs)
1248 ret = 0;
1249 else
1250 ret = s->hcyl;
5391d806
FB		 1251 break;
1252 case 6:
c45c3d00
FB		 1253 if (!s->bs)
1254 ret = 0;
1255 else
78ebca6e 1256 ret = s->select | 0xa0;
5391d806
FB		 1257 break;
1258 default:
1259 case 7:
c45c3d00
FB		 1260 if (!s->bs)
1261 ret = 0;
1262 else
1263 ret = s->status;
5391d806
FB		 1264 pic_set_irq(s->irq, 0);
1265 break;
1266 }
1267#ifdef DEBUG_IDE
1268 printf("ide: read addr=0x%x val=%02x\n", addr1, ret);
1269#endif
1270 return ret;
1271}
1272
caed8802 1273static uint32_t ide_status_read(void *opaque, uint32_t addr)
5391d806 1274{
caed8802 1275 IDEState *s = ((IDEState *)opaque)->cur_drive;
5391d806
FB		 1276 int ret;
1277 ret = s->status;
1278#ifdef DEBUG_IDE
1279 printf("ide: read status addr=0x%x val=%02x\n", addr, ret);
1280#endif
1281 return ret;
1282}
1283
caed8802 1284static void ide_cmd_write(void *opaque, uint32_t addr, uint32_t val)
5391d806 1285{
caed8802 1286 IDEState *ide_if = opaque;
5391d806
FB		 1287 IDEState *s;
1288 int i;
1289
1290#ifdef DEBUG_IDE
1291 printf("ide: write control addr=0x%x val=%02x\n", addr, val);
1292#endif
1293 /* common for both drives */
1294 if (!(ide_if[0].cmd & IDE_CMD_RESET) &&
1295 (val & IDE_CMD_RESET)) {
1296 /* reset low to high */
1297 for(i = 0;i < 2; i++) {
1298 s = &ide_if[i];
1299 s->status = BUSY_STAT | SEEK_STAT;
1300 s->error = 0x01;
1301 }
1302 } else if ((ide_if[0].cmd & IDE_CMD_RESET) &&
1303 !(val & IDE_CMD_RESET)) {
1304 /* high to low */
1305 for(i = 0;i < 2; i++) {
1306 s = &ide_if[i];
6b136f9e
FB		 1307 if (s->is_cdrom)
1308 s->status = 0x00; /* NOTE: READY is _not_ set */
1309 else
56bf1d37 1310 s->status = READY_STAT | SEEK_STAT;
5391d806
FB		 1311 ide_set_signature(s);
1312 }
1313 }
1314
1315 ide_if[0].cmd = val;
1316 ide_if[1].cmd = val;
1317}
1318
caed8802 1319static void ide_data_writew(void *opaque, uint32_t addr, uint32_t val)
5391d806 1320{
caed8802 1321 IDEState *s = ((IDEState *)opaque)->cur_drive;
5391d806
FB		 1322 uint8_t *p;
1323
1324 p = s->data_ptr;
1325 *(uint16_t *)p = tswap16(val);
1326 p += 2;
1327 s->data_ptr = p;
1328 if (p >= s->data_end)
1329 s->end_transfer_func(s);
1330}
1331
caed8802 1332static uint32_t ide_data_readw(void *opaque, uint32_t addr)
5391d806 1333{
caed8802 1334 IDEState *s = ((IDEState *)opaque)->cur_drive;
5391d806
FB		 1335 uint8_t *p;
1336 int ret;
1337 p = s->data_ptr;
1338 ret = tswap16(*(uint16_t *)p);
1339 p += 2;
1340 s->data_ptr = p;
1341 if (p >= s->data_end)
1342 s->end_transfer_func(s);
1343 return ret;
1344}
1345
caed8802 1346static void ide_data_writel(void *opaque, uint32_t addr, uint32_t val)
5391d806 1347{
caed8802 1348 IDEState *s = ((IDEState *)opaque)->cur_drive;
5391d806
FB		 1349 uint8_t *p;
1350
1351 p = s->data_ptr;
1352 *(uint32_t *)p = tswap32(val);
1353 p += 4;
1354 s->data_ptr = p;
1355 if (p >= s->data_end)
1356 s->end_transfer_func(s);
1357}
1358
caed8802 1359static uint32_t ide_data_readl(void *opaque, uint32_t addr)
5391d806 1360{
caed8802 1361 IDEState *s = ((IDEState *)opaque)->cur_drive;
5391d806
FB		 1362 uint8_t *p;
1363 int ret;
1364
1365 p = s->data_ptr;
1366 ret = tswap32(*(uint32_t *)p);
1367 p += 4;
1368 s->data_ptr = p;
1369 if (p >= s->data_end)
1370 s->end_transfer_func(s);
1371 return ret;
1372}
1373
1374static void ide_reset(IDEState *s)
1375{
1376 s->mult_sectors = MAX_MULT_SECTORS;
1377 s->cur_drive = s;
1378 s->select = 0xa0;
1379 s->status = READY_STAT;
1380 ide_set_signature(s);
1381}
1382
1383struct partition {
1384 uint8_t boot_ind; /* 0x80 - active */
1385 uint8_t head; /* starting head */
1386 uint8_t sector; /* starting sector */
1387 uint8_t cyl; /* starting cylinder */
1388 uint8_t sys_ind; /* What partition type */
1389 uint8_t end_head; /* end head */
1390 uint8_t end_sector; /* end sector */
1391 uint8_t end_cyl; /* end cylinder */
1392 uint32_t start_sect; /* starting sector counting from 0 */
1393 uint32_t nr_sects; /* nr of sectors in partition */
1394} __attribute__((packed));
1395
1396/* try to guess the IDE geometry from the MSDOS partition table */
1397static void ide_guess_geometry(IDEState *s)
1398{
1399 uint8_t buf[512];
1400 int ret, i;
1401 struct partition *p;
1402 uint32_t nr_sects;
1403
1404 if (s->cylinders != 0)
1405 return;
1406 ret = bdrv_read(s->bs, 0, buf, 1);
1407 if (ret < 0)
1408 return;
1409 /* test msdos magic */
1410 if (buf[510] != 0x55 || buf[511] != 0xaa)
1411 return;
1412 for(i = 0; i < 4; i++) {
1413 p = ((struct partition *)(buf + 0x1be)) + i;
1414 nr_sects = tswap32(p->nr_sects);
1415 if (nr_sects && p->end_head) {
1416 /* We make the assumption that the partition terminates on
1417 a cylinder boundary */
1418 s->heads = p->end_head + 1;
1419 s->sectors = p->end_sector & 63;
1420 s->cylinders = s->nb_sectors / (s->heads * s->sectors);
1421#if 0
1422 printf("guessed partition: CHS=%d %d %d\n",
1423 s->cylinders, s->heads, s->sectors);
1424#endif
1425 }
1426 }
1427}
1428
caed8802
FB		 1429void ide_init(int iobase, int iobase2, int irq,
1430 BlockDriverState *hd0, BlockDriverState *hd1)
5391d806 1431{
caed8802
FB		 1432 IDEState *s, *ide_state;
1433 int i, cylinders, heads, secs;
5391d806 1434 int64_t nb_sectors;
5391d806 1435
caed8802
FB		 1436 ide_state = qemu_mallocz(sizeof(IDEState) * 2);
1437 if (!ide_state)
1438 return;
1439
1440 for(i = 0; i < 2; i++) {
1441 s = ide_state + i;
1442 if (i == 0)
1443 s->bs = hd0;
1444 else
1445 s->bs = hd1;
5391d806
FB		 1446 if (s->bs) {
1447 bdrv_get_geometry(s->bs, &nb_sectors);
1448 s->nb_sectors = nb_sectors;
caed8802
FB		 1449 /* if a geometry hint is available, use it */
1450 bdrv_get_geometry_hint(s->bs, &cylinders, &heads, &secs);
1451 if (cylinders != 0) {
5391d806 1452 s->cylinders = cylinders;
caed8802
FB		 1453 s->heads = heads;
1454 s->sectors = secs;
1455 } else {
1456 ide_guess_geometry(s);
1457 if (s->cylinders == 0) {
1458 /* if no geometry, use a LBA compatible one */
1459 cylinders = nb_sectors / (16 * 63);
1460 if (cylinders > 16383)
1461 cylinders = 16383;
1462 else if (cylinders < 2)
1463 cylinders = 2;
1464 s->cylinders = cylinders;
1465 s->heads = 16;
1466 s->sectors = 63;
1467 }
1468 }
1469 if (bdrv_get_type_hint(s->bs) == BDRV_TYPE_CDROM) {
1470 s->is_cdrom = 1;
1471 bdrv_set_change_cb(s->bs, cdrom_change_cb, s);
5391d806
FB		 1472 }
1473 }
caed8802 1474 s->irq = irq;
5391d806
FB		 1475 ide_reset(s);
1476 }
caed8802
FB		 1477 register_ioport_write(iobase, 8, 1, ide_ioport_write, ide_state);
1478 register_ioport_read(iobase, 8, 1, ide_ioport_read, ide_state);
1479 if (iobase2) {
1480 register_ioport_read(iobase2, 1, 1, ide_status_read, ide_state);
1481 register_ioport_write(iobase2, 1, 1, ide_cmd_write, ide_state);
5391d806 1482 }
caed8802
FB		 1483
1484 /* data ports */
1485 register_ioport_write(iobase, 2, 2, ide_data_writew, ide_state);
1486 register_ioport_read(iobase, 2, 2, ide_data_readw, ide_state);
1487 register_ioport_write(iobase, 4, 4, ide_data_writel, ide_state);
1488 register_ioport_read(iobase, 4, 4, ide_data_readl, ide_state);
5391d806 1489}
Qemu copy for testing