Changeset 17545 in vbox

Timestamp:

Mar 8, 2009 1:12:25 PM (16 years ago)

Author:

vboxsync

Message:

DevPcBios.cpp,rombios.c: 4GB changes, synced the 0E820 code with current bochs code.

Location:

trunk/src/VBox/Devices/PC

Files:

• BIOS/rombios.c (modified) (10 diffs)
• DevPcBios.cpp (modified) (4 diffs)

trunk/src/VBox/Devices/PC/BIOS/rombios.c

@@ -2269 +2269 @@
 #define ATA_TYPE_ATA      0x02
 #define ATA_TYPE_ATAPI    0x03
+#ifdef VBOX
 #define ATA_TYPE_SCSI     0x04 // SCSI disk
+#endif
 
 #define ATA_DEVICE_NONE  0x00
@@ -4225 +4227 @@
 
       break;
-#endif
+#endif /* VBOX */
 
     case 0x90:
@@ -4597 +4599 @@
     write_word(ES, DI, start);
     write_word(ES, DI+2, start >> 16);
-    write_word(ES, DI+4, 0x00); /** @todo r=bird: why write it twice? */
     write_word(ES, DI+4, extra_start);
     write_word(ES, DI+6, 0x00);
@@ -4605 +4606 @@
     write_word(ES, DI+8, end);
     write_word(ES, DI+10, end >> 16);
-#ifdef VBOX
-    if (end == 0)
-        write_word(ES, DI+12, 0x0001);
-    else
-        /** @todo XXX: nike - is it really correct? see QEMU BIOS patch */
-        write_word(ES, DI+12, extra_end);
-#else /* !VBOX */
-    write_word(ES, DI+12, 0x0000);
-#endif /* !VBOX */
+    write_word(ES, DI+12, extra_end);
     write_word(ES, DI+14, 0x0000);
 
@@ -4626 +4619 @@
 {
   Bit32u  extended_memory_size=0; // 64bits long
-#ifdef VBOX_WITH_MORE_THAN_4GB
   Bit32u  extra_lowbits_memory_size=0;
-#endif
   Bit16u  CX,DX;
-#ifdef VBOX_WITH_MORE_THAN_4GB
   Bit8u   extra_highbits_memory_size=0;
-#endif
 
 BX_DEBUG_INT15("int15 AX=%04x\n",regs.u.r16.ax);
@@ -4692 +4681 @@
                 extended_memory_size |= inb_cmos(0x34);
                 extended_memory_size *= 64;
+#ifndef VBOX /* The following excludes 0xf0000000 thru 0xffffffff. Trust DevPcBios.cpp to get this right. */
                 // greater than EFF00000???
                 if(extended_memory_size > 0x3bc000) {
                     extended_memory_size = 0x3bc000; // everything after this is reserved memory until we get to 0x100000000
                 }
+#endif /* !VBOX */
                 extended_memory_size *= 1024;
                 extended_memory_size += (16L * 1024 * 1024);
@@ -4704 +4695 @@
                     extended_memory_size |= inb_cmos(0x30);
                     extended_memory_size *= 1024;
+                    extended_memory_size += (1L * 1024 * 1024);
                 }
 
-#ifdef VBOX_WITH_MORE_THAN_4GB /* bird: later (btw. this ain't making sense complixity wise, unless its a AMI/AWARD/PHOENIX interface) */
-                extra_lowbits_memory_size = inb_cmos(0x61);
+#ifdef VBOX     /* We've already used the CMOS entries for SATA.
+                   BTW. This is the amount of memory above 4GB measured in 64KB units. */
+                extra_lowbits_memory_size = inb_cmos(0x62);
                 extra_lowbits_memory_size <<= 8;
-                extra_lowbits_memory_size |= inb_cmos(0x62);
+                extra_lowbits_memory_size |= inb_cmos(0x61);
+                extra_lowbits_memory_size <<= 16;
+                extra_highbits_memory_size = inb_cmos(0x63);
+                /* 0x64 and 0x65 can be used if we need to dig 1 TB or more at a later point. */
+#else
+                extra_lowbits_memory_size = inb_cmos(0x5c);
+                extra_lowbits_memory_size <<= 8;
+                extra_lowbits_memory_size |= inb_cmos(0x5b);
                 extra_lowbits_memory_size *= 64;
                 extra_lowbits_memory_size *= 1024;
