Palacios Public Git Repository

To checkout Palacios execute

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.


fixed null memory list bug in print_shadow_map
[palacios.releases.git] / palacios / src / devices / ata.h
1 /* 
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.  
5  *
6  * The V3VEE Project is a joint project between Northwestern University
7  * and the University of New Mexico.  You can find out more at 
8  * http://www.v3vee.org
9  *
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.
13  *
14  * Author: Jack Lange <jarusl@cs.northwestern.edu>
15  *
16  * This is free software.  You are permitted to use,
17  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
18  */
19
20 #define MAX_MULT_SECTORS  255
21
22
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  ";
27
28     drive->transfer_length = 512;
29     drive->transfer_index = 0;
30
31
32     memset(drive_id->buf, 0, sizeof(drive_id->buf));
33
34     drive_id->fixed_drive = 1;
35     drive_id->removable_media = 0;
36
37     // Black magic...
38     drive_id->disk_speed1 = 1;
39     drive_id->disk_speed3 = 1;
40
41     drive_id->cdrom_flag = 0;
42
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;
49
50
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);
55
56     // 32 bits access
57     drive_id->dword_io = 1;
58
59
60     // enable DMA access
61     drive_id->dma_enable = 1;
62
63     // enable LBA access
64     drive_id->lba_enable = 1;
65     
66     // Drive Capacity (28 bit LBA)
67     drive_id->lba_capacity = drive->hd_ops->get_capacity(drive->private_data);
68     
69     // Drive Capacity (48 bit LBA)
70     drive_id->lba_capacity_2 = drive->hd_ops->get_capacity(drive->private_data);
71
72
73     // lower byte is the maximum multiple sector size...
74     drive_id->rw_multiples = 0x8000 | MAX_MULT_SECTORS;
75
76
77
78     // words 64-70, 54-58 valid
79     drive_id->field_valid = 0x0007; // DMA + pkg cmd valid
80
81
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;
86
87     
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;
93
94     drive_id->buf[71] = 30; // faked
95     drive_id->buf[72] = 30; // faked
96
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
99
100
101     drive_id->buf[83] |= 0x0400; // supports 48 bit LBA
102
103
104     drive_id->dma_ultra = 0x2020; // Ultra_DMA_Mode_5_Selected | Ultra_DMA_Mode_5_Supported;
105
106 }
107
108
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);
111
112     if (drive->hd_state.accessed == 0) {
113         drive->current_lba = 0;
114         drive->hd_state.accessed = 1;
115     }
116
117     PrintDebug("Reading Drive LBA=%d (count=%d)\n", (uint32_t)(drive->current_lba), sect_cnt);
118
119     int ret = drive->hd_ops->read(dst, sect_cnt, drive->current_lba, drive->private_data);
120     
121     if (ret == -1) {
122         PrintError("IDE: Error reading HD block (LBA=%p)\n", (void *)(addr_t)(drive->current_lba));
123         return -1;
124     }
125
126     return 0;
127 }
128
129
130 static int ata_write(struct vm_device * dev, struct ide_channel * channel, uint8_t * src, uint_t sect_cnt) {
131     struct ide_drive * drive = get_selected_drive(channel);
132
133     PrintDebug("Writing Drive LBA=%d (count=%d)\n", (uint32_t)(drive->current_lba), sect_cnt);
134
135     int ret = drive->hd_ops->write(src, sect_cnt, drive->current_lba, drive->private_data);
136
137     if (ret == -1) {
138         PrintError("IDE: Error writing HD block (LBA=%p)\n", (void *)(addr_t)(drive->current_lba));
139         return -1;
140     }
141
142     return 0;
143 }
144
145
146
147 static int ata_get_lba(struct vm_device * dev, struct ide_channel * channel, uint64_t * lba) {
148     struct ide_drive * drive = get_selected_drive(channel);
149     // The if the sector count == 0 then read 256 sectors (cast up to handle that value)
150     uint32_t sect_cnt = (drive->sector_count == 0) ? 256 : drive->sector_count;
151
152     union {
153         uint32_t addr;
154         uint8_t buf[4];
155     } __attribute__((packed)) lba_addr;
156
157     /* LBA addr bits:
158        0-8: sector number reg  (drive->lba0)
159        8-16: low cylinder reg (drive->lba1)
160        16-24: high cylinder reg (drive->lba2)
161        24-28:  low 4 bits of drive_head reg (channel->drive_head.head_num)
162      */
163
164     lba_addr.buf[0] = drive->lba0;
165     lba_addr.buf[1] = drive->lba1;
166     lba_addr.buf[2] = drive->lba2;
167     lba_addr.buf[3] = channel->drive_head.lba3;
168
169
170     if ((lba_addr.addr + sect_cnt) > 
171         drive->hd_ops->get_capacity(drive->private_data)) {
172         PrintError("IDE: request size exceeds disk capacity (lba=%d) (sect_cnt=%d) (ReadEnd=%d) (capacity=%p)\n", 
173                    lba_addr.addr, sect_cnt, 
174                    lba_addr.addr + (sect_cnt * IDE_SECTOR_SIZE),
175                    (void *)(addr_t)(drive->hd_ops->get_capacity(drive->private_data)));
176         return -1;
177     }
178
179     *lba = lba_addr.addr;
180     return 0;
181 }
182
183
184 // 28 bit LBA
185 static int ata_read_sectors(struct vm_device * dev, struct ide_channel * channel) {
186     struct ide_drive * drive = get_selected_drive(channel);
187     // The if the sector count == 0 then read 256 sectors (cast up to handle that value)
188     uint32_t sect_cnt = (drive->sector_count == 0) ? 256 : drive->sector_count;
189
190     if (ata_get_lba(dev, channel, &(drive->current_lba)) == -1) {
191         ide_abort_command(dev, channel);
192         return 0;
193     }
194
195     
196     if (ata_read(dev, channel, drive->data_buf, 1) == -1) {
197         PrintError("Could not read disk sector\n");
198         return -1;
199     }
200
201     drive->transfer_length = sect_cnt * IDE_SECTOR_SIZE;
202     drive->transfer_index = 0;
203
204     channel->status.busy = 0;
205     channel->status.ready = 0;
206     channel->status.write_fault = 0;
207     channel->status.data_req = 1;
208     channel->status.error = 0;
209
210     drive->irq_flags.io_dir = 1;
211     drive->irq_flags.c_d = 0;
212     drive->irq_flags.rel = 0;
213
214
215     ide_raise_irq(dev, channel);
216
217     PrintDebug("Returning from read sectors\n");
218
219     return 0;
220 }
221
222
223 // 48 bit LBA
224 static int ata_read_sectors_ext(struct vm_device * dev, struct ide_channel * channel) {
225     //struct ide_drive * drive = get_selected_drive(channel);
226     // The if the sector count == 0 then read 256 sectors (cast up to handle that value)
227     //uint32_t sector_count = (drive->sector_count == 0) ? 256 : drive->sector_count;
228
229     PrintError("Extended Sector read not implemented\n");
230
231     return -1;
232 }