nandfs.c

基于EP7312的MP3播放器源代码,包括MCU和PC端代码.

//****************************************************************************
//
// NANDFS.C - File system driver for the on-board NAND FLASH.
//
// Copyright (c) 1999,2000,2001 Cirrus Logic, Inc.
//
//****************************************************************************
#include "globals.h"
#include "../hwport.h"
#include "../hwdefs.h"

//****************************************************************************
//
// The persistent state of the NAND file system.
//
//****************************************************************************
static struct
{
    //
    // A list of the bad blocks in the on-board NAND FLASH, in numerical order.
    //
    unsigned short usBadBlocks[64];

    //
    // The number of bad blocks in the on-board NAND FLASH.
    //
    unsigned short usNumBadBlocks;

    //
    // The number of blocks in the on-board NAND FLASH.
    //
    unsigned short usNumBlocks;

    //
    // The number of pages per block of the on-board NAND FLASH.
    //
    unsigned char ucPagesPerBlock;

    //
    // Unused bytes to pad the next member to a word boundary.
    //
    unsigned char ucUnused1, ucUnused2, ucUnused3;

    //
    // The length of the one file in the on-board NAND FLASH.
    //
    unsigned long ulFileLength;

    //
    // A pointer to the function used to read a page from the on-board NAND
    // FLASH.
    //
    void (*pfnRead)(unsigned long ulNANDAddress, unsigned long ulPage,
                    unsigned char *pucData, unsigned char *pucRedundant);

    //
    // A pointer to the function used to write a page to the on-board NAND
    // FLASH.
    //
    void (*pfnWrite)(unsigned long ulNANDAddress, unsigned long ulPage,
                     unsigned char *pucData, unsigned char *pucRedundant);

    //
    // A pointer to the function used to erase a block of the on-board NAND
    // FLASH.
    //
    void (*pfnErase)(unsigned long ulNANDAddress, unsigned long ulBlock);
} sNAND;

//****************************************************************************
//
// The following structure contains the parameters of an opened file.
//
//****************************************************************************
typedef struct
{
    //
    // The next page of the file to be read.
    //
    unsigned long ulPage;

    //
    // The current byte offset into the file.
    //
    unsigned long ulFilePos;
} tNANDFile;

//****************************************************************************
//
// The following structure contains the parameters of an opened directory.
//
//****************************************************************************
typedef struct
{
    //
    // An indicator that is true when there have been no IOCTL_FS_READDIR
    // Ioctls after an IOCTL_FS_OPENDIR Ioctl.
    //
    unsigned long bIsFirstDirEntry;
} tNANDDir;

//****************************************************************************
//
// NextPage increments to the next valid page of the NAND FLASH.  The next
// valid page is "*pulPage++", unless this falls on an invalid block.  The
// current value of the page variable is returned, so that this function can
// be used as a post-increment reference (i.e. NextPage(&x) is roughly
// equivalent to x++).
//
//****************************************************************************
static unsigned long
NextPage(unsigned long *pulPage)
{
    unsigned long ulRet;
    int iIdx;

    //
    // Save the current page number.
    //
    ulRet = *pulPage;

    //
    // Increment the page number.
    //
    (*pulPage)++;

    //
    // If this is not the first page of a block, then it is not part of an
    // invalid block.
    //
    if((*pulPage & (sNAND.ucPagesPerBlock - 1)) != 0)
    {
        //
        // Return the previous page number.
        //
        return(ulRet);
    }

    //
    // Increment the page number until we reach a page in a valid block.
    //
    while(1)
    {
        //
        // See if this page lies in one of our invalid blocks.
        //
        for(iIdx = 0; iIdx < sNAND.usNumBadBlocks; iIdx++)
        {
            if((*pulPage / sNAND.ucPagesPerBlock) == sNAND.usBadBlocks[iIdx])
            {
                break;
            }
        }

        //
        // If this page does not lie in one of the invalid blocks, then stop
        // incrementing the page number.
        //
        if(iIdx == sNAND.usNumBadBlocks)
        {
            break;
        }

        //
        // Skip to the first page of the next block.
        //
        *pulPage += sNAND.ucPagesPerBlock;
    }

    //
    // Return the previous page number.
    //
    return(ulRet);
}

