0ceada986751c3e1422e19ab769086092b1a6a84
[reactos.git] / reactos / subsystems / mvdm / ntvdm / bios / bios32 / dskbios32.c
1 /*
2 * COPYRIGHT: GPL - See COPYING in the top level directory
3 * PROJECT: ReactOS Virtual DOS Machine
4 * FILE: dskbios32.c
5 * PURPOSE: VDM 32-bit Disk BIOS
6 * PROGRAMMERS: Hermes Belusca-Maito (hermes.belusca@sfr.fr)
7 */
8
9 /* INCLUDES *******************************************************************/
10
11 #define NDEBUG
12
13 #include "ntvdm.h"
14 #include "emulator.h"
15 // #include "../../memory.h"
16 // #include "cpu/bop.h"
17 #include "cpu/cpu.h" // for EMULATOR_FLAG_ZF
18 #include "int32.h"
19
20 #include "dskbios32.h"
21 // #include <bios/dskbios.h>
22 #include "bios32p.h"
23
24 #include "hardware/disk.h"
25
26
27 /* DEFINES ********************************************************************/
28
29 // Disks which are currently supported by the BIOS Disk module.
30 // NOTE: For the current implementation those are arrays of pointers to
31 // DISK_IMAGEs maintained by the Generic Disk Controller. In the future
32 // they will be arrays of objects containing disk information needed by
33 // the BIOS only.
34 static PDISK_IMAGE FloppyDrive[2] = {NULL};
35 static PDISK_IMAGE HardDrive[1] = {NULL};
36
37 #pragma pack(push, 1)
38
39 // See: http://www.ctyme.com/intr/rb-2445.htm
40 typedef struct _FLOPPY_PARAM_TABLE
41 {
42 BYTE Unused0;
43 BYTE Unused1;
44 BYTE MotorOffDelay;
45 BYTE SectorSize;
46 BYTE SectorsPerTrack;
47 BYTE SectorGapLength;
48 BYTE DataLength;
49 BYTE FormatGapLength;
50 BYTE FormatFillByte;
51 BYTE HeadSettleTime;
52 BYTE MotorStartTime;
53 } FLOPPY_PARAM_TABLE, *PFLOPPY_PARAM_TABLE;
54
55 typedef struct _FLOPPY_PARAM_TABLE_EX
56 {
57 FLOPPY_PARAM_TABLE FloppyParamTable;
58
59 // IBM Additions
60 BYTE MaxTrackNumber;
61 BYTE DataTransferRate;
62 BYTE CmosDriveType;
63 } FLOPPY_PARAM_TABLE_EX, *PFLOPPY_PARAM_TABLE_EX;
64
65 #pragma pack(pop)
66
67 // Parameters for 1.44 MB Floppy, taken from SeaBIOS
68
69 #define FLOPPY_SIZE_CODE 0x02 // 512 byte sectors
70 #define FLOPPY_DATALEN 0xFF // Not used - because size code is 0x02
71 #define FLOPPY_MOTOR_TICKS 37 // ~2 seconds
72 #define FLOPPY_FILLBYTE 0xF6
73 #define FLOPPY_GAPLEN 0x1B
74 #define FLOPPY_FORMAT_GAPLEN 0x6C
75
76 static const FLOPPY_PARAM_TABLE_EX FloppyParamTable =
77 {
78 // PC-AT compatible table
79 {
80 0xAF, // step rate 12ms, head unload 240ms
81 0x02, // head load time 4ms, DMA used
82 FLOPPY_MOTOR_TICKS, // ~2 seconds
83 FLOPPY_SIZE_CODE,
84 18,
85 FLOPPY_GAPLEN,
86 FLOPPY_DATALEN,
87 FLOPPY_FORMAT_GAPLEN,
88 FLOPPY_FILLBYTE,
89 0x0F, // 15ms
90 0x08, // 1 second
91 },
92
93 // IBM Additions
94 79, // maximum track
95 0, // data transfer rate
96 4, // drive type in CMOS
97 };
98
99
100 #pragma pack(push, 1)
101
102 // See: http://www.ctyme.com/intr/rb-6135.htm
103 typedef struct _HARDDISK_PARAM_TABLE
104 {
105 WORD Cylinders;
106 BYTE Heads;
107 WORD Unused0;
108 WORD Unused1;
109 BYTE Unused2;
110 BYTE Control;
111 BYTE StandardTimeout;
112 BYTE FormatTimeout;
113 BYTE CheckingTimeout;
114 WORD LandZoneCylinder;
115 BYTE SectorsPerTrack;
116 BYTE Reserved;
117 } HARDDISK_PARAM_TABLE, *PHARDDISK_PARAM_TABLE;
118
119 #pragma pack(pop)
120
121 // static const HARDDISK_PARAM_TABLE HardDiskParamTable =
122 // {0};
123
124
125 /* PRIVATE FUNCTIONS **********************************************************/
126
127 static PDISK_IMAGE
128 GetDisk(IN BYTE DiskNumber)
129 {
130 if (DiskNumber & 0x80)
131 {
132 DiskNumber &= ~0x80;
133
134 if (DiskNumber >= ARRAYSIZE(HardDrive))
135 {
136 DPRINT1("GetDisk: HDD number 0x%02X invalid\n", DiskNumber | 0x80);
137 return NULL;
138 }
139
140 return HardDrive[DiskNumber];
141 }
142 else
143 {
144 if (DiskNumber >= ARRAYSIZE(FloppyDrive))
145 {
146 DPRINT1("GetDisk: Floppy number 0x%02X invalid\n", DiskNumber);
147 return NULL;
148 }
149
150 return FloppyDrive[DiskNumber];
151 }
152 }
153
154 static VOID
155 AllDisksReset(VOID)
156 {
157 Bda->LastDisketteOperation = 0;
158 Bda->LastDiskOperation = 0;
159 }
160
161 /*static*/
162 VOID WINAPI BiosDiskService(LPWORD Stack)
163 {
164 BYTE Drive;
165 PDISK_IMAGE DiskImage;
166
167 switch (getAH())
168 {
169 /* Disk -- Reset Disk System */
170 case 0x00:
171 {
172 Drive = getDL();
173
174 if (Drive & 0x80)
175 {
176 AllDisksReset();
177
178 /* Return success */
179 setAH(0x00);
180 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
181 break;
182 }
183
184 Drive &= ~0x80;
185
186 if (Drive >= ARRAYSIZE(FloppyDrive))
187 {
188 DPRINT1("BiosDiskService(0x00): Drive number 0x%02X invalid\n", Drive);
189
190 /* Return error */
191 setAH(0x01);
192 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
193 break;
194 }
195
196 // TODO: Reset drive
197
198 /* Return success */
199 setAH(0x00);
200 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
201 break;
202 }
203
204 /* Disk -- Get Status of Last Operation */
205 case 0x01:
206 {
207 BYTE LastOperationStatus = 0x00;
208
209 Drive = getDL();
210 DiskImage = GetDisk(Drive);
211 if (!DiskImage || !IsDiskPresent(DiskImage))
212 {
213 DPRINT1("BiosDiskService(0x01): Disk number 0x%02X invalid\n", Drive);
214
215 /* Return error */
216 setAH(0x01);
217 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
218 break;
219 }
220
221 LastOperationStatus = DiskImage->LastOperationStatus;
222
223 if (Drive & 0x80)
224 Bda->LastDiskOperation = LastOperationStatus;
225 else
226 Bda->LastDisketteOperation = LastOperationStatus;
227
228 /* Return last error */
229 setAH(LastOperationStatus);
230 if (LastOperationStatus == 0x00)
231 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
232 else
233 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
234
235 break;
236 }
237
238 /* Disk -- Read Sectors into Memory */
239 case 0x02:
240 {
241 BYTE Status;
242 BYTE Head = getDH();
243 BYTE NumSectors = getAL();
244
245 // CH: Low eight bits of cylinder number
246 // CL: High two bits of cylinder (bits 6-7, hard disk only)
247 WORD Cylinder = MAKEWORD(getCH(), (getCL() >> 6) & 0x02);
248
249 // CL: Sector number 1-63 (bits 0-5)
250 BYTE Sector = (getCL() & 0x3F); // 1-based
251
252 Drive = getDL();
253 DiskImage = GetDisk(Drive);
254 if (!DiskImage || !IsDiskPresent(DiskImage))
255 {
256 DPRINT1("BiosDiskService(0x02): Disk number 0x%02X invalid\n", Drive);
257
258 /* Return error */
259 setAH(0x01);
260 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
261 break;
262 }
263
264 /* Read the sectors */
265 Status = ReadDisk(DiskImage, Cylinder, Head, Sector, NumSectors);
266 if (Status == 0x00)
267 {
268 /* Return success */
269 setAH(0x00);
270 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
271 }
272 else
273 {
274 DPRINT1("BiosDiskService(0x02): Error when reading from disk number 0x%02X (0x%02X)\n", Drive, Status);
275
276 /* Return error */
277 setAH(Status);
278 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
279 }
280
281 break;
282 }
283
284 /* Disk -- Write Disk Sectors */
285 case 0x03:
286 {
287 BYTE Status;
288 BYTE Head = getDH();
289 BYTE NumSectors = getAL();
290
291 // CH: Low eight bits of cylinder number
292 // CL: High two bits of cylinder (bits 6-7, hard disk only)
293 WORD Cylinder = MAKEWORD(getCH(), (getCL() >> 6) & 0x02);
294
295 // CL: Sector number 1-63 (bits 0-5)
296 BYTE Sector = (getCL() & 0x3F); // 1-based
297
298 Drive = getDL();
299 DiskImage = GetDisk(Drive);
300 if (!DiskImage || !IsDiskPresent(DiskImage))
301 {
302 DPRINT1("BiosDiskService(0x03): Disk number 0x%02X invalid\n", Drive);
303
304 /* Return error */
305 setAH(0x01);
306 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
307 break;
308 }
309
310 /* Write the sectors */
311 Status = WriteDisk(DiskImage, Cylinder, Head, Sector, NumSectors);
312 if (Status == 0x00)
313 {
314 /* Return success */
315 setAH(0x00);
316 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
317 }
318 else
319 {
320 DPRINT1("BiosDiskService(0x03): Error when writing to disk number 0x%02X (0x%02X)\n", Drive, Status);
321
322 /* Return error */
323 setAH(Status);
324 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
325 }
326
327 break;
328 }
329
330 /* Disk -- Verify Disk Sectors */
331 case 0x04:
332
333 /* Floppy/Fixed Disk -- Format Track */
334 case 0x05:
335
336 /* Fixed Disk -- Format Track and Set Bad Sector Flags */
337 case 0x06:
338
339 /* Fixed Disk -- Format Drive starting at Given Track */
340 case 0x07:
341 goto Default;
342
343 /* Disk -- Get Drive Parameters */
344 case 0x08:
345 {
346 WORD MaxCylinders;
347 BYTE MaxHeads;
348 BYTE PresentDrives = 0;
349 BYTE i;
350
351 Drive = getDL();
352 DiskImage = GetDisk(Drive);
353 if (!DiskImage || !IsDiskPresent(DiskImage))
354 {
355 DPRINT1("BiosDiskService(0x08): Disk number 0x%02X invalid\n", Drive);
356
357 /* Return error */
358 setAH(0x01);
359 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
360 break;
361 }
362
363 // Minus 2 because it's the maximum cylinder number (not count),
364 // and the last cylinder is reserved (for compatibility with BIOSes
365 // which reserve it for testing purposes).
366 MaxCylinders = DiskImage->DiskInfo.Cylinders - 2;
367 // Minus 1 because it's the maximum head number (not count).
368 MaxHeads = DiskImage->DiskInfo.Heads - 1;
369
370 // CL: Sector number 1-63 (bits 0-5)
371 // High two bits of cylinder (bits 6-7, hard disk only)
372 setCL((DiskImage->DiskInfo.Sectors & 0x3F) |
373 ((HIBYTE(MaxCylinders) & 0x02) << 6));
374 // CH: Low eight bits of cylinder number
375 setCH(LOBYTE(MaxCylinders));
376
377 setDH(MaxHeads);
378
379 if (Drive & 0x80)
380 {
381 /* Count the number of active HDDs */
382 for (i = 0; i < ARRAYSIZE(HardDrive); ++i)
383 {
384 if (IsDiskPresent(HardDrive[i]))
385 ++PresentDrives;
386 }
387
388 /* Reset ES:DI to NULL */
389 // FIXME: NONONO!! Apps expect (for example, MS-DOS kernel)
390 // that this function does not modify ES:DI if it was called
391 // for a HDD.
392 // setES(0x0000);
393 // setDI(0x0000);
394 }
395 else
396 {
397 /* Count the number of active floppies */
398 for (i = 0; i < ARRAYSIZE(FloppyDrive); ++i)
399 {
400 if (IsDiskPresent(FloppyDrive[i]))
401 ++PresentDrives;
402 }
403
404 /* ES:DI points to the floppy parameter table */
405 setES(HIWORD(((PULONG)BaseAddress)[0x1E]));
406 setDI(LOWORD(((PULONG)BaseAddress)[0x1E]));
407 }
408 setDL(PresentDrives);
409
410 setBL(DiskImage->DiskType); // DiskGeometryList[DiskImage->DiskType].biosval
411 setAL(0x00);
412
413 /* Return success */
414 setAH(0x00);
415 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
416 break;
417 }
418
419 /* Hard Disk -- Initialize Controller with Drive Parameters */
420 case 0x09:
421
422 /* Hard Disk -- Read Long Sectors */
423 case 0x0A:
424
425 /* Hard Disk -- Write Long Sectors */
426 case 0x0B:
427 goto Default;
428
429 /* Hard Disk -- Seek to Cylinder */
430 case 0x0C:
431 {
432 BYTE Status;
433 BYTE Head = getDH();
434
435 // CH: Low eight bits of cylinder number
436 // CL: High two bits of cylinder (bits 6-7, hard disk only)
437 WORD Cylinder = MAKEWORD(getCH(), (getCL() >> 6) & 0x02);
438
439 // CL: Sector number 1-63 (bits 0-5)
440 BYTE Sector = (getCL() & 0x3F); // 1-based
441
442 Drive = getDL();
443 if (!(Drive & 0x80))
444 {
445 DPRINT1("BiosDiskService(0x0C): Disk number 0x%02X is not a HDD\n", Drive);
446
447 /* Return error */
448 setAH(0x01);
449 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
450 break;
451 }
452
453 DiskImage = GetDisk(Drive);
454 if (!DiskImage || !IsDiskPresent(DiskImage))
455 {
456 DPRINT1("BiosDiskService(0x0C): Disk number 0x%02X invalid\n", Drive);
457
458 /* Return error */
459 setAH(0x01);
460 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
461 break;
462 }
463
464 /* Set position */
465 Status = SeekDisk(DiskImage, Cylinder, Head, Sector);
466 if (Status == 0x00)
467 {
468 /* Return success */
469 setAH(0x00);
470 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
471 }
472 else
473 {
474 DPRINT1("BiosDiskService(0x0C): Error when seeking in disk number 0x%02X (0x%02X)\n", Drive, Status);
475
476 /* Return error */
477 setAH(Status);
478 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
479 }
480
481 break;
482 }
483
484 /* Hard Disk -- Reset Hard Disks */
485 case 0x0D:
486 {
487 // FIXME: Should do what 0x11 does.
488 UNIMPLEMENTED;
489 }
490
491 /* Hard Disk -- Read Sector Buffer (XT only) */
492 case 0x0E:
493
494 /* Hard Disk -- Write Sector Buffer (XT only) */
495 case 0x0F:
496 goto Default;
497
498 /* Hard Disk -- Check if Drive is ready */
499 case 0x10:
500 {
501 Drive = getDL();
502 if (!(Drive & 0x80))
503 {
504 DPRINT1("BiosDiskService(0x10): Disk number 0x%02X is not a HDD\n", Drive);
505
506 /* Return error */
507 setAH(0x01);
508 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
509 break;
510 }
511
512 DiskImage = GetDisk(Drive);
513 if (!DiskImage || !IsDiskPresent(DiskImage))
514 {
515 DPRINT1("BiosDiskService(0x10): Disk number 0x%02X invalid\n", Drive);
516
517 /* Return error */
518 setAH(0x01);
519 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
520 break;
521 }
522
523 /* Return success */
524 setAH(0x00);
525 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
526 break;
527 }
528
529 /* Hard Disk -- Recalibrate Drive */
530 case 0x11:
531 {
532 BYTE Status;
533
534 Drive = getDL();
535 if (!(Drive & 0x80))
536 {
537 DPRINT1("BiosDiskService(0x11): Disk number 0x%02X is not a HDD\n", Drive);
538
539 /* Return error */
540 setAH(0x01);
541 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
542 break;
543 }
544
545 DiskImage = GetDisk(Drive);
546 if (!DiskImage || !IsDiskPresent(DiskImage))
547 {
548 DPRINT1("BiosDiskService(0x11): Disk number 0x%02X invalid\n", Drive);
549
550 /* Return error */
551 setAH(0x01);
552 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
553 break;
554 }
555
556 /* Set position to zero */
557 Status = SeekDisk(DiskImage, /*Cylinder*/ 0, /*Head*/ 0, /*Sector*/ 1);
558 if (Status == 0x00)
559 {
560 /* Return success */
561 setAH(0x00);
562 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
563 }
564 else
565 {
566 DPRINT1("BiosDiskService(0x11): Error when recalibrating disk number 0x%02X (0x%02X)\n", Drive, Status);
567
568 /* Return error */
569 setAH(Status);
570 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
571 }
572
573 break;
574 }
575
576 /* Hard Disk -- Controller RAM Diagnostic */
577 case 0x12:
578
579 /* Hard Disk -- Drive Diagnostic */
580 case 0x13:
581
582 /* Hard Disk -- Controller Internal Diagnostic */
583 case 0x14:
584 goto Default;
585
586 /* Disk -- Get Disk Type */
587 case 0x15:
588 {
589 Drive = getDL();
590 DiskImage = GetDisk(Drive);
591 if (!DiskImage || !IsDiskPresent(DiskImage))
592 {
593 DPRINT1("BiosDiskService(0x15): Disk number 0x%02X invalid\n", Drive);
594
595 /* Return error */
596 setAH(0x01);
597 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
598 break;
599 }
600
601 if (Drive & 0x80)
602 {
603 ULONG NumSectors;
604
605 /* Hard disk */
606 setAH(0x03);
607
608 /* Number of 512-byte sectors in CX:DX */
609 NumSectors = DiskImage->DiskInfo.Cylinders * DiskImage->DiskInfo.Heads
610 * DiskImage->DiskInfo.Sectors;
611 setCX(HIWORD(NumSectors));
612 setDX(LOWORD(NumSectors));
613 }
614 else
615 {
616 /* Floppy */
617 setAH(0x01);
618 }
619
620 /* Return success */
621 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
622 break;
623 }
624
625 /* Floppy Disk -- Detect Disk Change */
626 case 0x16:
627
628 /* Floppy Disk -- Set Disk Type for Format */
629 case 0x17:
630
631 /* Disk -- Set Media Type for Format */
632 case 0x18:
633 goto Default;
634
635 default: Default:
636 {
637 DPRINT1("BIOS Function INT 13h, AH = 0x%02X, AL = 0x%02X, BH = 0x%02X NOT IMPLEMENTED\n",
638 getAH(), getAL(), getBH());
639 }
640 }
641 }
642
643 /* PUBLIC FUNCTIONS ***********************************************************/
644
645 VOID DiskBios32Post(VOID)
646 {
647 /*
648 * Initialize BIOS Disk RAM dynamic data
649 */
650
651 /* Some vectors are in fact addresses to tables */
652 // Diskette Parameters
653 ((PULONG)BaseAddress)[0x1E] = MAKELONG(0xEFC7, BIOS_SEGMENT);
654 // Hard Disk 0 Parameter Table Address
655 ((PULONG)BaseAddress)[0x41] = (ULONG)NULL;
656 // Hard Disk 1 Drive Parameter Table Address
657 ((PULONG)BaseAddress)[0x46] = (ULONG)NULL;
658
659 /* Relocated services by the BIOS (when needed) */
660 ((PULONG)BaseAddress)[0x40] = (ULONG)NULL; // ROM BIOS Diskette Handler relocated by Hard Disk BIOS
661 // RegisterBiosInt32(0x40, NULL); // ROM BIOS Diskette Handler relocated by Hard Disk BIOS
662
663 /* Register the BIOS 32-bit Interrupts */
664 RegisterBiosInt32(BIOS_DISK_INTERRUPT, BiosDiskService);
665
666 /* Initialize the BDA */
667 // Bda->LastDisketteOperation = 0;
668 // Bda->LastDiskOperation = 0;
669 AllDisksReset();
670 }
671
672 BOOLEAN DiskBios32Initialize(VOID)
673 {
674 /*
675 * Initialize BIOS Disk ROM static data
676 */
677
678 /* Floppy Parameter Table */
679 RtlCopyMemory(SEG_OFF_TO_PTR(BIOS_SEGMENT, 0xEFC7),
680 &FloppyParamTable.FloppyParamTable,
681 sizeof(FloppyParamTable.FloppyParamTable));
682
683 //
684 // FIXME: Must be done by HW floppy controller!
685 //
686
687 /* Detect and initialize the supported disks */
688 // TODO: the "Detect" part is missing.
689 FloppyDrive[0] = RetrieveDisk(FLOPPY_DISK, 0);
690 FloppyDrive[1] = RetrieveDisk(FLOPPY_DISK, 1);
691 HardDrive[0] = RetrieveDisk(HARD_DISK, 0);
692
693 return TRUE;
694 }
695
696 VOID DiskBios32Cleanup(VOID)
697 {
698 }
699
700 /* EOF */