syslib.c

三星S3C44b0开发板配套 vxworks

#error CPU not supported
#endif /* (CPU == ARMARCH4) */
#else /*(_BYTE_ORDER == _LITTLE_ENDIAN)*/
#if   (CPU == ARMARCH4)
    return    "wrSbcArm7 - ARM7TDMI (ARM) Big Endian";
#elif (CPU == ARMARCH4_T)
    return    "wrSbcArm7 - ARM7TDMI (Thumb) Big Endian";
#else
#error CPU not supported
#endif /* (CPU == ARMARCH4) */
#endif /*(_BYTE_ORDER == _LITTLE_ENDIAN)*/
    }

/******************************************************************************
*
* sysBspRev - return the bsp version with the revision eg 1.1/<x>
*
* This function returns a pointer to a bsp version with the revision.
* for eg. 1.1/<x>. BSP_REV is concatenated to BSP_VERSION to form the
* BSP identification string.
*
* RETURNS: A pointer to the BSP version/revision string.
*/

char * sysBspRev (void)
    {
    return (BSP_VERSION BSP_REV);
    }

/******************************************************************************
*
* sysHwInit - initialize the CPU board hardware
*
* This routine initializes various features of the hardware.
* Normally, it is called from usrInit() in usrConfig.c.
*
* NOTE: This routine should not be called directly by the user.
*
* RETURNS: N/A
*/

void sysHwInit (void)
    {

	/*  : added */
	portInit();
    rtl8019Init();
    s3cExcVecSet();
	
    /* install the IRQ/SVC interrupt stack splitting routine */

    _func_armIntStackSplit = sysIntStackSplit;
#ifdef INCLUDE_LCD	/*  : added */
    sysLcdInit(); /* initialize the LCD panel */

    sysLcdWriteString("   WindRiver    ", 1, 1);
#if (_BYTE_ORDER == _LITTLE_ENDIAN)
#if   (CPU == ARMARCH4)
    sysLcdWriteString("   SBC ARM7     ", 2, 1);
#else  /* ARMARCH4 */
    sysLcdWriteString("   SBC ARM7 (t) ", 2, 1);
#endif  /* ARMARCH4 */
#else /* (_BYTE_ORDER == _LITTLE_ENDIAN) */
#if   (CPU == ARMARCH4)
    sysLcdWriteString("  SBC ARM7 (BE) ", 2, 1);
#else  /* ARMARCH4 */
    sysLcdWriteString("  SBC ARM7 (tBE)", 2, 1);
#endif  /* ARMARCH4 */
#endif /* (_BYTE_ORDER == _LITTLE_ENDIAN) */
#endif /*INCLUDE_LCD*/
#ifdef INCLUDE_LED	/*  : added */
    sysLedInit(); /* initialize the LED */
#endif /*INCLUDE_LED*/
    /* Set the MAC address based on DIP setting
     * The least significant byte of the address is changed to
     * the value of the user DIP switch setting. SW4-D0 is the
     * least significant bit of this byte.  We invert the bits
     * so Open=0.
     */

    /*sysSngks32cMacAddr[5] = ~READ_USERDIP();*/	/*  : deleted */

#ifdef  FORCE_DEFAULT_BOOT_LINE
    strncpy(sysBootLine,DEFAULT_BOOT_LINE,strlen(DEFAULT_BOOT_LINE)+1);
#elif defined INCLUDE_VWARE_LAUNCH
    sysVwareBuildBootLine((char*)&sysSngks32cMacAddr);
#endif /* FORCE_DEFAULT_BOOT_LINE */

    sysSerialHwInit ();      /* initialize serial data structure */

    }

/******************************************************************************
*
* sysHwInit2 - additional system configuration and initialization
*
* This routine connects system interrupts and does any additional
* configuration necessary.
*
* RETURNS: N/A
*
* NOMANUAL
*
* Note: this is called from sysClkConnect() in the timer driver.
*/