//****************************************************************************
//
// CheckNAND determines if the NAND FLASH on the board has been "formatted"
// and reads the bad block table if it has been formatted.
//
//****************************************************************************
static int
CheckNAND(unsigned char *pucBuffer, unsigned char *pucWriteBuffer)
{
    int iLoop;

    //
    // Read the first page of the NAND FLASH.
    //
    (sNAND.pfnRead)(HwNANDAddress, 0, pucBuffer, pucWriteBuffer);

    //
    // See if the NAND FLASH has been formatted by looking for the signature
    // at the beginning of the first page.
    //
    if((pucBuffer[0] != 'B') || (pucBuffer[1] != 'K') ||
       (pucBuffer[2] != 'O') || (pucBuffer[3] != 'K'))
    {
        //
        // The signature does not exist, so the NAND FLASH has not been
        // formatted yet.
        //
        return(0);
    }

    //
    // Get the number of bad blocks.
    //
    sNAND.usNumBadBlocks = pucBuffer[4] | (pucBuffer[5] << 8);

    //
    // Make sure that the number of bad blocks is valid.
    //
    if(sNAND.usNumBadBlocks > 64)
    {
        sNAND.usNumBadBlocks = 0;
        return(0);
    }

    //
    // Read the bad block table.
    //
    for(iLoop = 0; iLoop < sNAND.usNumBadBlocks; iLoop++)
    {
        sNAND.usBadBlocks[iLoop] = pucBuffer[6 + (iLoop << 1)] |
                                   (pucBuffer[7 + (iLoop << 1)] << 8);
    }

    //
    // The media has been formatted.
    //
    return(1);
}

//****************************************************************************
//
// FormatNAND prepares the NAND FLASH for use to record/download file data.
// It checks the NAND FLASH for bad blocks and builds a bad block table.
//
//****************************************************************************
static void
FormatNAND(unsigned char *pucBuffer, unsigned char *pucWriteBuffer)
{
    unsigned long ulValue;
    int iBlock, iPage, iIdx;

    //
    // We only need to check for bad blocks if the NAND FLASH has not already
    // been formatted.
    //
    if(!CheckNAND(pucBuffer, pucWriteBuffer))
    {
        //
        // Initially, there are no bad blocks in the NAND FLASH (until we find
        // bad blocks).
        //
        sNAND.usNumBadBlocks = 0;

        //
        // Loop through all the blocks in the on-board NAND FLASH.
        //
        for(iBlock = 1; iBlock < sNAND.usNumBlocks; iBlock++)
        {
            //
            // Read the first two pages of each block.  The page will be all
            // 0xff if it is good, and will contain zeros if it is bad.
            //
            for(iPage = 0; iPage < 2; iPage++)
            {
                //
                // Read the page from NAND FLASH.
                //
                (sNAND.pfnRead)(HwNANDAddress,
                                (iBlock * sNAND.ucPagesPerBlock) + iPage,
                                pucBuffer, pucWriteBuffer);

                //
                // Verify that the page contains all 0xff.
                //
                for(iIdx = 0; iIdx < 512; iIdx++)
                {
                    if(pucBuffer[iIdx] != 0xff)
                    {
                        break;
                    }
                }

                //
                // If this page did not contain all 0xff, then break out of the
                // loop.
                //
                if(iIdx != 512)
                {
                    break;
                }

                //
                // Verify that the spare area contains all 0xff.
                //
                for(iIdx = 0; iIdx < 16; iIdx++)
                {
                    if(pucWriteBuffer[iIdx] != 0xff)
                    {
                        break;
                    }
                }

                //
                // If the spare area did not contain all 0xff, then break out
                // of the loop.
                //
                if(iIdx != 16)
                {
                    break;
                }
            }

            //
            // If both pages did not contain all 0xff, then this block is bad.
            //
            if(iPage != 2)
            {
                //
                // Save this block in the bad block table.
                //
                sNAND.usBadBlocks[sNAND.usNumBadBlocks++] = iBlock;

                //
                // Quit scanning if we've found too many bad blocks.  This
                // ignores any following bad blocks, but what can you do (this
                // isn't exactly a "filesystem" and is certainly not product
                // worthy)?
                //
                if(sNAND.usNumBadBlocks == 64)
                {
                    break;
                }
            }
        }

        //
        // Build the signature and bad block table for the first page of the
        // NAND FLASH.
        //
        pucBuffer[0] = 'B';
        pucBuffer[1] = 'K';
        pucBuffer[2] = 'O';
        pucBuffer[3] = 'K';

        //
        // Fill in the bad block table.
        //
        pucBuffer[4] = sNAND.usNumBadBlocks & 0xFF;
        pucBuffer[5] = (sNAND.usNumBadBlocks >> 8) & 0xFF;
        for(iIdx = 0; iIdx < sNAND.usNumBadBlocks; iIdx++)
        {
            pucBuffer[6 + (iIdx << 1)] = sNAND.usBadBlocks[iIdx] & 0xFF;
            pucBuffer[7 + (iIdx << 1)] = (sNAND.usBadBlocks[iIdx] >> 8) & 0xFF;
        }

        //
        // Write the bad block table to the beginning of the NAND FLASH.
        //
        (sNAND.pfnErase)(HwNANDAddress, 0);
        NANDWaitTilNotBusy(HwNANDAddress);
        (sNAND.pfnWrite)(HwNANDAddress, 0, pucBuffer, pucWriteBuffer);
        NANDWaitTilNotBusy(HwNANDAddress);
    }

    //
    // Set the file size to zero, so that we do not try to play the empty
    // contents of the NAND FLASH.
    //
    pucBuffer[0] = 0;
    pucBuffer[1] = 0;
    pucBuffer[2] = 0;
    pucBuffer[3] = 0;
    ulValue = sNAND.ucPagesPerBlock - 1;
    NextPage(&ulValue);
    (sNAND.pfnErase)(HwNANDAddress, ulValue / sNAND.ucPagesPerBlock);
    NANDWaitTilNotBusy(HwNANDAddress);
    (sNAND.pfnWrite)(HwNANDAddress, ulValue, pucBuffer, pucWriteBuffer);
    NANDWaitTilNotBusy(HwNANDAddress);
}

