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)
static VOID	XboxInitializePCI (VOID)
VOID	XboxMemInit (VOID)
memory_map_t *	XboxGetMultibootMemoryMap (INT *Count)
TYPE_OF_MEMORY	XboxMultibootMemoryType (ULONG Type)
PFREELDR_MEMORY_DESCRIPTOR	XboxMemGetMemoryMap (ULONG *MemoryMapSize)

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

Macro Definition Documentation

TEST_PATTERN1

#define TEST_PATTERN1   0xAA

Definition at line 35 of file xboxmem.c.

TEST_PATTERN2

#define TEST_PATTERN2   0x55

Definition at line 36 of file xboxmem.c.

TEST_SIZE

#define TEST_SIZE   0x200

Definition at line 34 of file xboxmem.c.

Function Documentation

DBG_DEFAULT_CHANNEL()

DBG_DEFAULT_CHANNEL

(

MEMORY

)

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 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 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);
}

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 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 PcMemGetMemoryMap(), and XboxMemGetMemoryMap().

XboxGetMultibootMemoryMap()

memory_map_t * XboxGetMultibootMemoryMap

(

INT *

Count

)

Definition at line 175 of file xboxmem.c.

{
    memory_map_t * MemoryMap;
 
    if (!MultibootInfoPtr)
    {
        ERR("Multiboot info structure not found!\n");
        return NULL;
    }
 
    if (!(MultibootInfoPtr->flags & MB_INFO_FLAG_MEMORY_MAP))
    {
        ERR("Multiboot memory map is not passed!\n");
        return NULL;
    }
 
    MemoryMap = (memory_map_t *)MultibootInfoPtr->mmap_addr;
 
    if (!MemoryMap ||
        MultibootInfoPtr->mmap_length == 0 ||
        MultibootInfoPtr->mmap_length % sizeof(memory_map_t) != 0)
    {
        ERR("Multiboot memory map structure is malformed!\n");
        return NULL;
    }
 
    *Count = MultibootInfoPtr->mmap_length / sizeof(memory_map_t);
    return MemoryMap;
}

Referenced by XboxMemGetMemoryMap().

XboxInitializePCI()

static VOID XboxInitializePCI ( VOID  )

static

Definition at line 59 of file xboxmem.c.

{
    PCI_TYPE1_CFG_BITS PciCfg1;
    ULONG PciData;
 
    /* Select PCI to PCI bridge */
    PciCfg1.u.bits.Enable = 1;
    PciCfg1.u.bits.BusNumber = 0;
    PciCfg1.u.bits.DeviceNumber = 8;
    PciCfg1.u.bits.FunctionNumber = 0;
    /* Select register VendorID & DeviceID */
    PciCfg1.u.bits.RegisterNumber = 0x00;
    PciCfg1.u.bits.Reserved = 0;
 
    WRITE_PORT_ULONG(PCI_TYPE1_ADDRESS_PORT, PciCfg1.u.AsULONG);
    PciData = READ_PORT_ULONG((PULONG)PCI_TYPE1_DATA_PORT);
 
    if (PciData == 0x01B810DE)
    {
        /* Select register PrimaryBus/SecondaryBus/SubordinateBus/SecondaryLatency */
        PciCfg1.u.bits.RegisterNumber = 0x18;
        WRITE_PORT_ULONG(PCI_TYPE1_ADDRESS_PORT, PciCfg1.u.AsULONG);
 
        /* Link uninitialized PCI bridge to the empty PCI bus 2,
         * it's not supposed to have any devices attached anyway */
        PciData = READ_PORT_ULONG((PULONG)PCI_TYPE1_DATA_PORT);
        PciData &= 0xFF0000FF;
        PciData |= 0x00020200;
        WRITE_PORT_ULONG((PULONG)PCI_TYPE1_DATA_PORT, PciData);
    }
 
    /* Select AGP to PCI bridge */
    PciCfg1.u.bits.DeviceNumber = 30;
    /* Select register VendorID & DeviceID */
    PciCfg1.u.bits.RegisterNumber = 0x00;
 
    WRITE_PORT_ULONG(PCI_TYPE1_ADDRESS_PORT, PciCfg1.u.AsULONG);
    PciData = READ_PORT_ULONG((PULONG)PCI_TYPE1_DATA_PORT);
 
    if (PciData == 0x01B710DE)
    {
        /* Zero out uninitialized AGP Host bridge BARs */
 
        /* Select register BAR0 */
        PciCfg1.u.bits.RegisterNumber = 0x10;
        WRITE_PORT_ULONG(PCI_TYPE1_ADDRESS_PORT, PciCfg1.u.AsULONG);
        /* Zero it out */
        WRITE_PORT_ULONG((PULONG)PCI_TYPE1_DATA_PORT, 0);
 
        /* Select register BAR1 */
        PciCfg1.u.bits.RegisterNumber = 0x14;
        WRITE_PORT_ULONG(PCI_TYPE1_ADDRESS_PORT, PciCfg1.u.AsULONG);
        /* Zero it out */
        WRITE_PORT_ULONG((PULONG)PCI_TYPE1_DATA_PORT, 0);
    }
}