-                extra_highbits_memory_size = inb_cmos(0x63);
-#endif
+                extra_highbits_memory_size = inb_cmos(0x5d);
+#endif /* !VBOX */
 
                 switch(regs.u.r16.bx)
@@ -4719 +4719 @@
                     case 0:
                         set_e820_range(ES, regs.u.r16.di,
+#ifndef VBOX /** @todo Upstream sugggests the following, needs checking. (see next as well) */
+                                       0x0000000L, 0x0009f000L, 0, 0, 1);
+#else
                                        0x0000000L, 0x0009fc00L, 0, 0, 1);
+#endif
                         regs.u.r32.ebx = 1;
-                        regs.u.r32.eax = 0x534D4150;
-                        regs.u.r32.ecx = 0x14;
-                        CLEAR_CF();
-                        return;
                         break;
                     case 1:
                         set_e820_range(ES, regs.u.r16.di,
+#ifndef VBOX /** @todo Upstream sugggests the following, needs checking. (see next as well) */
+                                       0x0009f000L, 0x000a0000L, 0, 0, 2);
+#else
                                        0x0009fc00L, 0x000a0000L, 0, 0, 2);
+#endif
                         regs.u.r32.ebx = 2;
-                        regs.u.r32.eax = 0x534D4150;
-                        regs.u.r32.ecx = 0x14;
-                        CLEAR_CF();
-                        return;
                         break;
                     case 2:
@@ -4752 +4752 @@
 #endif /* !VBOX */
                         regs.u.r32.ebx = 3;
-                        regs.u.r32.eax = 0x534D4150;
-                        regs.u.r32.ecx = 0x14;
-                        CLEAR_CF();
-                        return;
                         break;
                     case 3:
+#if BX_ROMBIOS32 || defined(VBOX)
                         set_e820_range(ES, regs.u.r16.di,
                                        0x00100000L,
                                        extended_memory_size - ACPI_DATA_SIZE, 0, 0, 1);
                         regs.u.r32.ebx = 4;
-                        regs.u.r32.eax = 0x534D4150;
-                        regs.u.r32.ecx = 0x14;
-                        CLEAR_CF();
-                        return;
+#else
+                        set_e820_range(ES, regs.u.r16.di,
+                                       0x00100000L,
+                                       extended_memory_size, 1);
+                        regs.u.r32.ebx = 5;
+#endif
                         break;
                     case 4:
@@ -4772 +4771 @@
                                        extended_memory_size, 0, 0, 3); // ACPI RAM
                         regs.u.r32.ebx = 5;
-                        regs.u.r32.eax = 0x534D4150;
-                        regs.u.r32.ecx = 0x14;
-                        CLEAR_CF();
-                        return;
                         break;
                     case 5:
                         /* 256KB BIOS area at the end of 4 GB */
+#ifdef VBOX
+                        /* We don't set the end to 1GB here and rely on the 32-bit
+                           unsigned wrap around effect (0-0xfffc0000L). */
+#endif
                         set_e820_range(ES, regs.u.r16.di,
                                        0xfffc0000L, 0x00000000L, 0, 0, 2);
-#ifdef VBOX_WITH_MORE_THAN_4GB
                         if (extra_highbits_memory_size || extra_lowbits_memory_size)
                             regs.u.r32.ebx = 6;
                         else
-#endif
                             regs.u.r32.ebx = 0;
-                        regs.u.r32.eax = 0x534D4150;
-                        regs.u.r32.ecx = 0x14;
-                        CLEAR_CF();
-                        return;
-#ifdef VBOX_WITH_MORE_THAN_4GB
+                        break;
                     case 6:
