* constantly in RFA environment.** RETURNS: N/A*/LOCAL void rfaVccOff    (    FLSocket vol		/* pointer identifying drive */    )    {    }#ifdef SOCKET_12_VOLTS/********************************************************************************* rfaVppOn - turns on Vpp (12 Volts)** This routine turns on Vpp (12 Volts). Vpp must be known to be good on exit.* Assumed to be ON constantly in RFA environment. This is not optional and * must always be implemented. ** RETURNS: flOK always.*/LOCAL FLStatus rfaVppOn    (    FLSocket vol		/* pointer identifying drive */    )    {    return (flOK);    }/********************************************************************************* rfaVppOff - turns off Vpp (12 Volts)** This routine turns off Vpp (12 Volts). Assumed to be ON constantly * in RFA environment.This is not optional and must always be implemented.** RETURNS: N/A*/LOCAL void rfaVppOff    (    FLSocket vol		/* pointer identifying drive */    )    {    }#endif	/* SOCKET_12_VOLTS *//********************************************************************************* rfaInitSocket - perform all necessary initializations of the socket** This routine performs all necessary initializations of the socket.** RETURNS: flOK always.*/    /* TODO:      * This function is always board specific.     * Please set this to your specific needs.     */LOCAL FLStatus rfaInitSocket    (    FLSocket vol		/* pointer identifying drive */    )    {    return (flOK);    }/********************************************************************************* rfaSetWindow - set current window attributes, base address, size, etc** This routine sets current window hardware attributes: Base address, size,* speed and bus width.  The requested settings are given in the 'vol.window' * structure.  If it is not possible to set the window size requested in* 'vol.window.size', the window size should be set to a larger value, * if possible. In any case, 'vol.window.size' should contain the * actual window size (in 4 KB units) on exit.** RETURNS: N/A*/    /* TODO: set this to your specific needs */LOCAL void rfaSetWindow    (    FLSocket vol		/* pointer identifying drive */    )    {    /* Physical base as a 4K page */    vol.window.baseAddress = FLASH_BASE_ADRS >> 12;    flSetWindowSize (&vol, FLASH_SIZE >> 12);    }/********************************************************************************* rfaSetMappingContext - sets the window mapping register to a card address** This routine sets the window mapping register to a card address.* The window should be set to the value of 'vol.window.currentPage',* which is the card address divided by 4 KB. An address over 128MB,* (page over 32K) specifies an attribute-space address. On entry to this * routine vol.window.currentPage is the page already mapped into the window.* (In otherwords the page that was mapped by the last call to this routine.)* The page to map is guaranteed to be on a full window-size boundary.* This is meaningful only in environments that use sliding window mechanism* to view flash memory, like in PCMCIA. Not common in RFA environments. ** RETURNS: N/A*/LOCAL void rfaSetMappingContext    (    FLSocket vol,		/* pointer identifying drive */    unsigned page		/* page to be mapped */    )    {    }/********************************************************************************* rfaGetAndClearCardChangeIndicator - return the hardware card-change indicator** This routine returns TRUE if the card has been changed and FALSE if not. It* also clears the "card-changed" indicator if it has been set.* Always return FALSE in RFA environments since device is not removable.** RETURNS: FALSE, or TRUE if the card has been changed*/LOCAL FLBoolean rfaGetAndClearCardChangeIndicator    (    FLSocket vol		/* pointer identifying drive */    )    {    return (FALSE);    }/********************************************************************************* rfaWriteProtected - return the write-protect state of the media** This routine returns the write-protect state of the media** RETURNS: FALSE, or TRUE if the card is write-protected*/LOCAL FLBoolean rfaWriteProtected    (    FLSocket vol		/* pointer identifying drive */    )    {    return (FALSE);    }/********************************************************************************* flFitInSocketWindow - check whether the flash array fits in the socket window** This routine checks whether the flash array fits in the socket window.** RETURNS: A chip size guaranteed to fit in the socket window.*/long int flFitInSocketWindow     (    long int chipSize,		/* size of single physical chip in bytes */    int      interleaving,	/* flash chip interleaving (1,2,4 etc) */    long int windowSize		/* socket window size in bytes */    )    {    if (chipSize*interleaving > windowSize) /* doesn't fit in socket window */        {        int  roundedSizeBits;        /* fit chip in the socket window */        chipSize = windowSize / interleaving;        /* round chip size at powers of 2 */        for (roundedSizeBits = 0; (0x1L << roundedSizeBits) <= chipSize;             roundedSizeBits++)	    ;        chipSize = (0x1L << (roundedSizeBits - 1));        }    return (chipSize);    }/********************************************************************************* flDelayMsecs - wait for specified number of milliseconds** This routine waits for the specified number of milliseconds.** RETURNS: N/A** NOMANUAL*/void flDelayMsecs    (    unsigned milliseconds       /* milliseconds to wait */    )    {    UINT32 ix;    UINT32 iy = 1;    UINT32 iz = 2;    /* it doesn't count time consumed in interrupt level */    for (ix = 0; ix < milliseconds; ix++)        for (ix = 0; ix < sysTffsMsecLoopCount; ix++)	    {	    tickGet ();			/* dummy */	    iy = KILL_TIME_FUNC;	/* consume time */	    }    }/********************************************************************************* flDelayLoop - consume the specified time** This routine delays for the specified time.** RETURNS: N/A*/void flDelayLoop     (    int  cycles    )    {    while (--cycles)	;    }#if 1 /*FALSE*//********************************************************************************* sysTffsFormat - format the flash memory above an offset** This routine formats the flash memory.  Because this function defines * the symbolic constant, HALF_FORMAT, the lower half of the specified flash * memory is left unformatted.  If the lower half of the flash memory was* previously formated by TrueFFS, and you are trying to format the upper half,* you need to erase the lower half of the flash memory before you format the* upper half.  To do this, you could use:* .CS* tffsRawio(0, 3, 0, 8)  * .CE* The first argument in the tffsRawio() command shown above is the TrueFFS * drive number, 0.  The second argument, 3, is the function number (also * known as TFFS_PHYSICAL_ERASE).  The third argument, 0, specifies the unit * number of the first erase unit you want to erase.  The fourth argument, 8,* specifies how many erase units you want to erase.  ** RETURNS: OK, or ERROR if it fails.*/STATUS sysTffsFormat (void)    {    STATUS status;    tffsDevFormatParams params = 	{#define	HALF_FORMAT	/* lower 0.5MB for bootimage, upper 1.5MB for TFFS */#ifdef	HALF_FORMAT	{0x00100000l, 99, 1, 0x10000l, NULL, {0,0,0,0}, NULL, 2, 0, NULL},#else	{0x00000000l, 99, 1, 0x10000l, NULL, {0,0,0,0}, NULL, 2, 0, NULL},#endif	/* HALF_FORMAT */	FTL_FORMAT_IF_NEEDED	};    /* we assume that the drive number 0 is RFA */    status = tffsDevFormat (0, (int)&params);    return (status);    }#endif /* FALSE */