Referenced by XboxMemInit().

XboxMemGetMemoryMap()

PFREELDR_MEMORY_DESCRIPTOR XboxMemGetMemoryMap

(

ULONG *

MemoryMapSize

)

Definition at line 228 of file xboxmem.c.

{
    memory_map_t * MbMap;
    INT Count, i;
 
    TRACE("XboxMemGetMemoryMap()\n");
 
    MbMap = XboxGetMultibootMemoryMap(&Count);
    if (MbMap)
    {
        /* Obtain memory map via multiboot spec */
 
        for (i = 0; i < Count; i++, MbMap++)
        {
            TRACE("i = %d, base_addr_low = 0x%p, length_low = 0x%p\n", i, MbMap->base_addr_low, MbMap->length_low);
 
            if (MbMap->base_addr_high > 0 || MbMap->length_high > 0)
            {
                ERR("Memory descriptor base or size is greater than 4 GB, should not happen on Xbox!\n");
                ASSERT(FALSE);
            }
 
            SetMemory(XboxMemoryMap,
                      MbMap->base_addr_low,
                      MbMap->length_low,
                      XboxMultibootMemoryType(MbMap->type));
        }
    }
    else
    {
        /* 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 MachInit().

XboxMemInit()

VOID XboxMemInit

(

VOID

)

Definition at line 117 of file xboxmem.c.

{
    PCI_TYPE1_CFG_BITS PciCfg1;
    UCHAR ControlRegion[TEST_SIZE];
    PVOID MembaseTop = (PVOID)(64 * 1024 * 1024);
    PVOID MembaseLow = (PVOID)0;
 
    WRITE_REGISTER_ULONG((PULONG)(NvBase + NV2A_FB_CFG0), 0x03070103);
    WRITE_REGISTER_ULONG((PULONG)(NvBase + NV2A_FB_CFG0 + 4), 0x11448000);
 
    /* Select Host to PCI bridge */
    PciCfg1.u.bits.Enable = 1;
    PciCfg1.u.bits.BusNumber = 0;
    PciCfg1.u.bits.DeviceNumber = 0;
    PciCfg1.u.bits.FunctionNumber = 0;
    PciCfg1.u.bits.Reserved = 0;
    /* Prepare hardware for 128 MB */
    PciCfg1.u.bits.RegisterNumber = 0x84;
 
    WRITE_PORT_ULONG(PCI_TYPE1_ADDRESS_PORT, PciCfg1.u.AsULONG);
    WRITE_PORT_ULONG((PULONG)PCI_TYPE1_DATA_PORT, 0x7FFFFFF);
 
    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(PCI_TYPE1_ADDRESS_PORT, PciCfg1.u.AsULONG);
    WRITE_PORT_ULONG((PULONG)PCI_TYPE1_DATA_PORT, InstalledMemoryMb * 1024 * 1024 - 1);
 
    AvailableMemoryMb = InstalledMemoryMb;
 
    XboxInitializePCI();
}

Referenced by MachInit().

XboxMultibootMemoryType()

TYPE_OF_MEMORY XboxMultibootMemoryType

(

ULONG

Type

)

Definition at line 206 of file xboxmem.c.

{
    switch (Type)
    {
        case 0: // Video RAM
            return LoaderFirmwarePermanent;
        case 1: // Available RAM
            return LoaderFree;
        case 3: // ACPI area
            return LoaderFirmwareTemporary;
        case 4: // Hibernation area
            return LoaderSpecialMemory;
        case 5: // Reserved or invalid memory
            return LoaderSpecialMemory;
        default:
            return LoaderFirmwarePermanent;
    }
}

Referenced by XboxMemGetMemoryMap().

Variable Documentation

AvailableMemoryMb

ULONG AvailableMemoryMb = 0

static

Definition at line 28 of file xboxmem.c.

Referenced by XboxMemGetMemoryMap(), and XboxMemInit().

FrameBuffer

PVOID FrameBuffer

extern

Definition at line 28 of file xboxvideo.c.

Referenced by XboxMemGetMemoryMap().

FrameBufferSize

ULONG FrameBufferSize

extern

Definition at line 29 of file xboxvideo.c.

Referenced by XboxMemGetMemoryMap(), and XboxVideoInit().

InstalledMemoryMb

ULONG InstalledMemoryMb = 0

static

Definition at line 27 of file xboxmem.c.

Referenced by XboxMemInit().

MultibootInfoPtr

multiboot_info_t* MultibootInfoPtr

extern

Referenced by XboxGetMultibootMemoryMap().

NvBase

ULONG NvBase

extern

Definition at line 27 of file xboxvideo.c.

Referenced by NvGetCrtc(), XboxMemInit(), and XboxVideoInit().

XboxMemoryMap

FREELDR_MEMORY_DESCRIPTOR XboxMemoryMap[MAX_BIOS_DESCRIPTORS+1]

Definition at line 225 of file xboxmem.c.

Referenced by XboxMemGetMemoryMap().