VxWorks

开发平台：
C/C++

romInit.s：源码内容
							/* romInit.s - vxWorks ixdp425 initialization module */
/* Copyright 2002 Wind River Systems, Inc. */
/*
modification history
--------------------
01d,24sep02,jb3  Going for the Csr_Gold
01c,24sep02,jb  Changing memory timing
01b,12jun02,jb  Continuing restructure
01a,05jun02,jb  initial version...
*/
#define _ASMLANGUAGE
#include "vxWorks.h"
#include "arch/arm/arm.h"
#include "arch/arm/mmuArmLib.h"
#include "ixp425.h"
#include "ixdp425.h"
/* macros fail in diab #include "debugutils.h" */
#include "sysLib.h"
#include "config.h"
	.data
        .globl  FUNC(copyright_wind_river)
        .long   FUNC(copyright_wind_river)
/*
DESCRIPTION
This module contains the entry code for VxWorks images that start
running from ROM, such as 'bootrom' and 'vxWorks_rom'.
The entry point, romInit(), is the first code executed on power-up.
It performs the minimal setup needed to call the
generic C routine romStart() with parameter BOOT_COLD.
The routine romInit() masks interrupts in the processor, initialises
the MMU, sets the initial stack pointer (to STACK_ADRS which is defined
in configAll.h) and initialises system hardware including configuring
the DRAM controller. Other hardware and device initialisation is
performed later in the sysHwInit routine in sysLib.c.
The IXP425 device has a mechansim to "swap" the Expansion bus CS0 and SDRAM
decode spaces. i.e RAM can be moved to zero (where the vectors live)
without resorting to the use of the MMU.
The routine sysToMonitor() jumps to a location after the beginning of
romInit, (defined by ROM_WARM_ADRS) to perform a "warm boot". This
entry point allows a parameter to be passed to romStart().
It first has to disable the MMU, though, as romInit will disable it
during initialization.
The routines in this module don't use the "C" frame pointer %r11@ ! or
establish a stack frame.
SEE ALSO:
.I "ARM Architecture Reference Manual,"
.I "IXP425 Data Manual,"
*/
#define INIT_SDRAM	 (1)
#define XSCALE_WB_COAL_ENABLE (1)
/* debug routines */
#define IMMED1 #1
#define DELAY(cycles, reg0)	
	ldr	reg0, = cycles ;	
	subs	reg0, reg0, IMMED1 ;	
	subne	pc,	pc, IMMED12 ;
#define DEBUG_UART 			(1)  /* Enable Debug uart output */
#define UART_REG_SPREAD (2)
#define UART_DMABodgeDelay              10
#define UARTLCR_DivisorLatchAccess (1<<7)
#define UART_LineControl           (0x03  << UART_REG_SPREAD)
#define BaudRateDivisor_115200     1
#define BaudRateDivisor_9600       0x60
#define UART_DivisorLatchLSB       ( 0x00 << UART_REG_SPREAD )
#define UART_DivisorLatchMSB       ( 0x01 << UART_REG_SPREAD )
#define UARTLCR_CharLength8        (3<<0)
#define UARTLCR_StopBits1          (0<<2)
#define UART_InterruptEnable       0x01
#define UARTFCR_Enable	           (1<<0)
#define UART_FIFOControl           (0x02 << UART_REG_SPREAD )
#define UARTFCR_RXReset            (1<<1)
#define ARTFCR_TXReset             (1<<2)
#define UARTFCR_Mode0RXRDYTXRDY    (0<<3)
#define UARTFCR_RXTrigger1         (0<<6)
#define UARTMCR_DTRActive          (1<<0)
#define UART_ModemControl          (4 << UART_REG_SPREAD )
#define UART_LineStatus            (5 << UART_REG_SPREAD )
#define UART_Transmit              (0  << UART_REG_SPREAD )
#define UARTLSR_TXHoldingEmpty     (1<<5)
.macro	LED	value
/*enable gpio 4 5 6*/
         ldr r0, =0x3f87
         ldr r1, =IXP425_GPIO_GPOER
         str r0, [r1]	