-                        /* Mapping of memory above 4 GB */
-                        set_e820_range(ES, regs.u.r16.di,
-                                       0x00000000L, extra_lowbits_memory_size,
-                                       1, extra_highbits_memory_size + 1, 1);
+#ifdef VBOX /* Don't succeeded if no memory above 4 GB.  */
+                        /* Mapping of memory above 4 GB if present.
+                           Note: set_e820_range needs do no borrowing in the
+                                 subtraction because of the nice numbers. */
+                        if (extra_highbits_memory_size || extra_lowbits_memory_size)
+                        {
+                            set_e820_range(ES, regs.u.r16.di,
+                                           0x00000000L, extra_lowbits_memory_size,
+                                           1 /*GB*/, extra_highbits_memory_size + 1 /*GB*/, 1);
+                            regs.u.r32.ebx = 0;
+                            break;
+                        }
+                        /* fall thru */
+#else  /* !VBOX */
+                        /* Maping of memory above 4 GB */
+                        set_e820_range(ES, regs.u.r16.di, 0x00000000L,
+                        extra_lowbits_memory_size, 1, extra_highbits_memory_size
+                                       + 1, 1);
                         regs.u.r32.ebx = 0;
-                        regs.u.r32.eax = 0x534D4150;
-                        regs.u.r32.ecx = 0x14;
-                        CLEAR_CF();
-                        return;
-#endif
+                        break;
+#endif /* !VBOX */
                     default:  /* AX=E820, DX=534D4150, BX unrecognized */
                         goto int15_unimplemented;
                         break;
                 }
