pc98mem.c File Reference

#include <freeldr.h>
#include <debug.h>

Include dependency graph for pc98mem.c:

Go to the source code of this file.

Macros
#define	KB   1024
#define	MB   (KB * KB)

Functions
	DBG_DEFAULT_CHANNEL (MEMORY)
VOID	SetMemory (PFREELDR_MEMORY_DESCRIPTOR MemoryMap, ULONG_PTR BaseAddress, SIZE_T Size, TYPE_OF_MEMORY MemoryType)
VOID	ReserveMemory (PFREELDR_MEMORY_DESCRIPTOR MemoryMap, ULONG_PTR BaseAddress, SIZE_T Size, TYPE_OF_MEMORY MemoryType, PCHAR Usage)
ULONG	PcMemFinalizeMemoryMap (PFREELDR_MEMORY_DESCRIPTOR MemoryMap)
PFREELDR_MEMORY_DESCRIPTOR	Pc98MemGetMemoryMap (ULONG *MemoryMapSize)

Variables
BOOLEAN	HiResoMachine
static FREELDR_MEMORY_DESCRIPTOR	Pc98MemoryMap [MAX_BIOS_DESCRIPTORS+1]

Macro Definition Documentation

KB

#define KB   1024

Definition at line 40 of file pc98mem.c.

MB

#define MB   (KB * KB)

Definition at line 41 of file pc98mem.c.

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

MEMORY

)

Pc98MemGetMemoryMap()

PFREELDR_MEMORY_DESCRIPTOR Pc98MemGetMemoryMap

(

ULONG *

MemoryMapSize

)

Definition at line 48 of file pc98mem.c.

