main.c

PXA270的EBOOT源代码！可以启动wince内核

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
//------------------------------------------------------------------------------
//
//  File:  main.c
//
//  Core routines for the Intel Mainstone II bootloader.
//
#include <windows.h>
#include <nkintr.h>
#include <bulverde.h>
#include <mainstoneii.h>
#include <oal_memory.h>
#include <pcireg.h>
#include <fmd.h>
#include <xllp_pccardsocket.h>
#include <xllp_lcd.h>
#include <bsp.h>
#include "xllp_defs.h"
#include "loader.h"
#ifndef DEBUG
#include "startImage.c"
#endif

#define MAX_LINE_LENGTH				130
#define MAX_SCROLLBACK				20
#define MARATHON_LCD_CONFIG			0x60

// Big ugly hack because of conflicting defines
#undef NONE
#define NONE -1

#define MARATHON_VLIO_CHIP_SELECT	5
#define MARATHON_SRAM_CHIP_SELECT	1

#define MEMC_REG_MAP_SIZE			(4*1024)	// 4K
#define MEMC_REG_PHYSICAL_ADDR		(0x48000000)

#define CLK_REG_MAP_SIZE            (4*1024)
#define CLK_REG_PHYSICAL_ADDR       (0x41300000)
#define BULVERDE_REFCLK             13000000
#define COTULLA_REFCLK				3686400     

#define MARATHON_SCRATCH1			0x0104
#define MARATHON_SCRATCH2			0x0108

#define CPU_SYSCLOCK				13000000

#define MARATHON_GPIO_CONFIG			0x6c
#define MARATHON_GPIO0_DIRECTION		0x01
#define MARATHON_GPIO1_DIRECTION		0x02
#define MARATHON_GPIO0_DRIVESTRENGTH	0x04
#define MARATHON_GPIO1_DRIVESTRENGTH	0x08

#define MARATHON_GPIO_SR				0x70
#define MARATHON_GPIO_SR0				0x01
#define MARATHON_GPIO_SR1				0x02

#define DMA_DESC_SIZE               0x20
#define PALETTE_BUFFER_SIZE         0x400
#define FRAME_BUFFER_SIZE           0x96000
#define DISPLAY_BUFFER_SIZE         0x2b0000
#define ZBANK_BASE_C_VIRTUAL        0x96500000	// Should be the same as defined in config.bib

// Note: the following defines are duplicated in memdefs.h
// display base address won't be valid at eboot time, so hardcore it and recalculate the 
// rest of buffer address baesd on it
#define DISPLAY_BASE_PHYSICAL		0xA3A00000
#define DISPLAY_BASE_VIRTUAL		(UINT32)OALPAtoCA(DISPLAY_BASE_PHYSICAL)

#define DMA_CHANNEL_0_FRAME_DESCRIPTOR_BASE_PHYSICAL      (DISPLAY_BASE_PHYSICAL + 0)
#define DMA_CHANNEL_0_FRAME_DESCRIPTOR_BASE_VIRTUAL       (DISPLAY_BASE_VIRTUAL + 0)

#define DMA_CHANNEL_1_FRAME_DESCRIPTOR_BASE_PHYSICAL      (DMA_CHANNEL_0_FRAME_DESCRIPTOR_BASE_PHYSICAL + DMA_DESC_SIZE)
#define DMA_CHANNEL_1_FRAME_DESCRIPTOR_BASE_VIRTUAL       (DMA_CHANNEL_0_FRAME_DESCRIPTOR_BASE_VIRTUAL + DMA_DESC_SIZE)

#define DMA_CHANNEL_0_ALT_FRAME_DESCRIPTOR_BASE_PHYSICAL  (DMA_CHANNEL_1_FRAME_DESCRIPTOR_BASE_PHYSICAL + DMA_DESC_SIZE)
#define DMA_CHANNEL_0_ALT_FRAME_DESCRIPTOR_BASE_VIRTUAL   (DMA_CHANNEL_1_FRAME_DESCRIPTOR_BASE_VIRTUAL + DMA_DESC_SIZE)

#define PALETTE_FRAME_DESCRIPTOR_BASE_PHYSICAL            (DMA_CHANNEL_0_ALT_FRAME_DESCRIPTOR_BASE_PHYSICAL + DMA_DESC_SIZE)
#define PALETTE_FRAME_DESCRIPTOR_BASE_VIRTUAL             (DMA_CHANNEL_0_ALT_FRAME_DESCRIPTOR_BASE_VIRTUAL + DMA_DESC_SIZE)

#define PALETTE_BUFFER_BASE_PHYSICAL                      (PALETTE_FRAME_DESCRIPTOR_BASE_PHYSICAL + DMA_DESC_SIZE)
#define PALETTE_BUFFER_BASE_VIRTUAL                       (PALETTE_FRAME_DESCRIPTOR_BASE_VIRTUAL + DMA_DESC_SIZE)

