main.c

WinCE 3.0 BSP, 包含Inter SA1110, Intel_815E, Advantech_PCM9574 等

/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.
Copyright (c) 1995-2000  Microsoft Corporation

Module Name: main.c

Abstract: Boot loader main and supporting functions.

Functions:
    blMain
    OEMDebugInit
    OEMPlatformInit
    OEMShowProgress
    OEMLaunch
    OEMPreDownload
    OEMReadData
    OEMMapMemAddr
    OEMWriteFlash
    OEMFinishEraseFlash
    OEMContinueEraseFlash
    OEMStartEraseFlash
    OEMIsFlashAddr
    InitBootArgs
    CopyToRAM
    SpinForever
    OEMGetSecs

Notes:

--*/

#include <windows.h>
#include <nkintr.h>
#include "bootarg.h"

// Debug zones aren't registered, but this is a useful mechanism for
// controlling debug output levels.
#ifdef DEBUG
DBGPARAM dpCurSettings =
{
    TEXT("Bootloader"),
    {
        TEXT("0"),
        TEXT("1"),
        TEXT("2"),
        TEXT("3"),		//
        TEXT("4"),
        TEXT("5"),
        TEXT("6"),
        TEXT("7"),		//
        TEXT("8"),
        TEXT("9"),
        TEXT("PCIConfig"),
        TEXT("BootProg"),	//
        TEXT("Info"),
        TEXT("Function"),
        TEXT("Warn"),
        TEXT("Error")		//
    },
    0x8000
};
#endif

#include "bldr.h"

// Function prototypes
//
void InitBootArgs(BOOT_ARGS * pBootArgs);
BOOL PlatformInit(VOID);
void UIWatchForBootHalt(void);
void GetRealTimeFromCMOS(SYSTEMTIME *pst);
void StoreDefaultEnvVars(void);
BOOL LoadEnvVars(PLOADER_VARS pVars);

extern LOADER_VARS gLoaderVars;

// Global variables.
//
BOOT_ARGS *pBootArgs = NULL;
PFN_PLATFORM_INIT         pfnPlatformInit2 = NULL;
PFN_LAUNCH                pfnLaunch        = NULL;
PFN_PRE_DOWNLOAD          pfnPreDownload   = NULL;
PFN_READ_DATA             pfnReadData      = NULL;


VOID blMain(VOID)
{

    // Common bootloader main routine.
    BootloaderMain();

    // Should never get here.
    SpinForever();
}


BOOL OEMDebugInit(VOID)
{
    OEMInitDebugSerial();

    return(TRUE);
}


BOOL OEMPlatformInit(VOID)
{

    // Display loader version
    RETAILMSG(1, (TEXT("Loader Version %d.%d\r\n"), BLDR_VERSION_MAJOR, BLDR_VERSION_MINOR));

    // Call platform-specific initialization code.
    PlatformInit();

    // Load environment variables from CMOS.
    if (!LoadEnvVars(&gLoaderVars))
    {
        RETAILMSG(1, (TEXT("ERROR: Loading environment variables failed - storing and using defaults...\r\n")));
        StoreDefaultEnvVars();
    }

    // Get pointer to Boot Args...
    ((ULONG)(*(PBYTE *)BOOT_ARG_PTR_LOCATION_NP)) = BOOT_ARG_LOCATION_NP;
    pBootArgs = (BOOT_ARGS *) ((ULONG)(*(PBYTE *)BOOT_ARG_PTR_LOCATION_NP));
    InitBootArgs(pBootArgs);
    DEBUGMSG(ZONE_INFO, (TEXT("Boot Args @ 0x%x\r\n"), pBootArgs));


    // Allow user to halt boot process and break into configuration menu.
    UIWatchForBootHalt();


    // Assign loader function callbacks based on where image is to be loaded
    // from (read from CMOS - enet, hdd, etc.).
    switch(gLoaderVars.nImgLoc)
    {
        case BL_ENET:    // Ethernet.
            pfnPlatformInit2 = OEMEthPlatformInit;
            pfnPreDownload   = OEMEthPreDownload;
            pfnReadData      = OEMEthReadData;
            pfnLaunch        = OEMEthLaunch;
            break;
        case BL_ATAHDD: // IDE/ATA HDD.
            pfnPlatformInit2 = OEMHDDPlatformInit;
            pfnPreDownload   = OEMHDDPreDownload;
            pfnReadData      = OEMHDDReadData;
            pfnLaunch        = OEMHDDLaunch;
            break;
        default:
            break;
    }

    // Continue platform-specific initialization.
    if (!pfnPlatformInit2)
        SpinForever();

    return(pfnPlatformInit2());

}