+                regs.u.r32.eax = 0x534D4150;
+                regs.u.r32.ecx = 0x14;
+                CLEAR_CF();
             } else {
               // if DX != 0x534D4150)

trunk/src/VBox/Devices/PC/DevPcBios.cpp

@@ -90 +90 @@
     Number of CPUs:
          0x60
-    RAM above 4G (in 64M units):
-         0x61 - 0x63
+    RAM above 4G (in 64KB units):
+         0x61 - 0x65
 @endverbatim
  *
@@ -526 +526 @@
      * Memory sizes.
      */
-#ifdef VBOX_WITH_MORE_THAN_4GB
-    uint64_t cKBRam = pThis->cbRam / _1K;
-    uint64_t cKBAbove4GB = 0;
-    uint32_t cKBBelow4GB = cKBRam;
-    AssertRelease(cKBBelow4GB == cKBRam);
-    if (cKBRam > UINT32_C(0xe0000000)) /** @todo this limit must be picked up from CFGM and coordinated with MM/PGM! */
-    {
-        cKBAbove4GB = cKBRam - UINT32_C(0xe0000000);
-        cKBBelow4GB = UINT32_C(0xe0000000);
-    }
-    else
-    {
-        cKBAbove4GB = 0;
-        cKBBelow4GB = cKBRam;
-    }
-
-    /* base memory. */
-    u32 = cKBBelow4GB > 640 ? 640 : cKBBelow4GB;
-    pcbiosCmosWrite(pDevIns, 0x15, u32 & 0xff);                                 /* 15h - Base Memory in K, Low Byte */
-    pcbiosCmosWrite(pDevIns, 0x16, u32 >> 8);                                   /* 16h - Base Memory in K, High Byte */
-
-    /* Extended memory, up to 65MB */
-    u32 = cKBBelow4GB >= 65 * _1K ? 0xffff : (cKBBelow4GB - _1K);
-    pcbiosCmosWrite(pDevIns, 0x17, u32 & 0xff);                                 /* 17h - Extended Memory in K, Low Byte */
-    pcbiosCmosWrite(pDevIns, 0x18, u32 >> 8);                                   /* 18h - Extended Memory in K, High Byte */
-    pcbiosCmosWrite(pDevIns, 0x30, u32 & 0xff);                                 /* 30h - Extended Memory in K, Low Byte */
-    pcbiosCmosWrite(pDevIns, 0x31, u32 >> 8);                                   /* 31h - Extended Memory in K, High Byte */
-
-    /* Bochs BIOS specific? Anyway, it's the amount of memory above 16MB */
-    if (cKBBelow4GB > 16 * _1K)
-    {
-        u32 = (uint32_t)( (cKBBelow4GB - 16 * _1K) / 64 );
-        u32 = RT_MIN(u32, 0xffff);
-    }
-    else
-        u32 = 0;
-    pcbiosCmosWrite(pDevIns, 0x34, u32 & 0xff);
-    pcbiosCmosWrite(pDevIns, 0x35, u32 >> 8);
-
-    /* RAM above 4G, in 64MB units (needs discussing, see comments and @todos elsewhere). */
-    pcbiosCmosWrite(pDevIns, 0x61, cKBAbove4GB >> 16);
-    pcbiosCmosWrite(pDevIns, 0x62, cKBAbove4GB >> 24);
-    pcbiosCmosWrite(pDevIns, 0x63, cKBAbove4GB >> 32);
-
-#else  /* old code. */
     /* base memory. */
     u32 = pThis->cbRam > 640 ? 640 : (uint32_t)pThis->cbRam / _1K; /* <-- this test is wrong, but it doesn't matter since we never assign less than 1MB */
@@ -584 +539 @@
 
     /* Bochs BIOS specific? Anyway, it's the amount of memory above 16MB
-       and below 4GB (as it can only hold 4GB+16M). */
+       and below 4GB (as it can only hold 4GB+16M). For 0E820h to work right,
+       this has to indicate less than 0xfffc0000 bytes or it'll conflict with
+       the high BIOS area. */
     uint64_t const offRamHole = _4G - pThis->cbRamHole;
     if (pThis->cbRam > 16 * _1M)
     {
         u32 = (uint32_t)( (RT_MIN(pThis->cbRam, offRamHole) - 16 * _1M) / _64K );
-        u32 = RT_MIN(u32, 0xffff);
+        u32 = RT_MIN(u32, 0xfefc);
     }
     else
@@ -596 +553 @@
     pcbiosCmosWrite(pDevIns, 0x35, u32 >> 8);
 
-# if 0    /** @todo Report the amount above 4GB and make sure the BIOS is only using 34/35 for the bits below 4GB. */
-    /* Suggestion: MBs above 4GB, reserve 4 CMOS entries (need 3 now), means a
-                   total around 2**52 bytes or 4EB if you like. The max of what
-                   AMD64 is currently specified for IIRC.  */
+    /* Bochs/VBox BIOS specific way of specifying memory above 4GB in 64KB units.
+       Bochs got these in a different location which we've already used for SATA,
+       it also lacks the last two. */
+    uint64_t c64KBAbove4GB;
     if (pThis->cbRam <= offRamHole)
-        u32 = 0;
+        c64KBAbove4GB = 0;
     else
     {
-        u32 = (pThis->cbRam - offRamHole) / _1M;
-        AssertMsg((uint64_t)u32 * _1M + offRamHole == pThis->cbRam, ("%RX64 %RX64\n", pThis->cbRam, offRamHole));
-    }
-    pcbiosCmosWrite(pDevIns, 0xY0,  u32        & 0xff);
-    pcbiosCmosWrite(pDevIns, 0xY1, (u32 >>  8) & 0xff);
-    pcbiosCmosWrite(pDevIns, 0xY2, (u32 >> 16) & 0xff);
-    pcbiosCmosWrite(pDevIns, 0xY3,  u32 >> 24);
-# endif
-#endif /* old code */
+        c64KBAbove4GB = (pThis->cbRam - offRamHole) / _64K;
+        /* Make sure it doesn't hit the limits of the current BIOS code.   */
+        AssertLogRelMsgReturn((c64KBAbove4GB >> (3 * 8)) < 255, ("%#RX64\n", c64KBAbove4GB), VERR_OUT_OF_RANGE);
+    }
+    pcbiosCmosWrite(pDevIns, 0x61,  c64KBAbove4GB        & 0xff);
+    pcbiosCmosWrite(pDevIns, 0x62, (c64KBAbove4GB >>  8) & 0xff);
+    pcbiosCmosWrite(pDevIns, 0x63, (c64KBAbove4GB >> 16) & 0xff);
+    pcbiosCmosWrite(pDevIns, 0x64, (c64KBAbove4GB >> 24) & 0xff);
+    pcbiosCmosWrite(pDevIns, 0x65, (c64KBAbove4GB >> 32) & 0xff);
 
     /*