VirtualBox

source: vbox/trunk/src/VBox/Devices/PC/BIOS/disk.c@ 98103

Last change on this file since 98103 was 98103, checked in by vboxsync, 16 months ago

Copyright year updates by scm.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 21.7 KB
Line 
1/* $Id: disk.c 98103 2023-01-17 14:15:46Z vboxsync $ */
2/** @file
3 * PC BIOS - ???
4 */
5
6/*
7 * Copyright (C) 2006-2023 Oracle and/or its affiliates.
8 *
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
26 * --------------------------------------------------------------------
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
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 */
64
65
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
79/* Generic disk read/write routine signature. */
80typedef int __fastcall (* dsk_rw_func)(bio_dsk_t __far *bios_dsk);
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 */
86typedef 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. */
95dsk_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
106/// @todo put in a header
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
119
120/*
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 */
125void set_geom_lba(chs_t __far *lgeo, uint64_t nsectors64)
126{
127 uint32_t limit = 8257536; /* 1024 * 128 * 63 */
128 uint32_t nsectors;
129 unsigned heads = 255;
130 int i;
131
132 nsectors = (nsectors64 >> 32) ? 0xFFFFFFFFL : (uint32_t)nsectors64;
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
147int 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);
150
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
282void BIOSCALL int13_harddisk(disk_regs_t r)
283{
284 uint32_t lba;
285 uint16_t cylinder, head, sector;
286 uint16_t nlc, nlh, nlspt;
287 uint16_t count;
288 uint8_t device, status;
289 bio_dsk_t __far *bios_dsk;
290
291 BX_DEBUG_INT13_HD("%s: AX=%04x BX=%04x CX=%04x DX=%04x ES=%04x\n", __func__, AX, BX, CX, DX, ES);
292
293 SET_IF(); /* INT 13h always returns with interrupts enabled. */
294
295 bios_dsk = read_word(0x0040,0x000E) :> &EbdaData->bdisk;
296 write_byte(0x0040, 0x008e, 0); // clear completion flag
297
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 }
303
304 // Get the ata channel
305 device = bios_dsk->hdidmap[GET_ELDL()-0x80];
306
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();
342
343 /* Segment and offset are in ES:BX. */
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
349 /* Get the logical CHS geometry. */
350 nlc = bios_dsk->devices[device].lchs.cylinders;
351 nlh = bios_dsk->devices[device].lchs.heads;
352 nlspt = bios_dsk->devices[device].lchs.spt;
353
354 /* Sanity check the geometry. */
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 }
359
360 // FIXME verify
361 if ( GET_AH() == 0x04 )
362 goto int13_success;
363
364 /* If required, translate LCHS to LBA and execute command. */
365 /// @todo The IS_SCSI_DEVICE check should be redundant...
366 if (( (bios_dsk->devices[device].pchs.heads != nlh) || (bios_dsk->devices[device].pchs.spt != nlspt)) || VBOX_IS_SCSI_DEVICE(device)) {
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
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);
374 }
375
376
377 /* Clear the count of transferred sectors/bytes. */
378 bios_dsk->drqp.trsfsectors = 0;
379 bios_dsk->drqp.trsfbytes = 0;
380
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;
385 bios_dsk->drqp.sect_sz = 512; /// @todo device specific?
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
391 status = dskacc[bios_dsk->devices[device].type].a[GET_AH() - 0x02](bios_dsk);
392
393 // Set nb of sector transferred
394 SET_AL(bios_dsk->drqp.trsfsectors);
395
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 }
401
402 goto int13_success;
403 break;
404
405 case 0x05: /* format disk track */
406 BX_INFO("format disk track called\n");
407 goto int13_success;
408 break;
409
410 case 0x08: /* read disk drive parameters */
411
412 /* Get the logical geometry from internal table. */
413 nlc = bios_dsk->devices[device].lchs.cylinders;
414 nlh = bios_dsk->devices[device].lchs.heads;
415 nlspt = bios_dsk->devices[device].lchs.spt;
416
417 count = bios_dsk->hdcount;
418 /* Maximum cylinder number is just one less than the number of cylinders. */
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 */
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 */
428
429 // FIXME should set ES & DI
430 /// @todo Actually, the above comment is nonsense.
431
432 goto int13_success;
433 break;
434
435 case 0x10: /* check drive ready */
436 // should look at 40:8E also???
437
438#ifdef VBOX_WITH_SCSI
439 /* SCSI drives are always "ready". */
440 if (!VBOX_IS_SCSI_DEVICE(device)) {
441#endif
442 // Read the status from controller
443 status = inb(bios_dsk->channels[device/2].iobase1 + ATA_CB_STAT);
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 }
450#ifdef VBOX_WITH_SCSI
451 } else /* It's not an ATA drive. */
452 goto int13_success;
453#endif
454 break;
455
456 case 0x15: /* read disk drive size */
457
458 /* Get the physical geometry from internal table. */
459 cylinder = bios_dsk->devices[device].pchs.cylinders;
460 head = bios_dsk->devices[device].pchs.heads;
461 sector = bios_dsk->devices[device].pchs.spt;
462
463 /* Calculate sector count seen by old style INT 13h. */
464 lba = (uint32_t)cylinder * head * sector;
465 CX = lba >> 16;
466 DX = lba & 0xffff;
467
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
490int13_fail:
491 SET_AH(0x01); // defaults to invalid function in AH or invalid parameter
492int13_fail_noah:
493 SET_DISK_RET_STATUS(GET_AH());
494int13_fail_nostatus:
495 SET_CF(); // error occurred
496 return;
497
498int13_success:
499 SET_AH(0x00); // no error
500int13_success_noah:
501 SET_DISK_RET_STATUS(0x00);
502 CLEAR_CF(); // no error
503 return;
504}
505
506void BIOSCALL int13_harddisk_ext(disk_regs_t r)
507{
508 uint64_t lba;
509 uint16_t segment, offset;
510 uint8_t device, status;
511 uint16_t count;
512 uint8_t type;
513 bio_dsk_t __far *bios_dsk;
514 int13ext_t __far *i13_ext;
515#if 0
516 uint16_t ebda_seg = read_word(0x0040,0x000E);
517 uint16_t npc, nph, npspt;
518 uint16_t size;
519 dpt_t __far *dpt;
520#endif
521
522 bios_dsk = read_word(0x0040,0x000E) :> &EbdaData->bdisk;
523
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
527 write_byte(0x0040, 0x008e, 0); // clear completion flag
528
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 }
534
535 // Get the ata channel
536 device = bios_dsk->hdidmap[GET_ELDL()-0x80];
537
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;
563
564 // Get 64 bits lba and check
565 lba = i13_ext->lba2;
566 lba <<= 32;
567 lba |= i13_ext->lba1;
568
569 BX_DEBUG_INT13_HD("%s: %d sectors from LBA 0x%llx @ %04x:%04x\n", __func__,
570 count, lba, segment, offset);
571
572 type = bios_dsk->devices[device].type;
573 if (lba >= bios_dsk->devices[device].sectors) {
574 BX_INFO("%s: function %02x. LBA out of range\n", __func__, GET_AH());
575 goto int13x_fail;
576 }
577
578 /* Don't bother with seek or verify. */
579 if (( GET_AH() == 0x44 ) || ( GET_AH() == 0x47 ))
580 goto int13x_success;
581
582 /* Clear the count of transferred sectors/bytes. */
583 bios_dsk->drqp.trsfsectors = 0;
584 bios_dsk->drqp.trsfbytes = 0;
585
586 /* Pass request information to low level disk code. */
587 bios_dsk->drqp.lba = lba;
588 bios_dsk->drqp.buffer = MK_FP(segment, offset);
589 bios_dsk->drqp.nsect = count;
590 bios_dsk->drqp.sect_sz = 512; /// @todo device specific?
591 bios_dsk->drqp.sector = 0; /* Indicate LBA. */
592 bios_dsk->drqp.dev_id = device;
593
594 /* Execute the read or write command. */
595 status = dskacc[type].a[GET_AH() - 0x42](bios_dsk);
596 count = bios_dsk->drqp.trsfsectors;
597 i13_ext->count = count;
598
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 }
604
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
619 if (edd_fill_dpt(DS :> (dpt_t *)SI, bios_dsk, device))
620 goto int13x_fail;
621 else
622 goto int13x_success;
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
646int13x_fail:
647 SET_AH(0x01); // defaults to invalid function in AH or invalid parameter
648int13x_fail_noah:
649 SET_DISK_RET_STATUS(GET_AH());
650 SET_CF(); // error occurred
651 return;
652
653int13x_success:
654 SET_AH(0x00); // no error
655int13x_success_noah:
656 SET_DISK_RET_STATUS(0x00);
657 CLEAR_CF(); // no error
658 return;
659}
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
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use