systffs.c

wind river提供的MPC8260的BSP典型代码

    vol.VppOff =		pcVppOff;
#endif
    vol.initSocket =		pcInitSocket;
    vol.setWindow =		pcSetWindow;
    vol.setMappingContext =	pcSetMappingContext;
    vol.getAndClearCardChangeIndicator = pcGetAndClearCardChangeIndicator;
    vol.writeProtected =	pcWriteProtected;
    noOfDrives++;
    }

/*******************************************************************************
*
* pcCardDetected - detect if a card is present (inserted)
*
* This routine detects if a card is present (inserted).
*
* RETURNS: TRUE, or FALSE if the card is not present.
*/

LOCAL FLBoolean pcCardDetected
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    int	immrVal = vxImmrGet();

    if ((*PIPR (immrVal) & 0x18000000) == 0)
	return (TRUE);
    else
	return (FALSE);
    }

/*******************************************************************************
*
* pcVccOn - turn on Vcc (3.3/5 Volts)
*
* This routine turns on Vcc (3.3/5 Volts). Vcc must be known to be good
* on exit.
*
* RETURNS: N/A
*/

LOCAL void pcVccOn
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    *BCSR1 &= ~(BCSR1_PCCARD_VCCON_L);	/* on PC card VCC */
    flDelayMsecs (VCC_DELAY_MSEC);	/* wait for Vcc to ramp up */
    }

/*******************************************************************************
*
* pcVccOn - turn off Vcc (3.3/5 Volts)
*
* This routine turns off Vcc (3.3/5 Volts).
*
* RETURNS: N/A
*/

LOCAL void pcVccOff
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    *BCSR1 |= (BCSR1_PCCARD_VCCON_L);	/* off PC card VCC */
    }

#ifdef SOCKET_12_VOLTS

/*******************************************************************************
*
* pcVppOn - turn on Vpp (12 Volts)
*
* This routine turns on Vpp (12 Volts). Vpp must be known to be good on exit.
*
* RETURNS: flOK always
*/

LOCAL FLStatus pcVppOn
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    *BCSR1 = (*BCSR1 & ~BCSR1_PCCVPP_MSK) | BCSR1_PCCVPP_12V;
    flDelayMsecs (VPP_DELAY_MSEC);	/* wait for Vpp to ramp up */
    return (flOK);
    }

/*******************************************************************************
*
* pcVppOff - turn off Vpp (12 Volts)
*
* This routine turns off Vpp (12 Volts).
*
* RETURNS: N/A
*/

LOCAL void pcVppOff
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    *BCSR1 = (*BCSR1 & ~BCSR1_PCCVPP_MSK) | BCSR1_PCCVPP_MSK;
    }

#endif	/* SOCKET_12_VOLTS */

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

LOCAL FLStatus pcInitSocket
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    int	immrVal = vxImmrGet();

#if	FALSE
    printf ("-- pcInitSocket --\n");
    printf ("immrVal=0x%x\n", immrVal);
    printf ("BR0=0x%x, OR0=0x%x\n", *BR0(immrVal), *OR0(immrVal));
    printf ("BR1=0x%x, OR1=0x%x\n", *BR1(immrVal), *OR1(immrVal));
    printf ("BR2=0x%x, OR2=0x%x\n", *BR2(immrVal), *OR2(immrVal));
    printf ("BR3=0x%x, OR3=0x%x\n", *BR3(immrVal), *OR3(immrVal));
    printf ("BR4=0x%x, OR4=0x%x\n", *BR4(immrVal), *OR4(immrVal));
    printf ("BR5=0x%x, OR5=0x%x\n", *BR5(immrVal), *OR5(immrVal));
    printf ("BR6=0x%x, OR6=0x%x\n", *BR6(immrVal), *OR6(immrVal));
    printf ("BR7=0x%x, OR7=0x%x\n", *BR7(immrVal), *OR7(immrVal));