/*determine which gpio should be led*/
        ldrh r0, =value
        mov r0,	r0, LSL#4
        ldr r1, =0xffff
        eor	r0, r0, r1
        ldr r1, =IXP425_GPIO_GPOUTR
        str r0, [r1]
.endm
/* reset the kendin switch chip */
.macro RESET_NET
	ldr r0, =0x0
	ldr r1, =IXP425_GPIO_GPOUTR
	str r0, [r1]
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	nop
	ldr r0, =0x8
	str r0, [r1]
.endm
        .data
        .align 4
        .globl  VAR(sdata)
VAR_LABEL(sdata) .asciz  "start of data seg"
        .text
        .align 4
        /* externals */
        .extern FUNC(romStart)
        .extern FUNC(sysPhysMemSize)
        /* globals */
        .globl  FUNC(romInit)
        .globl  _romInit
	.globl	_vectorTable
	.globl	FUNC(sysRomVecUndefInstuc)
	.globl	FUNC(sysRomVecSoftwareInt)
	.globl	FUNC(sysRomVecPrefetchAbort)
	.globl	FUNC(sysRomVecDataAbort)
	.globl	FUNC(sysRomVecUnknow)
	.globl	FUNC(sysRomVecIRQ)
	.globl	FUNC(sysRomVecFIQ)
	.globl	FUNC(sysRomVecDefault)
	.globl  FUNC(UARTVString)
	.globl  vxWorks_boot
	.globl  FUNC(binArrayStart)
	.globl  FUNC(binArrayEnd)
_start:
/*******************************************************************************
*
* vectorTable - vector jump tabel
*
*/
/* All vectors destroys r0, r1, and r2 */
	/* Register Usage:
	* r0 contains the vector number but used for temp use
	* r1 should contain the vector number in 7seg format
	* r2 Used for temp use
	*/
_vectorTable:
        ldr     pc, =0x1000
        B       FUNC(sysRomVecUndefInstuc)
        B       FUNC(sysRomVecSoftwareInt)
        B       FUNC(sysRomVecPrefetchAbort)
        B       FUNC(sysRomVecDataAbort)
        B       FUNC(sysRomVecUnknow)
        B       FUNC(sysRomVecIRQ)
        B       FUNC(sysRomVecFIQ)
_ARM_FUNCTION(sysRomVecUndefInstuc)
        ldr     pc, UNDEFINSInt
_ARM_FUNCTION(sysRomVecSoftwareInt)
        ldr     pc, SOFTWAREINTIsr
_ARM_FUNCTION(sysRomVecPrefetchAbort)
        ldr     pc, PREFETCHABORTIsr
_ARM_FUNCTION(sysRomVecDataAbort)
        ldr     pc, VECDATAABORTIsr
_ARM_FUNCTION(sysRomVecUnknow)
        ldr     pc, UNKNOWVECIsr
_ARM_FUNCTION(sysRomVecIRQ)
        ldr     pc, IRQRAMIsr
_ARM_FUNCTION(sysRomVecFIQ)
        ldr     pc, FIQRAMIsr
	.balign 0x100
UNDEFINSInt:
	.long FUNC(sysRomVecUndefInstuc)
SOFTWAREINTIsr:
	.long FUNC(sysRomVecSoftwareInt)
PREFETCHABORTIsr:
	.long FUNC(sysRomVecPrefetchAbort)
VECDATAABORTIsr:
	.long FUNC(sysRomVecDataAbort)
UNKNOWVECIsr:
	.long FUNC(sysRomVecUnknow)
IRQRAMIsr:
	.long FUNC(sysRomVecIRQ)
FIQRAMIsr:
	.long FUNC(sysRomVecFIQ)
	.balign 0x1000
/* any data added here should reflect in ROM_TEXT_BASE in Makefile as well as in config.h */
/*******************************************************************************
*
* romInit - entry point for VxWorks in ROM
*
* This is the start of the ROM code.  The CPU will vector here upon reset.
*
* romInit
*     (
*     int startType     /@ only used by 2nd entry point @/
*     )
*
* INTERNAL
* sysToMonitor examines the ROM for the first instruction and the string
* "Copy" in the third word so if this changes, sysToMonitor must be updated.
*
* Register r8 holds startType until jump to the code that starts the whole
* vxWorks boot process
*
*/
_ARM_FUNCTION(romInit)
_romInit:
cold:
        MOV     r0, #BOOT_COLD   /* fall through to warm boot entry */
        