{
    USHORT ConventionalMemory, ExtendedMemory;
    ULONG ExtendedMemory16;
 
    TRACE("Pc98MemGetMemoryMap()\n");
 
    RtlZeroMemory(&PcBiosMemoryMap, sizeof(BIOS_MEMORY_MAP) * MAX_BIOS_DESCRIPTORS);
    PcBiosMapCount = 0;
 
    ConventionalMemory = ((*(PUCHAR)MEM_BIOS_FLAG1 & CONVENTIONAL_MEMORY_SIZE) + 1) * 128;
    ExtendedMemory = *(PUCHAR)MEM_EXPMMSZ * 128;
    ExtendedMemory16 = (*(PUCHAR)MEM_EXPMMSZ16M_LOW + (*(PUCHAR)MEM_EXPMMSZ16M_HIGH << 8)) * 1024;
 
    if (ConventionalMemory > 640 && !HiResoMachine)
        ConventionalMemory = 640;
 
    TRACE("Total conventional memory %d kB available.\n", ConventionalMemory);
    TRACE("Total extended memory %d kB available.\n", ExtendedMemory);
    TRACE("Total extended high memory %d kB available.\n", ExtendedMemory16);
    TRACE("Installed physical memory %d kB.\n", ConventionalMemory + ExtendedMemory + ExtendedMemory16);
 
    /* First, setup allowed ranges */
    SetMemory(Pc98MemoryMap, 0x0000600, ConventionalMemory * KB, LoaderFree);
    SetMemory(Pc98MemoryMap, 0x0100000, ExtendedMemory * KB, LoaderFree);
    SetMemory(Pc98MemoryMap, 0x1000000, ExtendedMemory16 * KB, LoaderFree);
 
    /* Next, setup some protected ranges */
    if (HiResoMachine)
    {
        SetMemory(Pc98MemoryMap, 0x000000, 1 * KB, LoaderFirmwarePermanent);  /* Real mode IVT */
        SetMemory(Pc98MemoryMap, 0x000400, 512, LoaderFirmwarePermanent);     /* Real mode BDA */
        SetMemory(Pc98MemoryMap, 0x080000, 256 * KB, LoaderFirmwarePermanent);/* Memory Window */
        SetMemory(Pc98MemoryMap, 0x0C0000, 128 * KB, LoaderFirmwarePermanent);/* VRAM */
        SetMemory(Pc98MemoryMap, 0x0E0000, 16 * KB, LoaderFirmwarePermanent); /* Text VRAM */
        SetMemory(Pc98MemoryMap, 0x0E4000, 4 * KB, LoaderFirmwarePermanent);  /* CG Window */
        SetMemory(Pc98MemoryMap, 0x0E5000, 103 * KB, LoaderSpecialMemory);    /* BIOS ROM */
        SetMemory(Pc98MemoryMap, 0xF00000, 640 * KB, LoaderSpecialMemory);    /* Reserved */
    }
    else
    {
        SetMemory(Pc98MemoryMap, 0x000000, 1 * KB, LoaderFirmwarePermanent);  /* Real mode IVT */
        SetMemory(Pc98MemoryMap, 0x000400, 512, LoaderFirmwarePermanent);     /* Real mode BDA */
        SetMemory(Pc98MemoryMap, 0x000600 + ConventionalMemory * KB,
                  (640 - ConventionalMemory) * KB, LoaderSpecialMemory);      /* External bus */
        SetMemory(Pc98MemoryMap, 0x0A0000, 16 * KB, LoaderFirmwarePermanent); /* Text VRAM */
        SetMemory(Pc98MemoryMap, 0x0A4000, 4 * KB, LoaderFirmwarePermanent);  /* CG Window */
        SetMemory(Pc98MemoryMap, 0x0A5000, 12 * KB, LoaderFirmwarePermanent); /* Reserved */
        SetMemory(Pc98MemoryMap, 0x0A8000, 96 * KB, LoaderFirmwarePermanent); /* VRAM (Plane B, R, G) */
        SetMemory(Pc98MemoryMap, 0x0C0000, 128 * KB, LoaderSpecialMemory);    /* BIOS ROM (Peripherals) */
        SetMemory(Pc98MemoryMap, 0x0E0000, 32 * KB, LoaderFirmwarePermanent); /* VRAM (Plane I) */
        SetMemory(Pc98MemoryMap, 0x0E8000, 96 * KB, LoaderSpecialMemory);     /* BIOS ROM */
        SetMemory(Pc98MemoryMap, 0xF00000, 640 * KB, LoaderSpecialMemory);    /* Reserved */
    }
 
    *MemoryMapSize = PcMemFinalizeMemoryMap(Pc98MemoryMap);
    return Pc98MemoryMap;
}

Referenced by MachInit().

PcMemFinalizeMemoryMap()

ULONG PcMemFinalizeMemoryMap

(

PFREELDR_MEMORY_DESCRIPTOR

MemoryMap

)

Definition at line 547 of file pcmem.c.

{
    ULONG i;
 
    /* Reserve some static ranges for freeldr */
    ReserveMemory(MemoryMap, 0x1000, STACKLOW - 0x1000, LoaderFirmwareTemporary, "BIOS area");
    ReserveMemory(MemoryMap, STACKLOW, STACKADDR - STACKLOW, LoaderOsloaderStack, "FreeLdr stack");
    ReserveMemory(MemoryMap, FREELDR_BASE, FrLdrImageSize, LoaderLoadedProgram, "FreeLdr image");
 
    /* Default to 1 page above freeldr for the disk read buffer */
    DiskReadBuffer = (PUCHAR)ALIGN_UP_BY(FREELDR_BASE + FrLdrImageSize, PAGE_SIZE);
    DiskReadBufferSize = PAGE_SIZE;
 
    /* Scan for free range above freeldr image */
    for (i = 0; i < PcMapCount; i++)
    {
        if ((MemoryMap[i].BasePage > (FREELDR_BASE / PAGE_SIZE)) &&
            (MemoryMap[i].MemoryType == LoaderFree))
        {
            /* Use this range for the disk read buffer */
            DiskReadBuffer = (PVOID)(MemoryMap[i].BasePage * PAGE_SIZE);
            DiskReadBufferSize = min(MemoryMap[i].PageCount * PAGE_SIZE,
                                     MAX_DISKREADBUFFER_SIZE);
            break;
        }
    }
 
    TRACE("DiskReadBuffer=0x%p, DiskReadBufferSize=0x%lx\n",
          DiskReadBuffer, DiskReadBufferSize);
 
    ASSERT(DiskReadBufferSize > 0);
 
    /* Now reserve the range for the disk read buffer */
    ReserveMemory(MemoryMap,
                  (ULONG_PTR)DiskReadBuffer,
                  DiskReadBufferSize,
                  LoaderFirmwareTemporary,
                  "Disk read buffer");
 
    TRACE("Dumping resulting memory map:\n");
    for (i = 0; i < PcMapCount; i++)
    {
        TRACE("BasePage=0x%lx, PageCount=0x%lx, Type=%s\n",
              MemoryMap[i].BasePage,
              MemoryMap[i].PageCount,
              MmGetSystemMemoryMapTypeString(MemoryMap[i].MemoryType));
    }
    return PcMapCount;
}