void sysHwInit2 (void)
    {
    /* initialize the interrupt library and interrupt driver */


    intLibInit (S3C44B0X_INTNUMLEVELS, S3C44B0X_INTNUMLEVELS, INT_MODE);
    sngks32cIntDevInit();

    /* connect sys clock interrupt and auxiliary clock interrupt */

    (void)intConnect (INUM_TO_IVEC (INT_VEC_TIMER0), sysClkInt, 0);
    (void)intConnect (INUM_TO_IVEC (INT_VEC_TIMER1), sysAuxClkInt, 0);

    /* connect serial interrupt */
    sysSerialHwInit2();
    }

/******************************************************************************
*
* sysPhysMemTop - get the address of the top of physical memory
*
* This routine returns the address of the first missing byte of memory,
* which indicates the top of memory.
*
* Normally, the user specifies the amount of physical memory with the
* macro LOCAL_MEM_SIZE in config.h.  BSPs that support run-time
* memory sizing do so only if the macro LOCAL_MEM_AUTOSIZE is defined.
* If not defined, then LOCAL_MEM_SIZE is assumed to be, and must be, the
* true size of physical memory.
*
* NOTE: Do no adjust LOCAL_MEM_SIZE to reserve memory for application
* use.  See sysMemTop() for more information on reserving memory.
*
* RETURNS: The address of the top of physical memory.
*
* SEE ALSO: sysMemTop()
*/

char * sysPhysMemTop (void)
    {
    static char * physTop = NULL;

    if (physTop == NULL)
        {
#ifdef LOCAL_MEM_AUTOSIZE

        /* If auto-sizing is possible, this would be the spot.  */

#    error   "Dynamic memory sizing not supported"

#else
        /* Don't do autosizing, if size is given */

        physTop = (char *)(LOCAL_MEM_LOCAL_ADRS + LOCAL_MEM_SIZE);

#endif /* LOCAL_MEM_AUTOSIZE */
        }

    return physTop;
    }

/******************************************************************************
*
* sysMemTop - get the address of the top of VxWorks memory
*
* This routine returns a pointer to the first byte of memory not
* controlled or used by VxWorks.
*
* The user can reserve memory space by defining the macro USER_RESERVED_MEM
* in config.h.  This routine returns the address of the reserved memory
* area.  The value of USER_RESERVED_MEM is in bytes.
*
* RETURNS: The address of the top of VxWorks memory.
*/

char * sysMemTop (void)
    {
    static char * memTop = NULL;

    if (memTop == NULL)
        {
        memTop = sysPhysMemTop () - USER_RESERVED_MEM;
        }

    return memTop;
    }

/******************************************************************************
*
* sysToMonitor - transfer control to the ROM monitor
*
* This routine transfers control to the ROM monitor.  It is usually called
* only by reboot() -- which services ^X -- and bus errors at interrupt
* level.  However, in some circumstances, the user may wish to introduce a
* new <startType> to enable special boot ROM facilities.
*
* RETURNS: Does not return.
*/

STATUS sysToMonitor
    (
    int startType    /* passed to ROM to tell it how to boot */
    )
    {
    FUNCPTR     pRom;
    UINT32 *    p = (UINT32 *)ROM_TEXT_ADRS;
#ifdef INCLUDE_SNGKS32C_END
    END_OBJ *   pEnd;
#endif

#ifdef INCLUDE_CACHE_SUPPORT
    sngks32cCacheDisable();
#endif /* INCLUDE_CACHE_SUPPORT */

    /*
     * Examine ROM - if it's a VxWorks boot ROM, jump to the warm boot entry
     * point; otherwise jump to the start of the ROM.
     * A VxWorks boot ROM begins
     *    MOV    R0,#BOOT_COLD
     *    B    ...
     *    DCB    "Copyright"
     * We check the first and third words only. This could be tightened up
     * if required (see romInit.s).
     */

#if (_BYTE_ORDER == _LITTLE_ENDIAN)
    if (p[0] == 0xE3A00002 && p[2] == 0x79706F43)
        pRom = (FUNCPTR)(ROM_TEXT_ADRS + 4);    /* warm boot address */
    else
        pRom = (FUNCPTR)ROM_TEXT_ADRS;        /* start of ROM */
#else /* (_BYTE_ORDER == _LITTLE_ENDIAN) */
    if (p[0] == 0xE3A00002 && p[2] == 0x436F7079)
        pRom = (FUNCPTR)(ROM_TEXT_ADRS + 4);    /* warm boot address */
    else
        pRom = (FUNCPTR)ROM_TEXT_ADRS;        /* start of ROM */
#endif /* (_BYTE_ORDER == _LITTLE_ENDIAN) */

#ifdef INCLUDE_SNGKS32C_END
    /*
     * Reset Ethernet controller to prevent it doing anything
     * before jumping to the bootrom.
     */

    pEnd = endFindByName ("sng", 0);

    if (pEnd != NULL)
        pEnd->pFuncTable->stop(pEnd->devObject.pDevice);
#endif /* INCLUDE_SNGKS32C_END */

    (*pRom)(startType);    /* jump to bootrom */

    return OK;        /* in case we ever continue from ROM monitor */
    }