void OEMShowProgress(DWORD dwPacketNum)
{
    // Do nothing.
    return;
}


void OEMLaunch (DWORD dwImageStart, DWORD dwImageLength, DWORD dwLaunchAddr, const ROMHDR *pRomHdr)
{
    if (!pfnLaunch)
        SpinForever();

    pfnLaunch(dwImageStart, dwImageLength, dwLaunchAddr, pRomHdr);
}


DWORD OEMPreDownload(VOID)
{
    if (!pfnPreDownload)
        SpinForever();

    return(pfnPreDownload());
}


BOOL OEMReadData (DWORD cbData, LPBYTE pbData)
{
    if (!pfnPreDownload)
        SpinForever();

    return(pfnReadData(cbData, pbData));
}


LPBYTE OEMMapMemAddr (DWORD dwImageStart, DWORD dwAddr)
{
    return (LPBYTE) dwAddr;
}


///////////////////////////////////////////////////////////////////
// Flash Routines (none for x86)
///////////////////////////////////////////////////////////////////
BOOL OEMWriteFlash(DWORD dwImageStart, DWORD dwImageLength)
{
    return(FALSE);
}

BOOL OEMFinishEraseFlash(void)
{
    return(FALSE);
}

void OEMContinueEraseFlash(void)
{
    return;
}

BOOL OEMStartEraseFlash (DWORD dwStartAddr, DWORD dwLength)
{
    return(FALSE);
}

BOOL OEMIsFlashAddr (DWORD dwAddr)
{
    return(FALSE);
}




void InitBootArgs(BOOT_ARGS *pBootArgs)
{
    // Video modes
    #define VM320x200x256   0
    #define VM480x240x256   1
    #define VM640x480x256   2
    #define VM800x600x256   3
    #define VM1024x768x256  4
    #define VM320x240x256   5

    // Baud divisors
    #define BD14400	8
    #define BD16457	7
    #define BD19200	6
    #define BD23040	5
    #define BD28800	4
    #define BD38400	3
    #define BD57600	2
    #define BD115200	1

    if (pBootArgs == NULL)
        return;

    memset(pBootArgs, 0, sizeof(BOOT_ARGS));

    pBootArgs->ucVideoMode         = VM640x480x256; // 640x480x256
    pBootArgs->ucComPort     	   = 1;             // COM1
    pBootArgs->ucBaudDivisor 	   = BD38400;       // 38400
    pBootArgs->ucPCIConfigType 	   = 1;


    pBootArgs->dwSig 		       = BOOTARG_SIG;
    pBootArgs->dwLen 		       = sizeof(BOOT_ARGS);


    pBootArgs->ucLoaderFlags	   = 0;
    pBootArgs->ucEshellFlags	   = 0;
    pBootArgs->dwEdbgDebugZone	   = 0;

    pBootArgs->dwEBootAddr = (DWORD)BootloaderMain;	// Warm reset entry

    pBootArgs->ucEdbgAdapterType = EDBG_ADAPTER_OEM;
    pBootArgs->dwEdbgBaseAddr    = 0;
    pBootArgs->ucEdbgIRQ         = DEBUG_ETHER_IRQ;

    return;
}


void CopyToRAM(void)
{
    // Copy BOOT ROM to RAM for faster execution.
    //
    memcpy((PVOID)RAM_DEST_ADDR, (PVOID)ROM_SOURCE_ADDR, MAX_IMAGE_SIZE);

}


void SpinForever(void)
{
    RETAILMSG(1, (TEXT("SpinForever...\r\n")));
    while(1);
}


DWORD OEMGetSecs(void)
{
    SYSTEMTIME st;
    GetRealTimeFromCMOS( &st );
    return ((60UL * (60UL * (24UL * (31UL * st.wMonth + st.wDay) + st.wHour) + st.wMinute)) + st.wSecond);
}