ss5-systffs.c

vxworks tffs for x86

*
* RETURNS: N/A
*/

LOCAL void rfaVppOff 
    (
    FLSocket vol		/* pointer identifying drive */
    ) 
    {
    /* ADDED: causes flMap() to call rfaSetMappingContext() */

    vol.window.currentPage = UNDEFINED_MAPPING;

    /* ADDED: causes rfaSetMappingContext() to switch to 'read' window */

    mapForRead = TRUE;

    *(FRC5CE_VME_A32MAP_REG) &= ~FRC5CE_VPP_FLASH_ENABLE;
    }

#endif	/* SOCKET_12_VOLTS */

/*******************************************************************************
*
* rfaSocketInit - perform all necessary initializations of the socket
*
* This routine performs all necessary initializations of the socket.
*
* RETURNS: flOK always
*/

LOCAL FLStatus rfaSocketInit
    (
    FLSocket vol		/* pointer identifying drive */
    ) 
    {
    vol.cardChanged = FALSE;

    /* enable memory window and map it at address 0 */
    rfaSetWindow (&vol);

    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
*/

LOCAL void rfaSetWindow
    (
    FLSocket vol		/* pointer identifying drive */
    ) 
    {
    /* Physical base as a 4K page */

    if (mapForRead == TRUE)	/* switch to 'read' window */
	{
        vol.window.baseAddress = FRC5CE_FLASH_USER1 >> 12;
        flSetWindowSize (&vol, FLASH_USER_SIZE >> 12);
	}
    else			/* switch to 'write' window */
	{
        vol.window.baseAddress = FRC5CE_FLASH_RW_ADRS >> 12;
        flSetWindowSize (&vol, FLASH_PAGE_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.
*
* The page to map is guaranteed to be on a full window-size boundary.
*
* RETURNS: N/A
*/

LOCAL void rfaSetMappingContext 
    (
    FLSocket vol,		/* pointer identifying drive */
    unsigned page		/* page to be mapped */
    )
    {
    if (mapForRead == TRUE)	/* switch to 'read' window */
	{
	}
    else			/* switch to 'write' window */
	{

        /* this function need to support "address wraparound".
         * Thus ((page >> 7) & 0x03) works, but (page >> 7). */

        switch ((page >> 7) & 0x03)
	    {
            case 0:
                *(FRC5CE_GEN_PURPOSE2_REG) &= ~FRC5CE_BOOT_EPROM_SELECTED;
                *(FRC5CE_GEN_PURPOSE2_REG) &= ~FRC5CE_USER_EPROM2_SELECTED;
                *(FRC5CE_VME_A32MAP_REG)   &= ~FRC5CE_FLASH_PAGE1;
                break;

            case 1:
                *(FRC5CE_GEN_PURPOSE2_REG) &= ~FRC5CE_BOOT_EPROM_SELECTED;
                *(FRC5CE_GEN_PURPOSE2_REG) &= ~FRC5CE_USER_EPROM2_SELECTED;
                *(FRC5CE_VME_A32MAP_REG)   |= FRC5CE_FLASH_PAGE1;
                break;

            case 2:
                *(FRC5CE_GEN_PURPOSE2_REG) &= ~FRC5CE_BOOT_EPROM_SELECTED;
                *(FRC5CE_GEN_PURPOSE2_REG) |= FRC5CE_USER_EPROM2_SELECTED;
                *(FRC5CE_VME_A32MAP_REG)   &= ~FRC5CE_FLASH_PAGE1;
                break;

            case 3:
                *(FRC5CE_GEN_PURPOSE2_REG) &= ~FRC5CE_BOOT_EPROM_SELECTED;
                *(FRC5CE_GEN_PURPOSE2_REG) |= FRC5CE_USER_EPROM2_SELECTED;
                *(FRC5CE_VME_A32MAP_REG)   |= FRC5CE_FLASH_PAGE1;
                break;

            default:
                break;
            }
        }
    }

/*******************************************************************************
*
* rfaGetAndClearCardChangeIndicator - return the hardware card-change indicator
*
* This routine returns the hardware card-change indicator and clears it if set.
*
* 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);		/* controlled by hardware SW2-4 */
    }

/*******************************************************************************
*
* 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 */
    )
    {
    /* ss5 use sliding windows for flash arrays
     * so this check is irrelevant for them */

    return (chipSize);
    }

#if FALSE
    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);
    }
#endif

#if	FALSE
/*******************************************************************************
*
* sysTffsCpy - copy memory from one location to another
*
* This routine copies <size> characters from the object pointed
* to by <source> into the object pointed to by <destination>. If copying
* takes place between objects that overlap, the behavior is undefined.
*
* INCLUDE FILES: string.h
*
* RETURNS: A pointer to <destination>.
*
* NOMANUAL
*/

void * sysTffsCpy
    (
    void *       destination,   /* destination of copy */
    const void * source,        /* source of copy */
    size_t       size           /* size of memory to copy */
    )
    {
    bcopyBytes ((char *) source, (char *) destination, (size_t) size);
    return (destination);
    }

/*******************************************************************************
*
* sysTffsSet - set a block of memory
*
* This routine stores <c> converted to an `unsigned char' in each of the
* elements of the array of `unsigned char' beginning at <m>, with size <size>.
*
* INCLUDE FILES: string.h
*
* RETURNS: A pointer to <m>.
*
* NOMANUAL
*/

void * sysTffsSet
    (
    void * m,                   /* block of memory */
    int    c,                   /* character to store */
    size_t size                 /* size of memory */
    )
    {
    bfillBytes ((char *) m, (int) size, c);
    return (m);
    }
#endif	/* FALSE */

/*******************************************************************************
*
* flDelayMsecs - wait for specified number of milliseconds
*
* This routine waits for specified number of milliseconds.
*
* RETURNS: N/A
*
* NOMANUAL
*/

void flDelayMsecs
    (
    unsigned milliseconds       /* milliseconds to wait */
    )
    {
    UINT32 ix;
    UINT32 iy = 1;
    UINT32 iz = 2;

    /* we don'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 consumes the specified time.
*
* RETURNS: N/A
*/

void flDelayLoop 
    (
    int cycles			/* loop count to be consumed */
    )
    {
    }