warm:
        B       bootStart
        /* copyright notice appears at beginning of ROM (in TEXT segment) */
        .ascii  "Copyright 2000 Wind River Systems, Inc. "
        .align 4
bootStart:
        MOV     r8, r0           /* store off startType */
        /* disable interrupts in CPU and switch to SVC32 mode */
        MRS     r1, cpsr
        BIC     r1, r1, #MASK_MODE
        ORR     r1, r1, #MODE_SVC32 | I_BIT | F_BIT
        MSR     cpsr, r1
        /*
         * CPU INTERRUPTS DISABLED
         *
         * Set processor and MMU to known state as follows (we may have not
         * been entered from a reset):
         *
         * MMU Control Register layout.
         *
         * bit
         *  0 M 0 MMU disabled
         *  1 A 0 Address alignment fault disabled, initially
         *  2 C 0 Data cache disabled
         *  3 W 0 Write Buffer disabled
         *  4 P 1 Should Be One (PROG32 on earlier CPUs)
         *  5 D 1 Should Be One (DATA32 on earlier CPUs)
         *  6 L 1 Should Be One (Late abort on earlier CPUs)
         *  7 B 1 Little-endian  ( Turn no Big Endian mode )
         *  8 S 0 System bit to zero } Modifies MMU protections, not really
         *  9 R 0 ROM bit to one     } relevant until MMU switched on later.
         * 10 F 0 Should Be Zero
         * 11 Z 0 Should Be Zero (Branch prediction control on 810)
         * 12 I 0 Instruction cache disabled
         *
         * Setup MMU Control Register
         */
        /* MOV     r1, #MMU_INIT_VALUE  */
        MOV     r1, #0x80
        MCR     CP_MMU, 0, r1, c1, c0, 0        /* Write to MMU CR */
	NOP
	NOP
	NOP
	NOP
	NOP
        LED 0x1
        
        RESET_NET
        /*
         * MMU is now off => addresses are physical addresses, no protection.
         *
         * If MMU was on before this, then we'd better hope it was set up
         * for flat translation (at least of this code) or there will
         * be problems. The next three instructions will still be
         * fetched "translated".
         *
         * Set Process ID Register to zero, this effectively disables
         * the process ID remapping feature.
         */
        MOV     r1, #0
        MCR     CP_MMU, 0, r1, c13, c0, 0
        MRC     CP_MMU, 0, r7, c0, c0, 0
        AND     r7,r7,#0xF
/*** Disable Write Buffer Coalescing ***/
	mcr		p15, 0, r0, c7, c10, 4  /* Drain write/fill buffers */
	CPWAIT(r0)				/* wait for the write to happen */
	CPWAIT(r0)				/* wait for the write to happen */
	mrc		p15, 0, r0, c1, c0, 1   /* Read Auxiliary Control Reg */
	orr		r0, r0, #0x00000001     /* Disable Coalescing */
	mcr		p15, 0, r0, c1, c0, 1   /* Write Auxiliary Control Reg */
	CPWAIT(r0)				/* wait for the write to happen */
	NOP
	NOP
/* fall through to warm boot entry */
        cmp     r8, #BOOT_COLD
        bne     warm_start
/*establish UART for debug... */
        bl              UARTStart
#if DEBUG_UART
	ldr r0 ,_debugStr1
	bl FUNC(UARTVString)