#define FRAME_BUFFER_0_BASE_PHYSICAL                      (PALETTE_BUFFER_BASE_PHYSICAL + PALETTE_BUFFER_SIZE)
#define FRAME_BUFFER_0_BASE_VIRTUAL                       (PALETTE_BUFFER_BASE_VIRTUAL + PALETTE_BUFFER_SIZE)

#define FRAME_BUFFER_1_BASE_PHYSICAL                      (FRAME_BUFFER_0_BASE_PHYSICAL + FRAME_BUFFER_SIZE)
#define FRAME_BUFFER_1_BASE_VIRTUAL                       (FRAME_BUFFER_0_BASE_VIRTUAL + FRAME_BUFFER_SIZE)

#define DMA_CHANNEL_2_Y_FRAME_DESCRIPTOR_BASE_PHYSICAL    (FRAME_BUFFER_1_BASE_PHYSICAL + FRAME_BUFFER_SIZE)
#define DMA_CHANNEL_2_Y_FRAME_DESCRIPTOR_BASE_VIRTUAL     (FRAME_BUFFER_1_BASE_VIRTUAL + FRAME_BUFFER_SIZE)

#define DMA_CHANNEL_3_Cb_FRAME_DESCRIPTOR_BASE_PHYSICAL   (DMA_CHANNEL_2_Y_FRAME_DESCRIPTOR_BASE_PHYSICAL + DMA_DESC_SIZE)
#define DMA_CHANNEL_3_Cb_FRAME_DESCRIPTOR_BASE_VIRTUAL    (DMA_CHANNEL_2_Y_FRAME_DESCRIPTOR_BASE_VIRTUAL + DMA_DESC_SIZE)

#define DMA_CHANNEL_4_Cr_FRAME_DESCRIPTOR_BASE_PHYSICAL   (DMA_CHANNEL_3_Cb_FRAME_DESCRIPTOR_BASE_PHYSICAL + DMA_DESC_SIZE)
#define DMA_CHANNEL_4_Cr_FRAME_DESCRIPTOR_BASE_VIRTUAL    (DMA_CHANNEL_3_Cb_FRAME_DESCRIPTOR_BASE_VIRTUAL + DMA_DESC_SIZE)

#define OVERLAY2_PHYSICAL_BASE_ADDRESS                    (DMA_CHANNEL_4_Cr_FRAME_DESCRIPTOR_BASE_PHYSICAL + DMA_DESC_SIZE)
#define OVERLAY2_VIRTUAL_BASE_ADDRESS                     (DMA_CHANNEL_4_Cr_FRAME_DESCRIPTOR_BASE_VIRTUAL + DMA_DESC_SIZE)

#define RED18(x) (((x) & 0x3f) << 12)
#define GREEN18(z) (((z) &0x3f) << 6)
#define BLUE18(y) (((y) & 0x3f) << 0) 
#define PACK18(r,g,b) (UINT32) ( RED18(r) | GREEN18(g) | BLUE18(b));

#define RED16(x) ((x & 0x1f) << 11)
#define GREEN16(z) ((z &0x3f) << 5)
#define BLUE16(y) ((y & 0x1f) << 0) 
#define PACK16(r,g,b) (UINT32) (RED16(r) | GREEN16(g) | BLUE16(b));

//------------------------------------------------------------------------------
// Local variables.
//
static PCI_REG_INFO g_FlashAddress;
static EBOOT_CFG    g_EbootCFG;
static BOOLEAN      g_DownloadImage = TRUE;

//------------------------------------------------------------------------------
// Global variables.
//
DWORD     EdbgDebugZone;
FlashInfo g_FlashInfo;
BSP_ARGS *g_pBSPArgs = (BSP_ARGS *) IMAGE_SHARE_ARGS_UA_START;
EDBG_ADDR g_DeviceAddr; // NOTE: global used so it remains in scope throughout download process
                        // since eboot library code keeps a global pointer to the variable provided.
XLLP_PCCARDSOCKET_T strEbtPCCardSocketHandle;
IMAGE_TYPE g_ImageType;

// Pass through mode strings for toggling through the menu selection.
static const UINT8 *sg_pu8MarathonPassthroughText[] =
{
	"Disabled",
	"LCD 1",
	"LCD 2",
	"LCD 1 & LCD 2"
};

static const UINT8 *sg_pu8RunModeText[] =
{
    "Run Mode   = ",
    "Turbo Mode = Run Mode",
    "Turbo Mode = 1.5 * Run Mode",
    "Turbo Mode = 2 * Run Mode",
    "Turbo Mode = 2.5 * Run Mode",
    "Turbo Mode = 3 * Run Mode",
    "Turbo Mode = 3.5 * Run Mode",
    "Turbo Mode = 4 * Run Mode",
};

static const UINT8 *sg_pu8RunModeArray[] =
{
    "26 MHz",
    "26 MHz",
    "26 MHz",
    "39 MHz",
    "52 MHz",
    "65 MHz",
    "78 MHz",
    "91 MHz",
    "104 MHz",
    "117 MHz",
    "130 MHz",
    "143 MHz",
    "156 MHz",
    "169 MHz",
    "182 MHz",
    "195 MHz",
    "208 MHz",
    "221 MHz",
    "234 MHz",
    "247 MHz",
    "260 MHz",
    "273 MHz",
    "286 MHz",
    "299 MHz",
    "312 MHz",
    "325 MHz",
    "338 MHz",
    "351 MHz",
    "364 MHz",
    "377 MHz",
    "390 MHz",
    "403 MHz",
};

static const UINT8 *sg_pu8A0MemClkArray[] =
{
    "26 MHz",              // L=0
    "26 MHz",              // L=1
    "26 MHz",              // L=2
    "39 MHz",              // L=3
    "52 MHz",              // L=4
    "65 MHz",              // L=5
    "78 MHz",              // L=6
    "91 MHz",              // L=7
    "104 MHz",             // L=8
    "117 MHz",             // L=9
    "130 MHz",             // L=10
    "71.5 MHz",            // L=11
    "78 MHz",              // L=12
    "84.5 MHz",            // L=13
    "91 MHz",              // L=14
    "97.5 MHz",            // L=15
    "104 MHz",             // L=16
    "110.5 MHz",           // L=17
    "117 MHz",             // L=18
    "124.5 MHz",           // L=19
    "130 MHz",             // L=20
    "68.25 MHz",           // L=21
    "71.5 MHz",            // L=22
    "74.75 MHz",           // L=23
    "78 MHz",              // L=24
    "81.25 MHz",           // L=25
    "84.5 MHz",            // L=26
    "87.75 MHz",           // L=27
    "91 MHz",              // L=28
    "94.25 MHz",           // L=29
    "97.5 MHz",            // L=30
    "100.75 MHz",          // L=31
};

static const UINT8 *sg_pu8A1B0MemClkArray[] =
{
    "13 MHz",            // L=0
    "13 MHz",            // L=1
    "13 MHz",            // L=2
    "19.5 MHz",          // L=3
    "26 MHz",            // L=4
    "32.5 MHz",          // L=5
    "39 MHz",            // L=6
    "45.5 MHz",          // L=7
    "52 MHz",            // L=8
    "58.5 MHz",          // L=9
    "65 MHz",            // L=10
    "71.5 MHz",          // L=11
    "78 MHz",            // L=12
    "84.5 MHz",          // L=13
    "91 MHz",            // L=14
    "97.5 MHz",          // L=15
    "104 MHz",           // L=16
    "110.5 MHz",         // L=17
    "117 MHz",           // L=18
    "124.5 MHz",         // L=19
    "130 MHz",           // L=20
    "136.5 MHz",         // L=21
    "143 MHz",           // L=22
    "149.5 MHz",         // L=23
    "156 MHz",           // L=24
    "162.5 MHz",         // L=25
    "169 MHz",           // L=26
    "175.5 MHz",         // L=27
    "182 MHz",           // L=28
    "188.5 MHz",         // L=29
    "195 MHz",           // L=30
    "201.5 MHz",         // L=31
};

static const UINT8 *sg_pu8A1B1MemClkArray[] =
{
    "26 MHz",            // L=0
    "26 MHz",            // L=1
    "26 MHz",            // L=2
    "39 MHz",            // L=3
    "52 MHz",            // L=4
    "65 MHz",            // L=5
    "78 MHz",            // L=6
    "91 MHz",            // L=7
    "104 MHz",           // L=8
    "117 MHz",           // L=9
    "130 MHz",           // L=10
    "143 MHz",           // L=11
    "156 MHz",           // L=12
    "169 MHz",           // L=13
    "182 MHz",           // L=14
    "195 MHz",           // L=15
    "208 MHz",           // L=16
};

extern OAL_ADDRESS_TABLE g_oalAddressTable[];

#ifndef DEBUG
//extern const unsigned char gImage_240x320[153600];
extern const unsigned char gImage_240x320[];
#endif

typedef enum
{
	LINE_OK,
	LINE_EXIT,
	LINE_UP,
	LINE_DOWN
} EStatus;

typedef enum
{
	LEX_EOF=256,
	LEX_CONSTANT,
	LEX_STRING,
	LEX_READ,
	LEX_WRITE,
	LEX_EXIT,
	LEX_DUMP,
	LEX_MAP,
	LEX_IDENTIFIER,
	LEX_BYTE,
	LEX_WORD,
	LEX_DWORD,
	LEX_DATASIZE,
	LEX_WRITEREAD,
	LEX_FILL
} ELex;