/****************************************************************************
*
* sysProcNumGet - get the processor number
*
* This routine returns the processor number for the CPU board, which is
* set with sysProcNumSet().
*
* RETURNS: The processor number for the CPU board.
*
* SEE ALSO: sysProcNumSet()
*/

int sysProcNumGet (void)
    {
    return 0;
    }

/****************************************************************************
*
* sysProcNumSet - set the processor number
*
* Set the processor number for the CPU board.  Processor numbers should be
* unique on a single backplane.
*
* NOTE
* By convention, only processor 0 should dual-port its memory.
*
* RETURNS: N/A
*
* SEE ALSO: sysProcNumGet()
*/

void sysProcNumSet
    (
    int procNum        /* processor number */
    )
    {
    sysProcNum = procNum;
    }

#ifdef INCLUDE_FLASH

/* default procedures assume static ram with no special r/w routines */
#ifndef NV_RAM_WR_ENBL
#   define NV_RAM_WR_ENBL    /* no write enable procedure */
#endif /*NV_RAM_WR_ENBL*/

#ifndef NV_RAM_WR_DSBL
#   define NV_RAM_WR_DSBL    /* no write disable procedure */
#endif /*NV_RAM_WR_DSBL*/

#ifndef NV_RAM_READ
#   define NV_RAM_READ(x) \
    (*(UCHAR *)((int)NV_RAM_ADRS + ((x) * NV_RAM_INTRVL)))
#endif /*NV_RAM_READ*/

#ifndef NV_RAM_WRITE
#   define NV_RAM_WRITE(x,y) \
    (*(UCHAR *)((int)NV_RAM_ADRS + ((x) * NV_RAM_INTRVL)) = (y))
#endif /*NV_RAM_WRITE*/
    
/******************************************************************************
*
* sysNvRamGet - get the contents of non-volatile RAM
*
* This routine copies the contents of non-volatile memory into a specified
* string.  The string is terminated with an EOS.
*
* RETURNS: OK, or ERROR if access is outside the non-volatile RAM range.
*
* SEE ALSO: sysNvRamSet()
*/

STATUS sysNvRamGet
    (
    char *string,    /* where to copy non-volatile RAM    */
    int   strLen,      /* maximum number of bytes to copy   */
    int   offset       /* byte offset into non-volatile RAM */
    )

    {
    STATUS retVal;

    offset += NV_BOOT_OFFSET;   /* boot line begins at <offset> = 0 */

    if ((offset < 0)
     || (strLen < 0)
     || ((offset + strLen) > NV_RAM_SIZE))
        return (ERROR);

    retVal = sysFlashGet (string, strLen, offset);
    string [strLen] = EOS;

    return (OK);
    }

/******************************************************************************
*
* sysNvRamSet - write to non-volatile RAM
*
* This routine copies a specified string into non-volatile RAM.
*
* RETURNS: OK, or ERROR if access is outside the non-volatile RAM range.
*
* SEE ALSO: sysNvRamGet()
*/

STATUS sysNvRamSet
    (
    char *string,     /* string to be copied into non-volatile RAM */
    int strLen,       /* maximum number of bytes to copy           */
    int offset        /* byte offset into non-volatile RAM         */
    )

    {
    offset += NV_BOOT_OFFSET;   /* boot line begins at <offset> = 0 */

    if ((offset < 0)