#endif
#ifdef INIT_SDRAM
/*read the GPIO 8 9 to identity size of sdram*/
        ldr     r1,     =IXP425_GPIO_GPINR
        ldr     r1,     [r1]
        mov    r1,     r1,    LSR#8
        and     r1,     r1,    #3
        /* set sdram config address */
        ldr  r9, L$LIXP425_SDRAM_CONFIG
        
        cmp     r1,     #0x0
        bne     1f
        /* 64M sdram */        
        mov r10, #SZ_64M
        ldr 	r2, L$LSDRAM_CONFIG_64MEG
        b       4f
        
 1:
        cmp     r1,     #0x1
        bne     2f
        /* 256M sdram*/
        mov r10, #SZ_256M
        ldr 	r2, L$LSDRAM_CONFIG_256MEG
        str     r2, [r9, #0]
        b       4f
        
 2:
        cmp    r1,     #0x2
        bne     3f
        /* 128M sdram */
        mov r10, #SZ_128M
        ldr 	r2, L$LSDRAM_CONFIG_128MEG
        str     r2, [r9, #0]
        b       4f
        
3:
	b       3b
4:
        /* config sdram size ok */
	LED 0x2
init_dram:
/* Disable refresh Cycles */
	ldr		r9,L$LIXP425_SDRAM_REFRESH
	ldr		r0,L$LIXP425_SDRAM_REFRESH_DISABLE
	str		r0, [r9, #0]		/* Disable Refresh Cycle */
	DELAY(0x4000, r0)
/* Issue a NOP Command to all SDRAM devices */
	ldr		r9, L$LIXP425_SDRAM_INSTRUCTION
	ldr		r0, L$LIXP425_SDRAM_IR_NOP_CMD
	str		r0, [r9, #0]		/* Issue NOP cmd to SDRAM */
	DELAY(0x4000, r0)
	ldr		r9,L$LIXP425_SDRAM_REFRESH
	ldr		r0,L$LIXDP425_SDRAM_CONFIG_REFRESH_CNT
	str		r0, [r9, #0]		/* Set refresh value  */
	DELAY(0x4000, r0)
/* Send a PrechargeAll Command to all SDRAM devices */
	ldr		r9,L$LIXP425_SDRAM_INSTRUCTION
	ldr		r0,L$LIXP425_SDRAM_IR_PRECHARGE_ALL_CMD
	str		r0, [r9, #0]	/* Precharge all */
	DELAY(0x4000, r0)
/* Send 8 AutoRefresh Command. There should Trc cycles between every AutoRefresh */
/* Trc = 70ns for devices used here,  */
	ldr		r9,L$LIXP425_SDRAM_INSTRUCTION
	ldr		r0,L$LIXP425_SDRAM_IR_AUTOREFRESH_CMD
	str		r0, [r9, #0]	/* Auto Refresh #1 */
	DELAY(0x100, r0)
	str		r0, [r9, #0]	/* Auto Refresh #2 */
	DELAY(0x100, r0)
	str		r0, [r9, #0]	/* Auto Refresh #3 */
	DELAY(0x100, r0)
	str		r0, [r9, #0]	/* Auto Refresh #4 */
	DELAY(0x100, r0)
	str		r0, [r9, #0]	/* Auto Refresh #5 */
	DELAY(0x100, r0)
	str		r0, [r9, #0]	/* Auto Refresh #6 */
	DELAY(0x100, r0)
	str		r0, [r9, #0]	/* Auto Refresh #7 */
	DELAY(0x100, r0)
	str		r0, [r9, #0]	/* Auto Refresh #8 */
	DELAY(0x100, r0)
/* Send Mode Reg Set Cmd with CAS Latency 3 */
	ldr		r9,L$LIXP425_SDRAM_INSTRUCTION
	ldr		r0,L$LIXP425_SDRAM_IR_MODE_SET_CAS3_CMD
	str		r0, [r9, #0]	/* Send Mode Select Command */
	DELAY(0x4000, r0)
	ldr		r9,L$LIXP425_SDRAM_INSTRUCTION
	ldr		r0,L$LIXP425_SDRAM_IR_NORMAL_OPERATION_CMD
	str		r0, [r9, #0x00000000]	        /* Issue aNormal Operation command */
#endif /* INIT_SDRAM */
#if DEBUG_UART
	ldr r0 ,_debugStr6
	bl FUNC(UARTVString)
#endif
/*************** SDRAM Config Complete *******************************************/
	/* DebugOutVal INFO_CODE_9 */
	LED 0x3
/* Enable Coprocessors access */
        ldr             r0, =0x001
        mcr             p15, 0, r0, c15, c1, 0
        mcr             p15, 0, r0, c7, c10, 4  /* Drain write/fill buffers */
	CPWAIT(r0)				/* wait for the write to happen */
/* Invalidate I-Cache, D-Cache, and BTB */
        mcr             p15, 0, r0, c7, c7, 0
	CPWAIT(r0)				/* Wait */
/*
 * Set the CS0 setting for Flash to optimum timings.
 */
	ldr	r0,L$LIXP425_EXP_CS0_REG
	ldr	r1,L$LIXDP425_FLASH_CS_DEFAULT
	str	r1,[r0]
	LED 0x4
/*** Enable Write Buffer Coalescing ***/
#if XSCALE_WB_COAL_ENABLE
	mcr		p15, 0, r0, c7, c10, 4  /* Drain write/fill buffers */
	CPWAIT(r0)				/* wait for the write to happen */
	CPWAIT(r0)				/* wait for the write to happen */
	mrc		p15, 0, r0, c1, c0, 1   /* Read Auxiliary Control Reg */
	and		r0, r0, #0xfffffffe    	/* Enable Coalescing */
	mcr		p15, 0, r0, c1, c0, 1   /* Write Auxiliary Control Reg */
	CPWAIT(r0)				/* wait for the write to happen */
	NOP
	NOP
#endif
warm_start:
/* Disable Interrupts */
        MRS     r1, cpsr                /* get current status */
        ORR     r1, r1, #I_BIT | F_BIT  /* disable IRQ and FIQ */
        MSR     cpsr, r1
/* Interrupts Disabled */
        ldr     r0, =IXP425_ICMR  /* Zero-out Interrupt Mask */
        mov     r2, #0x0
        str     r2, [r0]
/* 3: Jump to here + New FLash Location */
/* We could jump upto location in Flash,
 * But we have already copied enough code to
 * low ram to continue code execution from here
 */
	ldr	r0,=IXP425_EXPANSION_BUS_BASE2
        orr	r0,r0,pc
	mov	pc,r0
/* 4: Write to Expansion Bus controller to swap Flash & Ram */
	ldr	r0,=IXP425_EXP_CNFG0
	ldr	r1,[r0]
	and	r1,r1,#0x7FFFFFFF
	str	r1,[r0]
/*
 * End of switch , should now be running in Flash in its relocated position.
 */
/* Enable Coprocessors access */
        ldr     r0, =0x001
        mcr     p15, 0, r0, c15, c1, 0
        mcr     p15, 0, r0, c7, c10, 4  /* Drain write/fill buffers */
	CPWAIT(r0)				/* wait for the write to happen */
#ifdef ROM_ENABLES_MMU
/* Invalidate I-Cache, D-Cache, and BTB */
        mcr     p15, 0, r0, c7, c7, 0
	CPWAIT(r0)			/* Wait */
/* If Enable Instruction Cache */
        mrc     p15, 0, r0, c1, c0, 0   /* Read Control Register*/
        orr     r0, r0, #0x1000         /* Set I-Cache bit */
        mcr     p15, 0, r0, c1, c0, 0   /* Write Back Control Register */
	CPWAIT(r0)			/* Wait */
/* Set Translation Table Base */
        ldr     r0, =MMU_TRANSLATION_BASE
        mcr     p15, 0, r0, c2, c0, 0   /* Set Translation Table Base Register */
/* Invalidate Instruction, Data TLBs */
        mcr     p15, 0, r0, c8, c7, 0   /* Flush I & D TLBs*/
	CPWAIT(r0)			/* Wait */
/* Set Domain Access Control Register */
        ldr     r0, =0xffffffff         /* Set All 16 domains to manager access */
        mcr     p15, 0, r0, c3, c0, 0   /* Set Domain Permissions */
/* Enable MMU */
        mrc     p15, 0, r0, c1, c0, 0   /* Read Control Register */
        orr     r0, r0, #0x00000001     /* Enable MMU */
        mcr     p15, 0, r0, c1, c0, 0   /* Write Back the Control Register */
	CPWAIT(r0)			/* Wait */
/* Drain Write/Fill Buffers */
        mcr     p15, 0, r0, c7, c10, 4  /* Drain */
	CPWAIT(r0)			/* Wait */
/* Enable Data Cache */
        mrc     p15, 0, r0, c1, c0, 0   /* Read Control Reg */
        orr     r0, r0, #0x00000004             /* Enable Data Cache */
        mcr     p15, 0, r0, c1, c0, 0   /* Write Back */
	CPWAIT(r0)			/* Wait */
/* Enable Branch Target Buffer */
        mrc     p15, 0, r0, c1, c0, 0   /* Read Control Reg */
        orr     r0, r0, #0x00000800             /* Enable BTB */
        mcr     p15, 0, r0, c1, c0, 0   /* Write Back the Control Reg */
	CPWAIT(r0)			/* Wait */
#endif /* ROM_ENABLES_MMU */
/******************************************************************************/
/******************************************************************************/
	/* DebugOutVal INFO_CODE_E */
        LED 0x5
vxWorks_boot:
/*  Now jump to the code that starts the whole vxWorks boot process */
	mov	r0, r8
	ldr	sp, L$STACK_ADDR
	ldr	pc, L$StrtInFlash
/******************************************************************************/
/******************************************************************************/
/************************** UART Helpers ******************************************/
_ARM_FUNCTION(UARTVString)
/* Do nothing as byte reads from flash not allowed */
	mov	        pc, lr
        ldr             r10, =IXP425_UART1_BASE
UARTNextChar:
        ldrb            r1, [r0], #1
        teq             r1, #0
        beq             URATTxDone
        /* UARTTextOut     r10, r1, r2 */
        and             r1, r1, #0xff
/* Modified, don't even check if there is room in the transfer fifi`o just jut it.. TODO : remove later, on real card */
/*
        ldr             r10, =IXP425_UART1_BASE
        ldr             r2, [r10, #UART_LineStatus]
        TST             r2. #UARTLSR_TXHoldingEmpty
        BEQ             10b
*/
        str             r1, [r10, #UART_Transmit] /* strb */
/*Start-  Included to slow down writes to simultor : TODO: Remove later */
	DELAY(0x200, r3)
/*End-  Included to slow down writes to simultor : TODO: Remove later */
        B               UARTNextChar
URATTxDone:
        mov             r1, #13
        /* UARTTx          r10, r1, r2 */
        mov             r1, #10
        str             r1, [r10, #UART_Transmit] /* strb */
        /* UARTTx          r10, r1, r2 */
        str             r1, [r10, #UART_Transmit] /* strb */
	mov	        pc, lr
/*
Better don't use r0, r1, r2 and r10s
Uses r0, r10
*/
UARTStart:
	ldr	        r10, =IXP425_UART1_BASE
	ldr	        r0, =UART_DMABodgeDelay
UARTDelay:
	subs	        r0, r0, #1
	bne	        UARTDelay
    /* enable access to divisor registers */
	mov	        r0, #UARTLCR_DivisorLatchAccess
	str	        r0, [r10, #UART_LineControl] /* strb */
	ldr	        r0, =UART_DMABodgeDelay
UARTDelay1:
	subs	        r0, r0, #1
	bne	        UARTDelay1
    /* select baud rate */
/* 115200 Baud */
/*	ldr	        r0, =BaudRateDivisor_115200 	 */
/*	strb	        r0, [r10, #UART_DivisorLatchLSB] */
/*	mov	        r0, r0, LSR #8 			 */
/*	strb	        r0, [r10, #UART_DivisorLatchMSB] */
	ldr	        r0, =BaudRateDivisor_9600
	str	        r0, [r10, #UART_DivisorLatchLSB] /*strb  */
	mov	        r0, r0, LSR #8
	str	        r0, [r10, #UART_DivisorLatchMSB]  /* strb */
    /* 8 data, 1 stop, no parity */
	mov	        r0, #UARTLCR_CharLength8 | UARTLCR_StopBits1
    /* also disable access to divisor regs */
	str	        r0, [r10, #UART_LineControl] /* strb */
    /* no irqs , but enable the UART on IXP425 */
	mov	        r0, #0x40
	str	        r0, [r10, #UART_InterruptEnable] /* strb */
	mov             r0, #UARTFCR_Enable
	str            r0, [r10, #UART_FIFOControl] /* strb */
	/* turn fifos on */
	mov             r0, #UARTFCR_RXReset | ARTFCR_TXReset | UARTFCR_Mode0RXRDYTXRDY | UARTFCR_RXTrigger1
	str            r0, [r10, #UART_FIFOControl] /* strb */
    /* make DTR active, RTS inactive, stop other end */
	mov	        r0, #UARTMCR_DTRActive
	str	        r0, [r10, #UART_ModemControl] /* strb */
	mov	        pc, lr
_debugStr1: .asciz  "IXP425 Uart initialized"
_debugStr2: .asciz  "IXP425 Memory Config 32 Mbytes"
_debugStr3: .asciz  "IXP425 Memory Config 64 Mbytes"
_debugStr4: .asciz  "IXP425 Memory Config 128 Mbytes"
_debugStr5: .asciz  "IXP425 Memory Config  Error"
_debugStr6: .asciz  "IXP425 Memory Config Complete"
_debugStr7: .asciz  "IXP425 Memory Config 256 Mbytes"
	.align 4
/* TODO: Resolve these addresses for real. */
L$StrtInRam:    .long   FUNC(romStart) - FUNC(romInit)
L$StrtInFlash:	.long   ROM_TEXT_ADRS + FUNC(romStart) - FUNC(romInit)
L$STACK_ADDR:	.long	STACK_ADRS
L$LIXP425_EXP_CS0_REG:				.long	IXP425_EXP_CS0_REG
L$LIXDP425_FLASH_CS_DEFAULT:			.long	IXDP425_FLASH_CS_DEFAULT
/* SDRAM Literals */
L$LIXP425_SDRAM_CONFIG_BASE:			.long	IXP425_SDRAM_CONFIG_BASE
L$LSDRAM_CONFIG_32MEG:				.long	SDRAM_CONFIG_32MEG
L$LSDRAM_CONFIG_64MEG:				.long   SDRAM_CONFIG_64MEG
L$LSDRAM_CONFIG_128MEG:				.long	SDRAM_CONFIG_128MEG
L$LSDRAM_CONFIG_256MEG:				.long	SDRAM_CONFIG_256MEG
L$LIXP425_SDRAM_CONFIG:				.long   IXP425_SDRAM_CONFIG
L$LIXP425_SDRAM_REFRESH: 			.long 	IXP425_SDRAM_REFRESH
L$LIXP425_SDRAM_REFRESH_DISABLE:		.long 	IXP425_SDRAM_REFRESH_DISABLE
L$LIXP425_SDRAM_INSTRUCTION:			.long   IXP425_SDRAM_INSTRUCTION
L$LIXP425_SDRAM_IR_NOP_CMD:			.long   IXP425_SDRAM_IR_NOP_CMD
L$LIXDP425_SDRAM_CONFIG_REFRESH_CNT:		.long   IXDP425_SDRAM_CONFIG_REFRESH_CNT
L$LIXP425_SDRAM_IR_PRECHARGE_ALL_CMD:		.long   IXP425_SDRAM_IR_PRECHARGE_ALL_CMD
L$LIXP425_SDRAM_IR_AUTOREFRESH_CMD:		.long   IXP425_SDRAM_IR_AUTOREFRESH_CMD
L$LIXP425_SDRAM_IR_MODE_SET_CAS3_CMD:		.long	IXP425_SDRAM_IR_MODE_SET_CAS3_CMD
L$LIXP425_SDRAM_IR_NORMAL_OPERATION_CMD:	.long   IXP425_SDRAM_IR_NORMAL_OPERATION_CMD
/* DebugOutInitLiteral */
L$CS2_REG: .long 0xc4000008
L$CS2_VAL: .long 0xBFFF0002

						