struct SIdentifierEntry
{
	UINT8 *pu8TextToMatch;
	ELex eToken;
};

static UINT8 *sg_pu8LexPos = NULL;
static UINT8 sg_u8YYLEX[MAX_LINE_LENGTH+1];
static UINT32 sg_u32Constant = 0;
static ELex sg_eDatasize = LEX_DWORD;

struct SCommandEntry
{
	ELex eToken;
	UINT32 (*CommandFunction)(void);
};

static struct SIdentifierEntry sg_sIdentifiers[] =
{
	{"write",				LEX_WRITE},
	{"read",				LEX_READ},
	{"exit",				LEX_EXIT},
	{"dump",				LEX_DUMP},
	{"d",					LEX_DUMP},
	{"map",					LEX_MAP},
	{"byte",				LEX_BYTE},
	{"word",				LEX_WORD},
	{"dword",				LEX_DWORD},
	{"datasize",			LEX_DATASIZE},
	{"writeread",			LEX_WRITEREAD},
	{"w",					LEX_WRITE},
	{"r",					LEX_READ},
	{"wr",					LEX_WRITEREAD},
	{"fill",				LEX_FILL},
	{"f",					LEX_FILL},
	{NULL}
};

struct SRegionName
{
	UINT32 u32CachedAddress;
	UINT8 *pu8TextName;
};

//------------------------------------------------------------------------------
// Local function prototypes.
//
static BOOL LoadEBootCFG(EBOOT_CFG *EBootCFG);
static BOOL StoreEBootCFG(EBOOT_CFG *EBootCFG);
static void ResetDefaultEBootCFG(EBOOT_CFG *pEbootCFG);

static void SetIP(EBOOT_CFG *pEbootCFG);
static void SetMask(EBOOT_CFG *pEbootCFG);
static void SetBootMe(EBOOT_CFG *pEbootCFG);
static void SetDelay(EBOOT_CFG *pEbootCFG);

BOOL OEMVerifyMemory(DWORD dwStartAddr, DWORD dwLength);

//------------------------------------------------------------------------------
// Marathon function prototypes.
static void MarathonPassthroughToggle(EBOOT_CFG *pEbootCFG);
static void MarathonSetPassthroughMode(EPassthroughType eMode);
static void MarathonICSet(EMarathonIC eMarathonICEnable);
static void MarathonPresenceAndRegisterCheck(void);
static BOOL MarathonPresenceCheck(void);
static void SetBacklightMarathonDrive(BOOL bEnabled);
static void XScaleMMCSetup(DWORD dwFreq);
static void PrintClockSettings(void);
DWORD ReadClkCfgRegister(void);
static void DumpGPIORegs(void);

void displayStartUpImage(void);
//------------------------------------------------------------------------------
// External function prorotypes.
//
extern void Launch(unsigned int uAddr);

static int IsSpace(UINT8 u8Character)
{
	if (' ' == u8Character || '\t' == u8Character || '\0' == u8Character)
	{
		return(TRUE);
	}
	else
	{
		return(FALSE);
	}
}

static int IsDigit(UINT8 u8Character)
{
	if (u8Character >= '0' && u8Character <= '9')
	{
		return(TRUE);
	}
	else
	{
		return(FALSE);
	}
}

static int ToUpper(UINT8 u8Character)
{
	if (u8Character >= 'a' && u8Character <= 'z')
	{
		return(u8Character - 32);
	}

	return(u8Character);
}


static int IsAlpha(UINT8 u8Character)
{
	if (ToUpper(u8Character) >= 'A' && ToUpper(u8Character) <= 'Z')
	{
		return(TRUE);
	}
	else
	{
		return(FALSE);
	}
}

static int stricmp(UINT8 *pu8String1, UINT8 *pu8String2)
{
	while (*pu8String1 && *pu8String2)
	{
		if (ToUpper(*pu8String1) != ToUpper(*pu8String2))
		{
			return(-1);
		}

		++pu8String1;
		++pu8String2;
	}

	if (*pu8String1 || *pu8String2)
	{
		return(-1);
	}
	return(0);
}

static UINT8 *EatWhitespace(UINT8 *pu8Buffer)
{
	while (IsSpace(*pu8Buffer) && *pu8Buffer != '\0')
	{
		++pu8Buffer;
	}

	return(pu8Buffer);
}

static void LexBegin(UINT8 *pu8InputBuffer)
{
	sg_pu8LexPos = EatWhitespace(pu8InputBuffer);
}

static void PrintHexDigit(UINT8 u8Digit)
{
	if (u8Digit > 9)
	{
		u8Digit += 7;
	}