Referenced by Pc98MemGetMemoryMap().

ReserveMemory()

VOID ReserveMemory	(	PFREELDR_MEMORY_DESCRIPTOR	MemoryMap,
		ULONG_PTR	BaseAddress,
		SIZE_T	Size,
		TYPE_OF_MEMORY	MemoryType,
		PCHAR	Usage
	)

Definition at line 484 of file pcmem.c.

{
    ULONG_PTR BasePage, PageCount;
    ULONG i;
 
    BasePage = BaseAddress / PAGE_SIZE;
    PageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseAddress, Size);
 
    for (i = 0; i < PcMapCount; i++)
    {
        /* Check for conflicting descriptor */
        if ((MemoryMap[i].BasePage < BasePage + PageCount) &&
            (MemoryMap[i].BasePage + MemoryMap[i].PageCount > BasePage))
        {
            /* Check if the memory is free */
            if (MemoryMap[i].MemoryType != LoaderFree)
            {
                FrLdrBugCheckWithMessage(
                    MEMORY_INIT_FAILURE,
                    __FILE__,
                    __LINE__,
                    "Failed to reserve memory in the range 0x%Ix - 0x%Ix for %s",
                    BaseAddress,
                    Size,
                    Usage);
            }
        }
    }
 
    /* Add the memory descriptor */
    PcMapCount = AddMemoryDescriptor(MemoryMap,
                                     MAX_BIOS_DESCRIPTORS,
                                     BasePage,
                                     PageCount,
                                     MemoryType);
}

SetMemory()

VOID SetMemory	(	PFREELDR_MEMORY_DESCRIPTOR	MemoryMap,
		ULONG_PTR	BaseAddress,
		SIZE_T	Size,
		TYPE_OF_MEMORY	MemoryType
	)

Definition at line 527 of file pcmem.c.

{
    ULONG_PTR BasePage, PageCount;
 
    BasePage = BaseAddress / PAGE_SIZE;
    PageCount = ADDRESS_AND_SIZE_TO_SPAN_PAGES(BaseAddress, Size);
 
    /* Add the memory descriptor */
    PcMapCount = AddMemoryDescriptor(MemoryMap,
                                     MAX_BIOS_DESCRIPTORS,
                                     BasePage,
                                     PageCount,
                                     MemoryType);
}

Referenced by Pc98MemGetMemoryMap().

Variable Documentation

HiResoMachine

BOOLEAN HiResoMachine

extern

Definition at line 17 of file machpc98.c.

Referenced by Pc98MemGetMemoryMap().

Pc98MemoryMap

FREELDR_MEMORY_DESCRIPTOR Pc98MemoryMap[MAX_BIOS_DESCRIPTORS+1]

static

Definition at line 43 of file pc98mem.c.

Referenced by Pc98MemGetMemoryMap().