xboxmem.c File Reference

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

Include dependency graph for xboxmem.c:

Go to the source code of this file.

Macros
#define	TEST_SIZE   0x200
#define	TEST_PATTERN1   0xAA
#define	TEST_PATTERN2   0x55

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)
VOID	XboxMemInit (VOID)
PFREELDR_MEMORY_DESCRIPTOR	XboxMemGetMemoryMap (ULONG *MemoryMapSize)

Variables
static ULONG	InstalledMemoryMb = 0
static ULONG	AvailableMemoryMb = 0
PVOID	FrameBuffer
ULONG	FrameBufferSize
FREELDR_MEMORY_DESCRIPTOR	XboxMemoryMap [MAX_BIOS_DESCRIPTORS+1]

Macro Definition Documentation

TEST_PATTERN1

#define TEST_PATTERN1   0xAA

Definition at line 33 of file xboxmem.c.

TEST_PATTERN2

#define TEST_PATTERN2   0x55

Definition at line 34 of file xboxmem.c.

TEST_SIZE

#define TEST_SIZE   0x200

Definition at line 32 of file xboxmem.c.

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

MEMORY

)

PcMemFinalizeMemoryMap()

ULONG PcMemFinalizeMemoryMap

(

PFREELDR_MEMORY_DESCRIPTOR

MemoryMap

)

Definition at line 542 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 PcMemGetMemoryMap(), and XboxMemGetMemoryMap().

ReserveMemory()

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

Definition at line 479 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);
}

Referenced by PcMemFinalizeMemoryMap(), and XboxMemGetMemoryMap().

SetMemory()

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

Definition at line 522 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 PcMemGetMemoryMap(), and XboxMemGetMemoryMap().

XboxMemGetMemoryMap()

PFREELDR_MEMORY_DESCRIPTOR XboxMemGetMemoryMap

(

ULONG *

MemoryMapSize

)

Definition at line 104 of file xboxmem.c.

{
    TRACE("XboxMemGetMemoryMap()\n");
    /* FIXME: Obtain memory map via multiboot spec */

    /* Synthesize memory map */

    /* Available RAM block */
    SetMemory(XboxMemoryMap,
              0,
              AvailableMemoryMb * 1024 * 1024,
              LoaderFree);

    if (FrameBufferSize != 0)
    {
        /* Video memory */
        ReserveMemory(XboxMemoryMap,
                      (ULONG_PTR)FrameBuffer,
                      FrameBufferSize,
                      LoaderFirmwarePermanent,
                      "Video memory");
    }

    *MemoryMapSize = PcMemFinalizeMemoryMap(XboxMemoryMap);
    return XboxMemoryMap;
}

Referenced by XboxMachInit().

XboxMemInit()

VOID XboxMemInit

(

VOID

)

Definition at line 56 of file xboxmem.c.

{
    UCHAR ControlRegion[TEST_SIZE];
    PVOID MembaseTop = (PVOID)(64 * 1024 * 1024);
    PVOID MembaseLow = (PVOID)0;

    (*(PULONG)(0xfd000000 + 0x100200)) = 0x03070103;
    (*(PULONG)(0xfd000000 + 0x100204)) = 0x11448000;

    WRITE_PORT_ULONG((ULONG*) 0xcf8, CONFIG_CMD(0, 0, 0x84));
    WRITE_PORT_ULONG((ULONG*) 0xcfc, 0x7ffffff);             /* Prep hardware for 128 Mb */

    InstalledMemoryMb = 64;
    memset(ControlRegion, TEST_PATTERN1, TEST_SIZE);
    memset(MembaseTop, TEST_PATTERN1, TEST_SIZE);
    __wbinvd();

    if (memcmp(MembaseTop, ControlRegion, TEST_SIZE) == 0)
    {
        /* Looks like there is memory .. maybe a 128MB box */
        memset(ControlRegion, TEST_PATTERN2, TEST_SIZE);
        memset(MembaseTop, TEST_PATTERN2, TEST_SIZE);
        __wbinvd();
        if (memcmp(MembaseTop, ControlRegion, TEST_SIZE) == 0)
        {
            /* Definitely looks like there is memory */
            if (memcmp(MembaseLow, ControlRegion, TEST_SIZE) == 0)
            {
                /* Hell, we find the Test-string at 0x0 too! */
                InstalledMemoryMb = 64;
            }
            else
            {
                InstalledMemoryMb = 128;
            }
        }
    }

    /* Set hardware for amount of memory detected */
    WRITE_PORT_ULONG((ULONG*) 0xcf8, CONFIG_CMD(0, 0, 0x84));
    WRITE_PORT_ULONG((ULONG*) 0xcfc, InstalledMemoryMb * 1024 * 1024 - 1);

    AvailableMemoryMb = InstalledMemoryMb;
}

Referenced by XboxMachInit().

Variable Documentation

AvailableMemoryMb

ULONG AvailableMemoryMb = 0

static

Definition at line 28 of file xboxmem.c.

Referenced by XboxMemGetMemoryMap(), and XboxMemInit().

FrameBuffer

PVOID FrameBuffer

Definition at line 27 of file xboxvideo.c.

Referenced by ConsoleEfiGopEnable(), ConsoleInitHercules(), ConsoleInitVga(), ConsolepClearBuffer(), EfiGopGetFrameBuffer(), VBEMapVideoMemory(), XboxMemGetMemoryMap(), XboxVideoClearScreenColor(), XboxVideoInit(), XboxVideoOutputChar(), and XboxVmpMapVideoMemory().

FrameBufferSize

ULONG FrameBufferSize

Definition at line 28 of file xboxvideo.c.

Referenced by ConsoleEfiGopEnable(), EfiGopGetFrameBuffer(), XboxMemGetMemoryMap(), and XboxVideoInit().

InstalledMemoryMb

ULONG InstalledMemoryMb = 0

static

Definition at line 27 of file xboxmem.c.

Referenced by XboxMemInit().

XboxMemoryMap

FREELDR_MEMORY_DESCRIPTOR XboxMemoryMap[MAX_BIOS_DESCRIPTORS+1]

Definition at line 101 of file xboxmem.c.

Referenced by XboxMemGetMemoryMap().