//****************************************************************************
//
// The file system entry point for the on-board NAND FLASH.
//
//****************************************************************************
unsigned long
NANDIoctl(unsigned char *pucScratch, unsigned char *pucWriteBuffer,
          unsigned long ulIoctl, unsigned long ulInstance,
          unsigned long ulParam1, unsigned long ulParam2)
{
    volatile unsigned long *pulGPIO = (unsigned long *)HwBaseAddress;

    //
    // If we are being initialized, then we need to setup our global variables.
    //
    if(ulIoctl == IOCTL_FS_INIT)
    {
        unsigned long ulDeviceID;

        //
        // Select the on-board NAND.
        //
        pulGPIO[HwPortABCD >> 2] &= ~HwPortABCD_NAND1_CS;

        //
        // Get the ID of the on-board NAND FLASH.
        //
        ulDeviceID = NANDGetID(HwNANDAddress);

        //
        // Determine the size and geometry of the on-board NAND FLASH.
        //
        switch(ulDeviceID)
        {
            //
            // The device capacity is 4MB.
            //
            case 0x6B:
            case 0xE3:
            case 0xE5:
            {
                //
                // There are 512 blocks in this device.
                //
                sNAND.usNumBlocks = 512;

                //
                // There are 16 pages per block in this device.
                //
                sNAND.ucPagesPerBlock = 16;

                //
                // Fill in the function pointers for accessing this FLASH
                // device.
                //
                sNAND.pfnRead = NANDRead_512_3;
                sNAND.pfnWrite = NANDWrite_512_3;
                sNAND.pfnErase = NANDErase_16;

                //
                // We've interpreted the device ID.
                //
                break;
            }

            //
            // The device capacity is 8MB.
            //
            case 0xE6:
            {
                //
                // There are 1024 blocks in this device.
                //
                sNAND.usNumBlocks = 1024;

                //
                // There are 16 pages per block in this device.
                //
                sNAND.ucPagesPerBlock = 16;

                //
                // Fill in the function pointers for accessing this FLASH
                // device.
                //
                sNAND.pfnRead = NANDRead_512_3;
                sNAND.pfnWrite = NANDWrite_512_3;
                sNAND.pfnErase = NANDErase_16;

                //
                // We've interpreted the device ID.
                //
                break;
            }

            //
            // The device capacity is 16MB.
            //
            case 0x73: