syslib.c

S3C2410开发板的VXWORKS开发包

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
*
*
* 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
*
*
* 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)
     || (strLen < 0)
     || ((offset + strLen) > NV_RAM_SIZE))
        return ERROR;

    NV_RAM_WR_ENBL;

    return (sysFlashSet (string, strLen, offset));

    }

/******************************************************************************
*
* sysFlashBoardDelay - create a delay
*
*
* RETURNS: N/A
*/

void sysFlashBoardDelay (void)
    {
    return;
    }
#endif /* INCLUDE_FLASH */


STATUS sysRomGet(char *string, int   strLen,   int   offset )

    {
    /*STATUS retVal;*/

    if ((offset < 0)
     || (strLen < 0))
        return (ERROR);

    /*retVal = copyLongs (offset, string, strLen);*/
    /*copyString (offset, string, strLen);*/
    bcopyBytes ((char *) (offset), string, strLen);
    string [strLen] = EOS;

    return (OK);
    }


unsigned char SST39VF160_ChipProg(unsigned long ulRomAddr,unsigned long ulRamAddr,unsigned long ulRomSize)
{
	unsigned long i,j,ulRomAddrOri,ulRamAddrOri,ulRomSizeOri;
	/*static int LedCount=0;*/
	unsigned short usData;
	ulRomAddrOri	=ulRomAddr;
	ulRamAddrOri	=ulRamAddr;
	ulRomSizeOri	=ulRomSize;
	SST39VF160_SectorErase(ulRomAddr);
		
	
	for(i=0;i<6553600/3;i++);
	for(i=0;i<(ulRomSize/2);i++)	
	{
		for(j=0;j<200;j++);
		usData=*(unsigned short *)ulRamAddr;
		SST39VF160_WordProg_Test(ulRomAddr,usData);
		ulRomAddr++;
		ulRamAddr+=2;
	} 
	return (Verify(ulRomAddrOri,ulRamAddrOri,ulRomSizeOri));	
}

unsigned char SST39VF160_WordProg_Test(unsigned long ulAddr,unsigned short usData)
{       int level;
	_WR(0x5555,0xaa);
	_WR(0x2aaa,0x55);
	level = intLock();
	_WR(0x5555,0xa0);
	_WR(ulAddr,usData);
	_WAIT(ulAddr);
	intUnlock(level);
	return 1;
}
unsigned char _WAIT(unsigned long ulAddr) 
{
	volatile unsigned short flashStatus,old;
	old=*((volatile unsigned short *)(ulAddr<<1));
	
	while(1)
	{
		flashStatus=*((volatile unsigned short *)(ulAddr<<1));
		
		if( (old&0x40) == (flashStatus&0x40) )
			break;
		else
		   old=flashStatus;
	}
	return 1;
}

unsigned char SST39VF160_SectorErase(unsigned long ulAddr)
{
	int level;
	int i;
	_WR(0x5555,0xaa);
	_WR(0x2aaa,0x55);
	_WR(0x5555,0x80);
	_WR(0x5555,0xaa);
	_WR(0x2aaa,0x55);
	level = intLock();
	_WR(ulAddr,0x30);
	_WAIT(ulAddr);
	for(i=0; i<0x800; i++,ulAddr++){
		   if(*((volatile unsigned short *)(ulAddr<<1)) != 0xffff)  break;
		   
	}	
	_WR(ulAddr,0xf0);
	intUnlock(level);	
	if(i < 0x800)	{
			printf("Debug: sst39vf160_SectorErase fail.\n");
			return 0;
	}
  return 1;
}
unsigned char Verify(unsigned long ulRomAddr,unsigned long ulRamAddr,unsigned long ulRomSize)
{
	unsigned long i;
	for (i=0x0;i<ulRomSize;i+=2)
	{
		if(*((volatile unsigned short *)(i+(ulRomAddr<<1)))!=*((volatile unsigned short *)(i+ulRamAddr)))
		
			return 0;	
	}
	
	return 1;
}

#ifdef INCLUDE_CACHE_SUPPORT

/******************************************************************************
*
* s3c2410xCacheLibInit - initialize ARM cache library function pointers
*
*
* INTERNAL
* This routine is called (from cacheLibInit()), before sysHwInit has
* been called, and before BSS has been cleared.
*
* RETURNS: OK always
*
*/

