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