#endif	/* FALSE */

    *BR4(immrVal) = (PC_BASE_ADRS_1 & BR_BA_MSK) | BR_V;
    *OR4(immrVal) = 0xfc000000 | OR_BI | OR_SCY_8_CLK | OR_TRLX | 0x02;

    /* clear PCMCIA base registers */

    *PBR0 (immrVal) = PC_BASE_ADRS_0;
    *PBR1 (immrVal) = PC_BASE_ADRS_1;
    *PBR2 (immrVal) = 0x0;
    *PBR3 (immrVal) = 0x0;
    *PBR4 (immrVal) = 0x0;
    *PBR5 (immrVal) = 0x0;
    *PBR6 (immrVal) = 0x0;
    *PBR7 (immrVal) = 0x0;

    /* clear PCMCIA option registers */

    *POR0 (immrVal) = 0xf0000000 |		/* bank size:     1MB */
		      0x00020000 |		/* strobe hold:   2 clocks */
		      0x00001000 |		/* strobe setup:  1 clock */
		      0x00000300 |		/* strobe length: 6 clocks */
		      0x00000040 |		/* port size:     2 byte */
		      0x00000010 |		/* region select: attribute */
		      0x00000000 |		/* slot ID:       slot-A */
		      0x00000000 |		/* write protect: off */
		      0x00000001;		/* PCMCIA valid:  1 */
    *POR1 (immrVal) = 0xa8000000 |		/* bank size:     32MB */
		      0x00020000 |		/* strobe hold:   2 clocks */
		      0x00001000 |		/* strobe setup:  1 clock */
		      0x00000300 |		/* strobe length: 6 clocks */
		      0x00000040 |		/* port size:     2 byte */
		      0x00000000 |		/* region select: common mem */
		      0x00000000 |		/* slot ID:       slot-A */
		      0x00000000 |		/* write protect: off */
		      0x00000001;		/* PCMCIA valid:  1 */
    *POR2 (immrVal) = 0x0;
    *POR3 (immrVal) = 0x0;
    *POR4 (immrVal) = 0x0;
    *POR5 (immrVal) = 0x0;
    *POR6 (immrVal) = 0x0;
    *POR7 (immrVal) = 0x0;

    *PSCR (immrVal) = 0x0;

    *PGCRA (immrVal) = 0x0;			/* XXX disable interupt */
    *PGCRB (immrVal) = 0x0;			/* XXX disable interupt */

    *BCSR1 &= ~(BCSR1_PCCARD_EN_L);		/* enable the PCMCIA */
    *BCSR1 |= BCSR1_PCCVPP_MSK;			/* setup PC card Vpp to Hi-Z */

    *BCSR1 &= ~(BCSR1_PCCARD_VCCON_L);		/* on PC card VCC */
    flDelayMsecs (VCC_DELAY_MSEC);		/* wait for Vcc to ramp up */
    *PGCRA (immrVal) |= 0x00000040;		/* reset the card A */
    flDelayMsecs (10);				/* wait for the reset */
    *PGCRA (immrVal) &= ~0x00000040;

#if	FALSE
    printf ("PIPR=0x%x\n", *PIPR(immrVal));
    printf ("PSCR=0x%x\n", *PSCR(immrVal));
    printf ("PER=0x%x\n", *PER(immrVal));
    printf ("PGCRA=0x%x\n", *PGCRA(immrVal));
    printf ("PGCRB=0x%x\n", *PGCRB(immrVal));
#endif	/* FALSE */

    return (flOK);
    }

/*******************************************************************************
*
* pcSetWindow - 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 pcSetWindow
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    /* Physical base as a 4K page */
    vol.window.baseAddress = PC_BASE_ADRS_1 >> 12;

    flSetWindowSize (&vol, PC_BASE_ADRS_1 >> 12);
    }

/*******************************************************************************
*
* pcSetMappingContext - 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 pcSetMappingContext
    (
    FLSocket vol,		/* pointer identifying drive */
    unsigned page		/* page to be mapped */
    )
    {
    int	immrVal = vxImmrGet();

    if (page & ATTRIBUTE_SPACE_MAPPED)
        *POR1 (immrVal) |= 0x00000010;		/* attribute mem */
    else
        *POR1 (immrVal) &= ~0x00000010;		/* common mem */
    }

/*******************************************************************************
*
* pcGetAndClearCardChangeIndicator - 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 pcGetAndClearCardChangeIndicator
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    return (FALSE);
    }

/*******************************************************************************
*
* pcWriteProtected - 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 pcWriteProtected
    (
    FLSocket vol		/* pointer identifying drive */
    )
    {
    return (FALSE);
    }
#endif	/* INCLUDE_SOCKET_PCMCIA */

/*******************************************************************************
*
* 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);
    }

#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 */
    )
    {
    bcopy ((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 */
    )
    {
    bfill ((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;

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

void flDelayLoop
    (
    int  cycles
    )
    {
    while (--cycles)
	;
    }

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

#ifdef	HALF_FORMAT
	{0x80000l, 99, 1, 0x10000l, NULL, {0,0,0,0}, NULL, 2, 0, NULL},
#else
	{0x000000l, 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 SIMM */

    /* tffsRawio(0, TFFS_PHYSICAL_ERASE, 0, 10, 0);*/
    status = tffsDevFormat (0, (int)&params);
    return (status);
    }