STATUS s3c2410xCacheLibInit
    (
    CACHE_MODE    instMode,    /* instruction cache mode */
    CACHE_MODE    dataMode    /* data cache mode */
    )
    {

#if ((ARMCACHE == ARMCACHE_920T))
    cacheLib.enableRtn               = (FUNCPTR) s3c2410xCacheEnable;
    cacheLib.disableRtn              = (FUNCPTR) s3c2410xCacheDisable;
    cacheLib.flushRtn                = (FUNCPTR) s3c2410xCacheFlush;
    cacheLib.invalidateRtn           = (FUNCPTR) NULL;
    cacheLib.clearRtn                = (FUNCPTR) NULL;
    cacheLib.textUpdateRtn           = (FUNCPTR) NULL;
    cacheLib.pipeFlushRtn            = (FUNCPTR) NULL;
    cacheLib.dmaMallocRtn            = (FUNCPTR) s3c2410xCacheDmaMalloc;
    cacheLib.dmaFreeRtn              = (FUNCPTR) s3c2410xCacheDmaFree;
    s3c2410xCacheFuncs.virtToPhysRtn = (FUNCPTR) s3c2410xVirtToPhysRtn;
    s3c2410xCacheFuncs.physToVirtRtn = (FUNCPTR) s3c2410xPhysToVirtRtn;

    if (
    (instMode & CACHE_WRITEALLOCATE)    ||
    (dataMode & CACHE_WRITEALLOCATE)    ||
    (instMode & CACHE_NO_WRITEALLOCATE)    ||
    (dataMode & CACHE_NO_WRITEALLOCATE)    ||
    (instMode & CACHE_SNOOP_ENABLE)        ||
    (dataMode & CACHE_SNOOP_ENABLE)        ||
    (instMode & CACHE_SNOOP_DISABLE)    ||
    (dataMode & CACHE_SNOOP_DISABLE)    ||
    (instMode & CACHE_BURST_ENABLE)        ||
    (dataMode & CACHE_BURST_ENABLE)        ||
    (instMode & CACHE_BURST_DISABLE)    ||
    (dataMode & CACHE_BURST_DISABLE))
        return ERROR;

    /* This has combined Instruction and Data caches */
    if (instMode != dataMode)
        return ERROR;

#else
#error ARMCACHE type not supported here
#endif


    return OK;
    }

/******************************************************************************
*
* s3c2410xCacheDmaMalloc - allocate a cache-safe buffer
*
*
* RETURNS: A pointer to a cache-safe buffer, or NULL.
*
* SEE ALSO: s3c2410xCacheDmaFree(), cacheDmaMalloc()
*
* NOMANUAL
*/

void * s3c2410xCacheDmaMalloc
    (
    size_t    bytes    /* size of cache-safe buffer */
    )
    {
    void   *ptr;
    UINT32  foo;

    ptr = malloc (bytes);
    foo = (UINT32)ptr;
    foo |= NON_CACHE_REGION;
    ptr = (void *)foo;

    return (ptr);

    } /* cacheArchDmaMalloc() */

/******************************************************************************
*
* s3c2410xCacheDmaFree - free the buffer acquired by cacheArchDmaMalloc()
*
* RETURNS: OK, or ERROR if cacheArchDmaMalloc() cannot be undone.
*
* SEE ALSO: s3c2410xCacheDmaMalloc(), cacheDmaFree()
*
* NOMANUAL
*/

STATUS s3c2410xCacheDmaFree
    (
    void *    pBuf        /* ptr returned by cacheArchDmaMalloc() */
    )
    {

    UINT32 foo;

    foo = (UINT32) pBuf;
    foo &= ~NON_CACHE_REGION;
    pBuf = (void *)foo;
	
    free (pBuf);    /* free buffer after modified */

    return OK;

    } /* cacheArchDmaFree() */

/******************************************************************************
*
* s3c2410xCacheEnable - enable cache
*
* This routine enables cache
*
* RETURNS: void
*
* SEE ALSO: s3c2410xCacheDisable(), s3c2410xCacheFlush()
*
* NOMANUAL
*/

void s3c2410xCacheEnable
    ( 
    void
    )
    {

    UINT32    result;

    SBCARM9_CTRL_REG_READ (S3C2410X_SYSCFG, result);
    SBCARM9_CTRL_REG_WRITE (S3C2410X_SYSCFG, (result & (~SBCARM9_CACHE_MODE)));
    SBCARM9_CTRL_REG_READ (S3C2410X_SYSCFG, result);


#if (SBCARM9_CACHE_SIZE == SBCARM9_CACHE_4K)
    result &= ~SBCARM9_CACHE_MODE;        /* For 4K Cache */
    /*-SBCARM9_CTRL_REG_WRITE (S3C2410X_SYSCFG, (result | SBCARM9_WRITE_BUFF));*/
    s3c2410xCacheFlush();
	/* : added */
	SBCARM9_CTRL_REG_WRITE (S3C2410X_SYSCFG, (result | SBCARM9_WRITE_BUFF | SBCARM9_CACHE_4K));

    /*-SBCARM9_CTRL_REG_READ (S3C2410X_SYSCFG, result);
    SBCARM9_CTRL_REG_WRITE (S3C2410X_SYSCFG, (result | SBCARM9_CACHE_ENABLE));*/
#endif /* (SBCARM9_CACHE_SIZE == SBCARM9_CACHE_4K) */

#if (SBCARM9_CACHE_SIZE == SBCARM9_CACHE_8K)	
    result &= ~SBCARM9_CACHE_MODE;        /* Clear mode bits */
    /*-SBCARM9_CTRL_REG_WRITE (S3C2410X_SYSCFG,
                            (result | SBCARM9_WRITE_BUFF | SBCARM9_CACHE_8K));*/
    s3c2410xCacheFlush();
	/* : added */	
	SBCARM9_CTRL_REG_WRITE (S3C2410X_SYSCFG, (result | SBCARM9_WRITE_BUFF | SBCARM9_CACHE_8K));

    /*-SBCARM9_CTRL_REG_READ (S3C2410X_SYSCFG, result);
    SBCARM9_CTRL_REG_WRITE(S3C2410X_SYSCFG, (result | SBCARM9_CACHE_ENABLE));*/
#endif /* (SBCARM9_CACHE_SIZE == SBCARM9_CACHE_8K) */
    }


