2 * This file is part of the Palacios Virtual Machine Monitor developed
3 * by the V3VEE Project with funding from the United States National
4 * Science Foundation and the Department of Energy.
6 * The V3VEE Project is a joint project between Northwestern University
7 * and the University of New Mexico. You can find out more at
10 * Copyright (c) 2008, Jack Lange <jarusl@cs.northwestern.edu>
11 * Copyright (c) 2008, The V3VEE Project <http://www.v3vee.org>
12 * All rights reserved.
14 * Author: Jack Lange <jarusl@cs.northwestern.edu>
16 * This is free software. You are permitted to use,
17 * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
20 #define MAX_MULT_SECTORS 255
23 static void ata_identify_device(struct ide_drive * drive) {
24 struct ide_drive_id * drive_id = (struct ide_drive_id *)(drive->data_buf);
25 const char* serial_number = " VT00001\0\0\0\0\0\0\0\0\0\0\0\0";
26 const char* firmware = "ALPHA1 ";
28 drive->transfer_length = 512;
29 drive->transfer_index = 0;
32 memset(drive_id->buf, 0, sizeof(drive_id->buf));
34 drive_id->fixed_drive = 1;
35 drive_id->removable_media = 0;
38 drive_id->disk_speed1 = 1;
39 drive_id->disk_speed3 = 1;
41 drive_id->cdrom_flag = 0;
43 // Make it the simplest drive possible (1 head, 1 cyl, 1 sect/track)
44 drive_id->num_cylinders = drive->num_cylinders;
45 drive_id->num_heads = drive->num_heads;
46 drive_id->bytes_per_track = drive->num_sectors * IDE_SECTOR_SIZE;
47 drive_id->bytes_per_sector = IDE_SECTOR_SIZE;
48 drive_id->sectors_per_track = drive->num_sectors;
51 // These buffers do not contain a terminating "\0"
52 memcpy(drive_id->serial_num, serial_number, strlen(serial_number));
53 memcpy(drive_id->firmware_rev, firmware, strlen(firmware));
54 memcpy(drive_id->model_num, drive->model, 40);
57 drive_id->dword_io = 1;
61 drive_id->dma_enable = 1;
64 drive_id->lba_enable = 1;
66 // Drive Capacity (28 bit LBA)
67 drive_id->lba_capacity = drive->hd_ops->get_capacity(drive->private_data);
69 // Drive Capacity (48 bit LBA)
70 drive_id->lba_capacity_2 = drive->hd_ops->get_capacity(drive->private_data);
73 // lower byte is the maximum multiple sector size...
74 drive_id->rw_multiples = 0x8000 | MAX_MULT_SECTORS;
78 // words 64-70, 54-58 valid
79 drive_id->field_valid = 0x0007; // DMA + pkg cmd valid
82 // copied from CFA540A
83 // drive_id->buf[63] = 0x0103; // variable (DMA stuff)
84 //drive_id->buf[63] = 0x0000; // variable (DMA stuff)
85 drive_id->buf[63] = 0x0007;
88 // drive_id->buf[64] = 0x0001; // PIO
89 drive_id->buf[65] = 0x00b4;
90 drive_id->buf[66] = 0x00b4;
91 drive_id->buf[67] = 0x012c;
92 drive_id->buf[68] = 0x00b4;
94 drive_id->buf[71] = 30; // faked
95 drive_id->buf[72] = 30; // faked
97 // drive_id->buf[80] = 0x1e; // supports up to ATA/ATAPI-4
98 drive_id->major_rev_num = 0x0040; // supports up to ATA/ATAPI-6
101 drive_id->buf[83] |= 0x0400; // supports 48 bit LBA
104 drive_id->dma_ultra = 0x2020; // Ultra_DMA_Mode_5_Selected | Ultra_DMA_Mode_5_Supported;
109 static int ata_read(struct vm_device * dev, struct ide_channel * channel, uint8_t * dst, uint_t sect_cnt) {
110 struct ide_drive * drive = get_selected_drive(channel);
112 if (drive->hd_state.accessed == 0) {
113 drive->current_lba = 0;
114 drive->hd_state.accessed = 1;
117 PrintDebug("Reading Drive LBA=%d (count=%d)\n", (uint32_t)(drive->current_lba), sect_cnt);
119 int ret = drive->hd_ops->read(dst, sect_cnt, drive->current_lba, drive->private_data);
122 PrintError("IDE: Error reading HD block (LBA=%p)\n", (void *)(addr_t)(drive->current_lba));
132 static int ata_get_lba(struct vm_device * dev, struct ide_channel * channel, uint64_t * lba) {
133 struct ide_drive * drive = get_selected_drive(channel);
134 // The if the sector count == 0 then read 256 sectors (cast up to handle that value)
135 uint32_t sect_cnt = (drive->sector_count == 0) ? 256 : drive->sector_count;
140 } __attribute__((packed)) lba_addr;
143 0-8: sector number reg (drive->lba0)
144 8-16: low cylinder reg (drive->lba1)
145 16-24: high cylinder reg (drive->lba2)
146 24-28: low 4 bits of drive_head reg (channel->drive_head.head_num)
149 lba_addr.buf[0] = drive->lba0;
150 lba_addr.buf[1] = drive->lba1;
151 lba_addr.buf[2] = drive->lba2;
152 lba_addr.buf[3] = channel->drive_head.lba3;
155 if (lba_addr.addr + (sect_cnt * IDE_SECTOR_SIZE) >
156 drive->hd_ops->get_capacity(drive->private_data)) {
157 PrintError("IDE: request size exceeds disk capacity (lba=%d) (sect_cnt=%d) (ReadEnd=%d) (capacity=%p)\n",
158 lba_addr.addr, sect_cnt,
159 lba_addr.addr + (sect_cnt * IDE_SECTOR_SIZE),
160 (void *)(addr_t)(drive->hd_ops->get_capacity(drive->private_data)));
164 *lba = lba_addr.addr;
170 static int ata_read_sectors(struct vm_device * dev, struct ide_channel * channel) {
171 struct ide_drive * drive = get_selected_drive(channel);
172 // The if the sector count == 0 then read 256 sectors (cast up to handle that value)
173 uint32_t sect_cnt = (drive->sector_count == 0) ? 256 : drive->sector_count;
175 if (ata_get_lba(dev, channel, &(drive->current_lba)) == -1) {
176 ide_abort_command(dev, channel);
181 if (ata_read(dev, channel, drive->data_buf, 1) == -1) {
182 PrintError("Could not read disk sector\n");
186 drive->transfer_length = sect_cnt * IDE_SECTOR_SIZE;
187 drive->transfer_index = 0;
189 channel->status.busy = 0;
190 channel->status.ready = 0;
191 channel->status.write_fault = 0;
192 channel->status.data_req = 1;
193 channel->status.error = 0;
195 drive->irq_flags.io_dir = 1;
196 drive->irq_flags.c_d = 0;
197 drive->irq_flags.rel = 0;
200 ide_raise_irq(dev, channel);
202 PrintDebug("Returning from read sectors\n");
209 static int ata_read_sectors_ext(struct vm_device * dev, struct ide_channel * channel) {
210 //struct ide_drive * drive = get_selected_drive(channel);
211 // The if the sector count == 0 then read 256 sectors (cast up to handle that value)
212 //uint32_t sector_count = (drive->sector_count == 0) ? 256 : drive->sector_count;
214 PrintError("Extended Sector read not implemented\n");