[69501] | 1 | /* $Id: disk.c 98103 2023-01-17 14:15:46Z vboxsync $ */
|
---|
| 2 | /** @file
|
---|
| 3 | * PC BIOS - ???
|
---|
| 4 | */
|
---|
| 5 |
|
---|
[38699] | 6 | /*
|
---|
[98103] | 7 | * Copyright (C) 2006-2023 Oracle and/or its affiliates.
|
---|
[38699] | 8 | *
|
---|
[96407] | 9 | * This file is part of VirtualBox base platform packages, as
|
---|
| 10 | * available from https://www.virtualbox.org.
|
---|
| 11 | *
|
---|
| 12 | * This program is free software; you can redistribute it and/or
|
---|
| 13 | * modify it under the terms of the GNU General Public License
|
---|
| 14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
| 15 | * License.
|
---|
| 16 | *
|
---|
| 17 | * This program is distributed in the hope that it will be useful, but
|
---|
| 18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 20 | * General Public License for more details.
|
---|
| 21 | *
|
---|
| 22 | * You should have received a copy of the GNU General Public License
|
---|
| 23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
| 24 | *
|
---|
| 25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
[69498] | 26 | * --------------------------------------------------------------------
|
---|
[38699] | 27 | *
|
---|
| 28 | * This code is based on:
|
---|
| 29 | *
|
---|
| 30 | * ROM BIOS for use with Bochs/Plex86/QEMU emulation environment
|
---|
| 31 | *
|
---|
| 32 | * Copyright (C) 2002 MandrakeSoft S.A.
|
---|
| 33 | *
|
---|
| 34 | * MandrakeSoft S.A.
|
---|
| 35 | * 43, rue d'Aboukir
|
---|
| 36 | * 75002 Paris - France
|
---|
| 37 | * http://www.linux-mandrake.com/
|
---|
| 38 | * http://www.mandrakesoft.com/
|
---|
| 39 | *
|
---|
| 40 | * This library is free software; you can redistribute it and/or
|
---|
| 41 | * modify it under the terms of the GNU Lesser General Public
|
---|
| 42 | * License as published by the Free Software Foundation; either
|
---|
| 43 | * version 2 of the License, or (at your option) any later version.
|
---|
| 44 | *
|
---|
| 45 | * This library is distributed in the hope that it will be useful,
|
---|
| 46 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
| 47 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
| 48 | * Lesser General Public License for more details.
|
---|
| 49 | *
|
---|
| 50 | * You should have received a copy of the GNU Lesser General Public
|
---|
| 51 | * License along with this library; if not, write to the Free Software
|
---|
| 52 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
---|
| 53 | *
|
---|
| 54 | */
|
---|
| 55 |
|
---|
[69501] | 56 | /*
|
---|
| 57 | * Oracle LGPL Disclaimer: For the avoidance of doubt, except that if any license choice
|
---|
| 58 | * other than GPL or LGPL is available it will apply instead, Oracle elects to use only
|
---|
| 59 | * the Lesser General Public License version 2.1 (LGPLv2) at this time for any software where
|
---|
| 60 | * a choice of LGPL license versions is made available with the language indicating
|
---|
| 61 | * that LGPLv2 or any later version may be used, or where a choice of which version
|
---|
| 62 | * of the LGPL is applied is otherwise unspecified.
|
---|
| 63 | */
|
---|
[38699] | 64 |
|
---|
[69501] | 65 |
|
---|
[38699] | 66 | #include <stdint.h>
|
---|
| 67 | #include "biosint.h"
|
---|
| 68 | #include "inlines.h"
|
---|
| 69 | #include "ebda.h"
|
---|
| 70 | #include "ata.h"
|
---|
| 71 |
|
---|
| 72 |
|
---|
| 73 | #if DEBUG_INT13_HD
|
---|
| 74 | # define BX_DEBUG_INT13_HD(...) BX_DEBUG(__VA_ARGS__)
|
---|
| 75 | #else
|
---|
| 76 | # define BX_DEBUG_INT13_HD(...)
|
---|
| 77 | #endif
|
---|
| 78 |
|
---|
[39651] | 79 | /* Generic disk read/write routine signature. */
|
---|
[83027] | 80 | typedef int __fastcall (* dsk_rw_func)(bio_dsk_t __far *bios_dsk);
|
---|
[39651] | 81 |
|
---|
| 82 | /* Controller specific disk access routines. Declared as a union to reduce
|
---|
| 83 | * the need for conditionals when choosing between read/write functions.
|
---|
| 84 | * Note that we get away with using near pointers, which is nice.
|
---|
| 85 | */
|
---|
| 86 | typedef union {
|
---|
| 87 | struct {
|
---|
| 88 | dsk_rw_func read;
|
---|
| 89 | dsk_rw_func write;
|
---|
| 90 | } s;
|
---|
| 91 | dsk_rw_func a[2];
|
---|
| 92 | } dsk_acc_t;
|
---|
| 93 |
|
---|
| 94 | /* Pointers to HW specific disk access routines. */
|
---|
| 95 | dsk_acc_t dskacc[DSKTYP_CNT] = {
|
---|
| 96 | [DSK_TYPE_ATA] = { ata_read_sectors, ata_write_sectors },
|
---|
| 97 | #ifdef VBOX_WITH_AHCI
|
---|
| 98 | [DSK_TYPE_AHCI] = { ahci_read_sectors, ahci_write_sectors },
|
---|
| 99 | #endif
|
---|
| 100 | #ifdef VBOX_WITH_SCSI
|
---|
| 101 | [DSK_TYPE_SCSI] = { scsi_read_sectors, scsi_write_sectors },
|
---|
| 102 | #endif
|
---|
| 103 | };
|
---|
| 104 |
|
---|
| 105 |
|
---|
[63562] | 106 | /// @todo put in a header
|
---|
[38699] | 107 | #define AX r.gr.u.r16.ax
|
---|
| 108 | #define BX r.gr.u.r16.bx
|
---|
| 109 | #define CX r.gr.u.r16.cx
|
---|
| 110 | #define DX r.gr.u.r16.dx
|
---|
| 111 | #define SI r.gr.u.r16.si
|
---|
| 112 | #define DI r.gr.u.r16.di
|
---|
| 113 | #define BP r.gr.u.r16.bp
|
---|
| 114 | #define ELDX r.gr.u.r16.sp
|
---|
| 115 | #define DS r.ds
|
---|
| 116 | #define ES r.es
|
---|
| 117 | #define FLAGS r.ra.flags.u.r16.flags
|
---|
| 118 |
|
---|
[43483] | 119 |
|
---|
[48122] | 120 | /*
|
---|
[43483] | 121 | * Build translated CHS geometry given a disk size in sectors. Based on
|
---|
| 122 | * Phoenix EDD 3.0. This is used as a fallback to generate sane logical
|
---|
| 123 | * geometry in case none was provided in CMOS.
|
---|
| 124 | */
|
---|
[58724] | 125 | void set_geom_lba(chs_t __far *lgeo, uint64_t nsectors64)
|
---|
[43483] | 126 | {
|
---|
| 127 | uint32_t limit = 8257536; /* 1024 * 128 * 63 */
|
---|
[58724] | 128 | uint32_t nsectors;
|
---|
[43483] | 129 | unsigned heads = 255;
|
---|
| 130 | int i;
|
---|
[48122] | 131 |
|
---|
[58724] | 132 | nsectors = (nsectors64 >> 32) ? 0xFFFFFFFFL : (uint32_t)nsectors64;
|
---|
[43483] | 133 | /* Start with ~4GB limit, go down to 504MB. */
|
---|
| 134 | for (i = 0; i < 4; ++i) {
|
---|
| 135 | if (nsectors <= limit)
|
---|
| 136 | heads = (heads + 1) / 2;
|
---|
| 137 | limit /= 2;
|
---|
| 138 | }
|
---|
| 139 |
|
---|
| 140 | lgeo->cylinders = nsectors / (heads * 63UL);
|
---|
| 141 | if (lgeo->cylinders > 1024)
|
---|
| 142 | lgeo->cylinders = 1024;
|
---|
| 143 | lgeo->heads = heads;
|
---|
| 144 | lgeo->spt = 63; /* Always 63 sectors per track, the maximum. */
|
---|
| 145 | }
|
---|
| 146 |
|
---|
[70333] | 147 | int edd_fill_dpt(dpt_t __far *dpt, bio_dsk_t __far *bios_dsk, uint8_t device)
|
---|
| 148 | {
|
---|
| 149 | uint16_t ebda_seg = read_word(0x0040,0x000E);
|
---|
[43483] | 150 |
|
---|
[70333] | 151 | /* Check if buffer is large enough. */
|
---|
| 152 | if (dpt->size < 0x1a)
|
---|
| 153 | return -1;
|
---|
| 154 |
|
---|
| 155 | /* Fill in EDD 1.x table. */
|
---|
| 156 | if (dpt->size >= 0x1a) {
|
---|
| 157 | uint64_t lba;
|
---|
| 158 |
|
---|
| 159 | dpt->size = 0x1a;
|
---|
| 160 | dpt->blksize = bios_dsk->devices[device].blksize;
|
---|
| 161 |
|
---|
| 162 | if (bios_dsk->devices[device].device == DSK_DEVICE_CDROM) {
|
---|
| 163 | dpt->infos = 0x74; /* Removable, media change, lockable, max values */
|
---|
| 164 | dpt->cylinders = 0xffffffff;
|
---|
| 165 | dpt->heads = 0xffffffff;
|
---|
| 166 | dpt->spt = 0xffffffff;
|
---|
| 167 | dpt->sector_count1 = 0xffffffff;
|
---|
| 168 | dpt->sector_count2 = 0xffffffff;
|
---|
| 169 | } else {
|
---|
| 170 | dpt->infos = 0x02; // geometry is valid
|
---|
| 171 | dpt->cylinders = bios_dsk->devices[device].pchs.cylinders;
|
---|
| 172 | dpt->heads = bios_dsk->devices[device].pchs.heads;
|
---|
| 173 | dpt->spt = bios_dsk->devices[device].pchs.spt;
|
---|
| 174 | lba = bios_dsk->devices[device].sectors;
|
---|
| 175 | dpt->sector_count1 = lba;
|
---|
| 176 | dpt->sector_count2 = lba >> 32;
|
---|
| 177 | }
|
---|
| 178 | }
|
---|
| 179 |
|
---|
| 180 | /* Fill in EDD 2.x table. */
|
---|
| 181 | if (dpt->size >= 0x1e) {
|
---|
| 182 | uint8_t channel, irq, mode, checksum, i, xlation;
|
---|
| 183 | uint16_t iobase1, iobase2, options;
|
---|
| 184 |
|
---|
| 185 | dpt->size = 0x1e;
|
---|
| 186 | dpt->dpte_segment = ebda_seg;
|
---|
| 187 | dpt->dpte_offset = (uint16_t)&EbdaData->bdisk.dpte;
|
---|
| 188 |
|
---|
| 189 | // Fill in dpte
|
---|
| 190 | channel = device / 2;
|
---|
| 191 | iobase1 = bios_dsk->channels[channel].iobase1;
|
---|
| 192 | iobase2 = bios_dsk->channels[channel].iobase2;
|
---|
| 193 | irq = bios_dsk->channels[channel].irq;
|
---|
| 194 | mode = bios_dsk->devices[device].mode;
|
---|
| 195 | xlation = bios_dsk->devices[device].translation;
|
---|
| 196 |
|
---|
| 197 | options = (xlation == GEO_TRANSLATION_NONE ? 0 : 1 << 3); /* CHS translation */
|
---|
| 198 | options |= (1 << 4); /* LBA translation */
|
---|
| 199 | if (bios_dsk->devices[device].device == DSK_DEVICE_CDROM) {
|
---|
| 200 | options |= (1 << 5); /* Removable device */
|
---|
| 201 | options |= (1 << 6); /* ATAPI device */
|
---|
| 202 | }
|
---|
| 203 | #if VBOX_BIOS_CPU >= 80386
|
---|
| 204 | options |= (mode == ATA_MODE_PIO32 ? 1 : 0 << 7);
|
---|
| 205 | #endif
|
---|
| 206 | options |= (xlation == GEO_TRANSLATION_LBA ? 1 : 0 << 9);
|
---|
| 207 | options |= (xlation == GEO_TRANSLATION_RECHS ? 3 : 0 << 9);
|
---|
| 208 |
|
---|
| 209 | bios_dsk->dpte.iobase1 = iobase1;
|
---|
| 210 | bios_dsk->dpte.iobase2 = iobase2;
|
---|
| 211 | bios_dsk->dpte.prefix = (0xe | (device % 2)) << 4;
|
---|
| 212 | bios_dsk->dpte.unused = 0xcb;
|
---|
| 213 | bios_dsk->dpte.irq = irq;
|
---|
| 214 | bios_dsk->dpte.blkcount = 1;
|
---|
| 215 | bios_dsk->dpte.dma = 0;
|
---|
| 216 | bios_dsk->dpte.pio = 0;
|
---|
| 217 | bios_dsk->dpte.options = options;
|
---|
| 218 | bios_dsk->dpte.reserved = 0;
|
---|
| 219 | bios_dsk->dpte.revision = 0x11;
|
---|
| 220 |
|
---|
| 221 | checksum = 0;
|
---|
| 222 | for (i = 0; i < 15; ++i)
|
---|
| 223 | checksum += read_byte(ebda_seg, (uint16_t)&EbdaData->bdisk.dpte + i);
|
---|
| 224 | checksum = -checksum;
|
---|
| 225 | bios_dsk->dpte.checksum = checksum;
|
---|
| 226 | }
|
---|
| 227 |
|
---|
| 228 | /* Fill in EDD 3.x table. */
|
---|
| 229 | if (dpt->size >= 0x42) {
|
---|
| 230 | uint8_t channel, iface, checksum, i;
|
---|
| 231 | uint16_t iobase1;
|
---|
| 232 |
|
---|
| 233 | channel = device / 2;
|
---|
| 234 | iface = bios_dsk->channels[channel].iface;
|
---|
| 235 | iobase1 = bios_dsk->channels[channel].iobase1;
|
---|
| 236 |
|
---|
| 237 | dpt->size = 0x42;
|
---|
| 238 | dpt->key = 0xbedd;
|
---|
| 239 | dpt->dpi_length = 0x24;
|
---|
| 240 | dpt->reserved1 = 0;
|
---|
| 241 | dpt->reserved2 = 0;
|
---|
| 242 |
|
---|
| 243 | if (iface == ATA_IFACE_ISA) {
|
---|
| 244 | dpt->host_bus[0] = 'I';
|
---|
| 245 | dpt->host_bus[1] = 'S';
|
---|
| 246 | dpt->host_bus[2] = 'A';
|
---|
| 247 | dpt->host_bus[3] = ' ';
|
---|
| 248 | }
|
---|
| 249 | else {
|
---|
| 250 | // FIXME PCI
|
---|
| 251 | }
|
---|
| 252 | dpt->iface_type[0] = 'A';
|
---|
| 253 | dpt->iface_type[1] = 'T';
|
---|
| 254 | dpt->iface_type[2] = 'A';
|
---|
| 255 | dpt->iface_type[3] = ' ';
|
---|
| 256 | dpt->iface_type[4] = ' ';
|
---|
| 257 | dpt->iface_type[5] = ' ';
|
---|
| 258 | dpt->iface_type[6] = ' ';
|
---|
| 259 | dpt->iface_type[7] = ' ';
|
---|
| 260 |
|
---|
| 261 | if (iface == ATA_IFACE_ISA) {
|
---|
| 262 | ((uint16_t __far *)dpt->iface_path)[0] = iobase1;
|
---|
| 263 | ((uint16_t __far *)dpt->iface_path)[1] = 0;
|
---|
| 264 | ((uint32_t __far *)dpt->iface_path)[1] = 0;
|
---|
| 265 | }
|
---|
| 266 | else {
|
---|
| 267 | // FIXME PCI
|
---|
| 268 | }
|
---|
| 269 | ((uint16_t __far *)dpt->device_path)[0] = device & 1; // device % 2; @todo: correct?
|
---|
| 270 | ((uint16_t __far *)dpt->device_path)[1] = 0;
|
---|
| 271 | ((uint32_t __far *)dpt->device_path)[1] = 0;
|
---|
| 272 |
|
---|
| 273 | checksum = 0;
|
---|
| 274 | for (i = 30; i < 64; i++)
|
---|
| 275 | checksum += ((uint8_t __far *)dpt)[i];
|
---|
| 276 | checksum = -checksum;
|
---|
| 277 | dpt->checksum = checksum;
|
---|
| 278 | }
|
---|
| 279 | return 0;
|
---|
| 280 | }
|
---|
| 281 |
|
---|
[38699] | 282 | void BIOSCALL int13_harddisk(disk_regs_t r)
|
---|
| 283 | {
|
---|
[38706] | 284 | uint32_t lba;
|
---|
| 285 | uint16_t cylinder, head, sector;
|
---|
[39366] | 286 | uint16_t nlc, nlh, nlspt;
|
---|
[38706] | 287 | uint16_t count;
|
---|
| 288 | uint8_t device, status;
|
---|
[39347] | 289 | bio_dsk_t __far *bios_dsk;
|
---|
[38699] | 290 |
|
---|
| 291 | BX_DEBUG_INT13_HD("%s: AX=%04x BX=%04x CX=%04x DX=%04x ES=%04x\n", __func__, AX, BX, CX, DX, ES);
|
---|
[38706] | 292 |
|
---|
[67694] | 293 | SET_IF(); /* INT 13h always returns with interrupts enabled. */
|
---|
| 294 |
|
---|
[39347] | 295 | bios_dsk = read_word(0x0040,0x000E) :> &EbdaData->bdisk;
|
---|
[38699] | 296 | write_byte(0x0040, 0x008e, 0); // clear completion flag
|
---|
[48122] | 297 |
|
---|
[38699] | 298 | // basic check : device has to be defined
|
---|
| 299 | if ( (GET_ELDL() < 0x80) || (GET_ELDL() >= 0x80 + BX_MAX_STORAGE_DEVICES) ) {
|
---|
| 300 | BX_DEBUG("%s: function %02x, ELDL out of range %02x\n", __func__, GET_AH(), GET_ELDL());
|
---|
| 301 | goto int13_fail;
|
---|
| 302 | }
|
---|
[48122] | 303 |
|
---|
[38699] | 304 | // Get the ata channel
|
---|
[39347] | 305 | device = bios_dsk->hdidmap[GET_ELDL()-0x80];
|
---|
[48122] | 306 |
|
---|
[38699] | 307 | // basic check : device has to be valid
|
---|
| 308 | if (device >= BX_MAX_STORAGE_DEVICES) {
|
---|
| 309 | BX_DEBUG("%s: function %02x, unmapped device for ELDL=%02x\n", __func__, GET_AH(), GET_ELDL());
|
---|
| 310 | goto int13_fail;
|
---|
| 311 | }
|
---|
| 312 |
|
---|
| 313 | switch (GET_AH()) {
|
---|
| 314 |
|
---|
| 315 | case 0x00: /* disk controller reset */
|
---|
| 316 | #ifdef VBOX_WITH_SCSI
|
---|
| 317 | /* SCSI controller does not need a reset. */
|
---|
| 318 | if (!VBOX_IS_SCSI_DEVICE(device))
|
---|
| 319 | #endif
|
---|
| 320 | ata_reset (device);
|
---|
| 321 | goto int13_success;
|
---|
| 322 | break;
|
---|
| 323 |
|
---|
| 324 | case 0x01: /* read disk status */
|
---|
| 325 | status = read_byte(0x0040, 0x0074);
|
---|
| 326 | SET_AH(status);
|
---|
| 327 | SET_DISK_RET_STATUS(0);
|
---|
| 328 | /* set CF if error status read */
|
---|
| 329 | if (status) goto int13_fail_nostatus;
|
---|
| 330 | else goto int13_success_noah;
|
---|
| 331 | break;
|
---|
| 332 |
|
---|
| 333 | case 0x02: // read disk sectors
|
---|
| 334 | case 0x03: // write disk sectors
|
---|
| 335 | case 0x04: // verify disk sectors
|
---|
| 336 |
|
---|
| 337 | count = GET_AL();
|
---|
| 338 | cylinder = GET_CH();
|
---|
| 339 | cylinder |= ( ((uint16_t) GET_CL()) << 2) & 0x300;
|
---|
| 340 | sector = (GET_CL() & 0x3f);
|
---|
| 341 | head = GET_DH();
|
---|
[48122] | 342 |
|
---|
| 343 | /* Segment and offset are in ES:BX. */
|
---|
[38699] | 344 | if ( (count > 128) || (count == 0) ) {
|
---|
| 345 | BX_INFO("%s: function %02x, count out of range!\n", __func__, GET_AH());
|
---|
| 346 | goto int13_fail;
|
---|
| 347 | }
|
---|
| 348 |
|
---|
[39346] | 349 | /* Get the logical CHS geometry. */
|
---|
[39347] | 350 | nlc = bios_dsk->devices[device].lchs.cylinders;
|
---|
| 351 | nlh = bios_dsk->devices[device].lchs.heads;
|
---|
| 352 | nlspt = bios_dsk->devices[device].lchs.spt;
|
---|
[38699] | 353 |
|
---|
[39346] | 354 | /* Sanity check the geometry. */
|
---|
[38699] | 355 | if( (cylinder >= nlc) || (head >= nlh) || (sector > nlspt )) {
|
---|
| 356 | BX_INFO("%s: function %02x, disk %02x, parameters out of range %04x/%04x/%04x!\n", __func__, GET_AH(), GET_DL(), cylinder, head, sector);
|
---|
| 357 | goto int13_fail;
|
---|
| 358 | }
|
---|
[48122] | 359 |
|
---|
[38699] | 360 | // FIXME verify
|
---|
| 361 | if ( GET_AH() == 0x04 )
|
---|
| 362 | goto int13_success;
|
---|
| 363 |
|
---|
[39346] | 364 | /* If required, translate LCHS to LBA and execute command. */
|
---|
[63562] | 365 | /// @todo The IS_SCSI_DEVICE check should be redundant...
|
---|
[39366] | 366 | if (( (bios_dsk->devices[device].pchs.heads != nlh) || (bios_dsk->devices[device].pchs.spt != nlspt)) || VBOX_IS_SCSI_DEVICE(device)) {
|
---|
[38699] | 367 | lba = ((((uint32_t)cylinder * (uint32_t)nlh) + (uint32_t)head) * (uint32_t)nlspt) + (uint32_t)sector - 1;
|
---|
| 368 | sector = 0; // this forces the command to be lba
|
---|
[82980] | 369 | BX_DEBUG_INT13_HD("%s: %d sectors from lba %lu @ %04x:%04x\n", __func__,
|
---|
| 370 | count, lba, ES, BX);
|
---|
| 371 | } else {
|
---|
| 372 | BX_DEBUG_INT13_HD("%s: %d sectors from C/H/S %u/%u/%u @ %04x:%04x\n", __func__,
|
---|
| 373 | count, cylinder, head, sector, ES, BX);
|
---|
[38699] | 374 | }
|
---|
| 375 |
|
---|
[48122] | 376 |
|
---|
[39366] | 377 | /* Clear the count of transferred sectors/bytes. */
|
---|
[39355] | 378 | bios_dsk->drqp.trsfsectors = 0;
|
---|
| 379 | bios_dsk->drqp.trsfbytes = 0;
|
---|
| 380 |
|
---|
[39366] | 381 | /* Pass request information to low level disk code. */
|
---|
| 382 | bios_dsk->drqp.lba = lba;
|
---|
| 383 | bios_dsk->drqp.buffer = MK_FP(ES, BX);
|
---|
| 384 | bios_dsk->drqp.nsect = count;
|
---|
[63562] | 385 | bios_dsk->drqp.sect_sz = 512; /// @todo device specific?
|
---|
[39366] | 386 | bios_dsk->drqp.cylinder = cylinder;
|
---|
| 387 | bios_dsk->drqp.head = head;
|
---|
| 388 | bios_dsk->drqp.sector = sector;
|
---|
| 389 | bios_dsk->drqp.dev_id = device;
|
---|
| 390 |
|
---|
[39651] | 391 | status = dskacc[bios_dsk->devices[device].type].a[GET_AH() - 0x02](bios_dsk);
|
---|
[38699] | 392 |
|
---|
| 393 | // Set nb of sector transferred
|
---|
[39355] | 394 | SET_AL(bios_dsk->drqp.trsfsectors);
|
---|
[48122] | 395 |
|
---|
[38699] | 396 | if (status != 0) {
|
---|
| 397 | BX_INFO("%s: function %02x, error %02x !\n", __func__, GET_AH(), status);
|
---|
| 398 | SET_AH(0x0c);
|
---|
| 399 | goto int13_fail_noah;
|
---|
| 400 | }
|
---|
[48122] | 401 |
|
---|
[38699] | 402 | goto int13_success;
|
---|
| 403 | break;
|
---|
| 404 |
|
---|
| 405 | case 0x05: /* format disk track */
|
---|
[62095] | 406 | BX_INFO("format disk track called\n");
|
---|
| 407 | goto int13_success;
|
---|
| 408 | break;
|
---|
[38699] | 409 |
|
---|
| 410 | case 0x08: /* read disk drive parameters */
|
---|
| 411 |
|
---|
[39346] | 412 | /* Get the logical geometry from internal table. */
|
---|
[39347] | 413 | nlc = bios_dsk->devices[device].lchs.cylinders;
|
---|
| 414 | nlh = bios_dsk->devices[device].lchs.heads;
|
---|
| 415 | nlspt = bios_dsk->devices[device].lchs.spt;
|
---|
[38699] | 416 |
|
---|
[39347] | 417 | count = bios_dsk->hdcount;
|
---|
[38699] | 418 | /* Maximum cylinder number is just one less than the number of cylinders. */
|
---|
[93415] | 419 | /* To make Windows 3.1x WDCTRL.386 happy, we'd have to subtract 2, not 1,
|
---|
| 420 | * to account for a diagnostic cylinder.
|
---|
| 421 | */
|
---|
[38699] | 422 | nlc = nlc - 1; /* 0 based , last sector not used */
|
---|
| 423 | SET_AL(0);
|
---|
| 424 | SET_CH(nlc & 0xff);
|
---|
| 425 | SET_CL(((nlc >> 2) & 0xc0) | (nlspt & 0x3f));
|
---|
| 426 | SET_DH(nlh - 1);
|
---|
| 427 | SET_DL(count); /* FIXME returns 0, 1, or n hard drives */
|
---|
[48122] | 428 |
|
---|
[38699] | 429 | // FIXME should set ES & DI
|
---|
[63562] | 430 | /// @todo Actually, the above comment is nonsense.
|
---|
[48122] | 431 |
|
---|
[38699] | 432 | goto int13_success;
|
---|
| 433 | break;
|
---|
| 434 |
|
---|
| 435 | case 0x10: /* check drive ready */
|
---|
| 436 | // should look at 40:8E also???
|
---|
| 437 |
|
---|
[83027] | 438 | #ifdef VBOX_WITH_SCSI
|
---|
| 439 | /* SCSI drives are always "ready". */
|
---|
| 440 | if (!VBOX_IS_SCSI_DEVICE(device)) {
|
---|
| 441 | #endif
|
---|
[38699] | 442 | // Read the status from controller
|
---|
[39347] | 443 | status = inb(bios_dsk->channels[device/2].iobase1 + ATA_CB_STAT);
|
---|
[38699] | 444 | if ( (status & ( ATA_CB_STAT_BSY | ATA_CB_STAT_RDY )) == ATA_CB_STAT_RDY ) {
|
---|
| 445 | goto int13_success;
|
---|
| 446 | } else {
|
---|
| 447 | SET_AH(0xAA);
|
---|
| 448 | goto int13_fail_noah;
|
---|
| 449 | }
|
---|
[83027] | 450 | #ifdef VBOX_WITH_SCSI
|
---|
| 451 | } else /* It's not an ATA drive. */
|
---|
| 452 | goto int13_success;
|
---|
| 453 | #endif
|
---|
[38699] | 454 | break;
|
---|
| 455 |
|
---|
| 456 | case 0x15: /* read disk drive size */
|
---|
| 457 |
|
---|
[39346] | 458 | /* Get the physical geometry from internal table. */
|
---|
[39366] | 459 | cylinder = bios_dsk->devices[device].pchs.cylinders;
|
---|
| 460 | head = bios_dsk->devices[device].pchs.heads;
|
---|
| 461 | sector = bios_dsk->devices[device].pchs.spt;
|
---|
[38699] | 462 |
|
---|
[39346] | 463 | /* Calculate sector count seen by old style INT 13h. */
|
---|
[39366] | 464 | lba = (uint32_t)cylinder * head * sector;
|
---|
[38699] | 465 | CX = lba >> 16;
|
---|
| 466 | DX = lba & 0xffff;
|
---|
[48122] | 467 |
|
---|
[38699] | 468 | SET_AH(3); // hard disk accessible
|
---|
| 469 | goto int13_success_noah;
|
---|
| 470 | break;
|
---|
| 471 |
|
---|
| 472 | case 0x09: /* initialize drive parameters */
|
---|
| 473 | case 0x0c: /* seek to specified cylinder */
|
---|
| 474 | case 0x0d: /* alternate disk reset */
|
---|
| 475 | case 0x11: /* recalibrate */
|
---|
| 476 | case 0x14: /* controller internal diagnostic */
|
---|
| 477 | BX_INFO("%s: function %02xh unimplemented, returns success\n", __func__, GET_AH());
|
---|
| 478 | goto int13_success;
|
---|
| 479 | break;
|
---|
| 480 |
|
---|
| 481 | case 0x0a: /* read disk sectors with ECC */
|
---|
| 482 | case 0x0b: /* write disk sectors with ECC */
|
---|
| 483 | case 0x18: // set media type for format
|
---|
| 484 | default:
|
---|
| 485 | BX_INFO("%s: function %02xh unsupported, returns fail\n", __func__, GET_AH());
|
---|
| 486 | goto int13_fail;
|
---|
| 487 | break;
|
---|
| 488 | }
|
---|
| 489 |
|
---|
| 490 | int13_fail:
|
---|
| 491 | SET_AH(0x01); // defaults to invalid function in AH or invalid parameter
|
---|
| 492 | int13_fail_noah:
|
---|
| 493 | SET_DISK_RET_STATUS(GET_AH());
|
---|
| 494 | int13_fail_nostatus:
|
---|
| 495 | SET_CF(); // error occurred
|
---|
| 496 | return;
|
---|
| 497 |
|
---|
| 498 | int13_success:
|
---|
| 499 | SET_AH(0x00); // no error
|
---|
| 500 | int13_success_noah:
|
---|
| 501 | SET_DISK_RET_STATUS(0x00);
|
---|
| 502 | CLEAR_CF(); // no error
|
---|
| 503 | return;
|
---|
| 504 | }
|
---|
| 505 |
|
---|
| 506 | void BIOSCALL int13_harddisk_ext(disk_regs_t r)
|
---|
| 507 | {
|
---|
[58724] | 508 | uint64_t lba;
|
---|
[38699] | 509 | uint16_t segment, offset;
|
---|
| 510 | uint8_t device, status;
|
---|
[70333] | 511 | uint16_t count;
|
---|
[39651] | 512 | uint8_t type;
|
---|
[39347] | 513 | bio_dsk_t __far *bios_dsk;
|
---|
[38699] | 514 | int13ext_t __far *i13_ext;
|
---|
[70333] | 515 | #if 0
|
---|
| 516 | uint16_t ebda_seg = read_word(0x0040,0x000E);
|
---|
| 517 | uint16_t npc, nph, npspt;
|
---|
| 518 | uint16_t size;
|
---|
[38699] | 519 | dpt_t __far *dpt;
|
---|
[70333] | 520 | #endif
|
---|
[38699] | 521 |
|
---|
[39347] | 522 | bios_dsk = read_word(0x0040,0x000E) :> &EbdaData->bdisk;
|
---|
[38699] | 523 |
|
---|
[48122] | 524 | BX_DEBUG_INT13_HD("%s: AX=%04x BX=%04x CX=%04x DX=%04x ES=%04x DS=%04x SI=%04x\n",
|
---|
| 525 | __func__, AX, BX, CX, DX, ES, DS, SI);
|
---|
| 526 |
|
---|
[38699] | 527 | write_byte(0x0040, 0x008e, 0); // clear completion flag
|
---|
[48122] | 528 |
|
---|
[38699] | 529 | // basic check : device has to be defined
|
---|
| 530 | if ( (GET_ELDL() < 0x80) || (GET_ELDL() >= 0x80 + BX_MAX_STORAGE_DEVICES) ) {
|
---|
| 531 | BX_DEBUG("%s: function %02x, ELDL out of range %02x\n", __func__, GET_AH(), GET_ELDL());
|
---|
| 532 | goto int13x_fail;
|
---|
| 533 | }
|
---|
[48122] | 534 |
|
---|
[38699] | 535 | // Get the ata channel
|
---|
[39347] | 536 | device = bios_dsk->hdidmap[GET_ELDL()-0x80];
|
---|
[48122] | 537 |
|
---|
[38699] | 538 | // basic check : device has to be valid
|
---|
| 539 | if (device >= BX_MAX_STORAGE_DEVICES) {
|
---|
| 540 | BX_DEBUG("%s: function %02x, unmapped device for ELDL=%02x\n", __func__, GET_AH(), GET_ELDL());
|
---|
| 541 | goto int13x_fail;
|
---|
| 542 | }
|
---|
| 543 |
|
---|
| 544 | switch (GET_AH()) {
|
---|
| 545 | case 0x41: // IBM/MS installation check
|
---|
| 546 | BX=0xaa55; // install check
|
---|
| 547 | SET_AH(0x30); // EDD 3.0
|
---|
| 548 | CX=0x0007; // ext disk access and edd, removable supported
|
---|
| 549 | goto int13x_success_noah;
|
---|
| 550 | break;
|
---|
| 551 |
|
---|
| 552 | case 0x42: // IBM/MS extended read
|
---|
| 553 | case 0x43: // IBM/MS extended write
|
---|
| 554 | case 0x44: // IBM/MS verify
|
---|
| 555 | case 0x47: // IBM/MS extended seek
|
---|
| 556 |
|
---|
| 557 | /* Get a pointer to the extended structure. */
|
---|
| 558 | i13_ext = DS :> (int13ext_t *)SI;
|
---|
| 559 |
|
---|
| 560 | count = i13_ext->count;
|
---|
| 561 | segment = i13_ext->segment;
|
---|
| 562 | offset = i13_ext->offset;
|
---|
[39610] | 563 |
|
---|
[58724] | 564 | // Get 64 bits lba and check
|
---|
[38699] | 565 | lba = i13_ext->lba2;
|
---|
[58724] | 566 | lba <<= 32;
|
---|
| 567 | lba |= i13_ext->lba1;
|
---|
[48122] | 568 |
|
---|
[58724] | 569 | BX_DEBUG_INT13_HD("%s: %d sectors from LBA 0x%llx @ %04x:%04x\n", __func__,
|
---|
| 570 | count, lba, segment, offset);
|
---|
[38699] | 571 |
|
---|
[39651] | 572 | type = bios_dsk->devices[device].type;
|
---|
[39347] | 573 | if (lba >= bios_dsk->devices[device].sectors) {
|
---|
[38699] | 574 | BX_INFO("%s: function %02x. LBA out of range\n", __func__, GET_AH());
|
---|
| 575 | goto int13x_fail;
|
---|
| 576 | }
|
---|
| 577 |
|
---|
[39651] | 578 | /* Don't bother with seek or verify. */
|
---|
[38699] | 579 | if (( GET_AH() == 0x44 ) || ( GET_AH() == 0x47 ))
|
---|
| 580 | goto int13x_success;
|
---|
[39355] | 581 |
|
---|
[39366] | 582 | /* Clear the count of transferred sectors/bytes. */
|
---|
[39355] | 583 | bios_dsk->drqp.trsfsectors = 0;
|
---|
| 584 | bios_dsk->drqp.trsfbytes = 0;
|
---|
| 585 |
|
---|
[39366] | 586 | /* Pass request information to low level disk code. */
|
---|
[39560] | 587 | bios_dsk->drqp.lba = lba;
|
---|
| 588 | bios_dsk->drqp.buffer = MK_FP(segment, offset);
|
---|
| 589 | bios_dsk->drqp.nsect = count;
|
---|
[63562] | 590 | bios_dsk->drqp.sect_sz = 512; /// @todo device specific?
|
---|
[39560] | 591 | bios_dsk->drqp.sector = 0; /* Indicate LBA. */
|
---|
[39610] | 592 | bios_dsk->drqp.dev_id = device;
|
---|
[48122] | 593 |
|
---|
[39651] | 594 | /* Execute the read or write command. */
|
---|
| 595 | status = dskacc[type].a[GET_AH() - 0x42](bios_dsk);
|
---|
| 596 | count = bios_dsk->drqp.trsfsectors;
|
---|
[38699] | 597 | i13_ext->count = count;
|
---|
[48122] | 598 |
|
---|
[38699] | 599 | if (status != 0) {
|
---|
| 600 | BX_INFO("%s: function %02x, error %02x !\n", __func__, GET_AH(), status);
|
---|
| 601 | SET_AH(0x0c);
|
---|
| 602 | goto int13x_fail_noah;
|
---|
| 603 | }
|
---|
[48122] | 604 |
|
---|
[38699] | 605 | goto int13x_success;
|
---|
| 606 | break;
|
---|
| 607 |
|
---|
| 608 | case 0x45: // IBM/MS lock/unlock drive
|
---|
| 609 | case 0x49: // IBM/MS extended media change
|
---|
| 610 | goto int13x_success; // Always success for HD
|
---|
| 611 | break;
|
---|
| 612 |
|
---|
| 613 | case 0x46: // IBM/MS eject media
|
---|
| 614 | SET_AH(0xb2); // Volume Not Removable
|
---|
| 615 | goto int13x_fail_noah; // Always fail for HD
|
---|
| 616 | break;
|
---|
| 617 |
|
---|
| 618 | case 0x48: // IBM/MS get drive parameters
|
---|
[70333] | 619 | if (edd_fill_dpt(DS :> (dpt_t *)SI, bios_dsk, device))
|
---|
[38699] | 620 | goto int13x_fail;
|
---|
[70333] | 621 | else
|
---|
| 622 | goto int13x_success;
|
---|
[38699] | 623 | break;
|
---|
| 624 |
|
---|
| 625 | case 0x4e: // // IBM/MS set hardware configuration
|
---|
| 626 | // DMA, prefetch, PIO maximum not supported
|
---|
| 627 | switch (GET_AL()) {
|
---|
| 628 | case 0x01:
|
---|
| 629 | case 0x03:
|
---|
| 630 | case 0x04:
|
---|
| 631 | case 0x06:
|
---|
| 632 | goto int13x_success;
|
---|
| 633 | break;
|
---|
| 634 | default :
|
---|
| 635 | goto int13x_fail;
|
---|
| 636 | }
|
---|
| 637 | break;
|
---|
| 638 |
|
---|
| 639 | case 0x50: // IBM/MS send packet command
|
---|
| 640 | default:
|
---|
| 641 | BX_INFO("%s: function %02xh unsupported, returns fail\n", __func__, GET_AH());
|
---|
| 642 | goto int13x_fail;
|
---|
| 643 | break;
|
---|
| 644 | }
|
---|
| 645 |
|
---|
| 646 | int13x_fail:
|
---|
| 647 | SET_AH(0x01); // defaults to invalid function in AH or invalid parameter
|
---|
| 648 | int13x_fail_noah:
|
---|
| 649 | SET_DISK_RET_STATUS(GET_AH());
|
---|
| 650 | SET_CF(); // error occurred
|
---|
| 651 | return;
|
---|
| 652 |
|
---|
| 653 | int13x_success:
|
---|
| 654 | SET_AH(0x00); // no error
|
---|
| 655 | int13x_success_noah:
|
---|
| 656 | SET_DISK_RET_STATUS(0x00);
|
---|
| 657 | CLEAR_CF(); // no error
|
---|
| 658 | return;
|
---|
| 659 | }
|
---|
[39375] | 660 |
|
---|
| 661 | /* Avoid saving general registers already saved by caller (PUSHA). */
|
---|
| 662 | #pragma aux int13_harddisk modify [di si cx dx bx];
|
---|
| 663 | #pragma aux int13_harddisk_ext modify [di si cx dx bx];
|
---|
| 664 |
|
---|