/******************************************************************************
*
* s3c2410xCacheDisable - disable cache
*
* This routine disables cache
*
* RETURNS: void
*
* SEE ALSO: s3c2410xCacheEnable(), s3c2410xCacheFlush()
*
* NOMANUAL
*/

void s3c2410xCacheDisable
    (
    void
    )
    {
    UINT32 result;

    SBCARM9_CTRL_REG_READ(S3C2410X_SYSCFG, result);
    /* : SBCARM9_CACHE_ENABLE->SBCARM9_CACHE_MODE */
    SBCARM9_CTRL_REG_WRITE(S3C2410X_SYSCFG,
                           (result & ~(SBCARM9_CACHE_MODE)));
    }

/******************************************************************************
*
* s3c2410xCacheFlush - flush the cache
*
* This routine flushes the cache
*
* RETURNS: void
*
* SEE ALSO: s3c2410xCacheEnable(), s3c2410xCacheDisable()
*
* NOMANUAL
*/
void s3c2410xCacheFlush(void)
{
    int i, num;
    UINT32 *tagram;
	UINT32 addr;

	addr = SBCARM9_TAGRAM_BEG;
	num = (SBCARM9_TAGRAM_END - SBCARM9_TAGRAM_BEG)/16;
    s3c2410xCacheDisable();
    for(i=0; i < num; i++)
    {
        tagram = (UINT32 *)addr;
        *tagram = 0x00000000; 
        addr += 16;
    }
	SBCARM9_CTRL_REG_WRITE (S3C2410X_SYSCFG, (SBCARM9_WRITE_BUFF | SBCARM9_CACHE_8K));
}

/******************************************************************************
*
* s3c2410xPhysToVirtRtn - force memory to cacheable region
*
* This routine clears the "non-cache" bit on an address to force it to use
* the cacheable region of memory
*
* RETURNS: void
*
* SEE ALSO: s3c2410xCacheEnable(), s3c2410xCacheDisable()
*
* NOMANUAL
*/

void * s3c2410xPhysToVirtRtn 
    (
    void *adrs
    )

    {
    UINT32 foo;

    foo = (UINT32)adrs;
    foo &= ~NON_CACHE_REGION;
    adrs = (void *) foo;
    return adrs;
    }

/******************************************************************************
*
* s3c2410xVirtToPhysRtn - force memory to non-cacheable region
*
* This routine sets the "non-cache" bit on an address to force it to use
* the non-cacheable region of memory
*
* RETURNS: void
*
* SEE ALSO: s3c2410xCacheEnable(), s3c2410xCacheDisable()
*
* NOMANUAL
*/

void * s3c2410xVirtToPhysRtn 
    (
    void *adrs
    )
    
    {
    UINT32 foo;

    foo = (UINT32)adrs;
    foo |= NON_CACHE_REGION;
    adrs = (void *) foo;
    return adrs;
    }

#endif    /* INCLUDE_CACHE_SUPPORT */

#ifdef DEBUG
/******************************************************************************
*
* sysDebug - print message using polled serial driver
*
* Use the polled driver to print debug messages.  Useful before the full
* hardware initialization is complete (but only after sysHwInit).
*
* RETURNS: N/A.
*
* NOMANUAL
*/

void sysDebug
    (
    char *str
    )
    {
    int msgSize;
    int msgIx;
    LOCAL SIO_CHAN * pSioChan;        /* serial I/O channel */
    LOCAL BOOL beenHere = FALSE;

    msgSize = strlen (str);

    if (!beenHere)
        {
        sysSerialHwInit ();

        pSioChan = sysSerialChanGet (0);

        sioIoctl (pSioChan, SIO_BAUD_SET, (void *)CONSOLE_BAUD_RATE);

        sioIoctl (pSioChan, SIO_MODE_SET, (void *) SIO_MODE_POLL);

        beenHere = TRUE;
	}

    for (msgIx = 0; msgIx < msgSize; msgIx++)
        {
        while (sioPollOutput (pSioChan, str[msgIx]) == EAGAIN)
            /* do nothing */;
        }
    }
#endif /* DEBUG */