usrmtdlib.c

vxworks MPC8541 BSP

/* usrMtdLib.c - TrueFFS MTD for Flash devices *//*lyf@ok*/

/* Copyright 2003-2004 ZTE of ShangHai, Inc. */

/*
modification history
--------------------
01a,dec2004,lzq  created by Liuzq.
*/

/* includes */

#include "tffs/flflash.h"
#include "tffs/backgrnd.h"
#include "stdio.h"

#include "sysFlashMem.h"
/*
#include "configFlashMem.h"
*/

#ifdef INCLUDE_TFFS

/* defines */

/* globals */

/* locals */

LOCAL const char *badVolMsg = "Invalid volNo: "; 

/* forward */


/*******************************************************************************
*
* usrMtdRead - MTD read routine
*
* This routine will be registered as the MTD vol.read routine
*
* Parameters:
* vol       : Pointer identifying drive
* address   : Card address to read from
* buffer    : Address of data to read
* length    : Number of bytes to read
* overwrite : TRUE if overwriting old Flash contents
*             FALSE if old contents are known to be erased
*
* RETURNS: OK on success, failed otherwise
*/

static FLStatus usrMtdRead
    (
    FLFlash     vol,
    CardAddress address,
    void FAR1  *buffer,
    int         length,
    int         modes
    )
    {
    FLStatus    retVal = flOK;
    unsigned    volNo = vol.socket->volNo;

    switch (volNo)
        {
        case 0:
            retVal = flashRead (FLASH_DEV_DATAM, address, (char *)buffer, length);
            break;

        /* lyf del
        case 1:
            retVal = flashRead (FLASH_DEV_DATAB, address, (char *)buffer, length);
            break;
        case 2:
            retVal = flashRead (FLASH_DEV_VERM, address, (char *)buffer, length);
            break;
        case 3:
            retVal = flashRead (FLASH_DEV_VERB, address, (char *)buffer, length);
            break;
        */
        default:
            printf ("%s%d\n", badVolMsg, volNo);
            return(ERROR);
          /*  break;*/
        }

    /*retVal = flashRead (FLASH_DEV_FS, address, (char *)buffer, length);*/

    return retVal;
    }

/*******************************************************************************
*
* usrMtdWrite - MTD write routine
*
* This routine will be registered as the MTD vol.write routine
*
* Parameters:
* vol       : Pointer identifying drive
* address   : Card address to write to
* buffer    : Address of data to write
* length    : Number of bytes to write
* overwrite : TRUE if overwriting old Flash contents
*             FALSE if old contents are known to be erased
*
* RETURNS: OK on success, failed otherwise
*/

static FLStatus usrMtdWrite
    (
    FLFlash     vol,
    CardAddress address,
    const void *buffer,
    int         length,
    int         modes
    )
    {
    FLStatus    retVal = flOK;
    unsigned    volNo = vol.socket->volNo;

    if (flWriteProtected (vol.socket))
        return flWriteProtect;

#ifdef SOCKET_12_VOLTS
    checkStatus (flNeedVpp (vol.socket));
#endif

    switch (volNo)
        {
        case 0:
            retVal = flashWrite (FLASH_DEV_DATAM, address, (char *)buffer, length);
            break;

        /* lyf del
        case 1:
            retVal = flashWrite (FLASH_DEV_DATAB, address, (char *)buffer, length);
            break;
        case 2:
            retVal = flashWrite (FLASH_DEV_VERM, address, (char *)buffer, length);
            break;
        case 3:
            retVal = flashWrite (FLASH_DEV_VERB, address, (char *)buffer, length);
            break;
        */
        default:
            printf ("%s%d\n", badVolMsg, volNo);
            return (ERROR);
           /* break;*/
        }

    /*retVal = flashWrite (FLASH_DEV_FS, address, (char *)buffer, length);*/

    return retVal;
    }

/*******************************************************************************
*
* usrMtdErase - MTD erase routine
*
* This routine will be registered as the MTD vol.erase routine
*
* Parameters:
* vol       : Pointer identifying drive
* firstErasableBlock : Number of first block to erase
* numOfErasableBlocks: Number of blocks to erase
*
* RETURNS: OK on success, failed otherwise
*/

static FLStatus usrMtdErase
    (
    FLFlash vol,
    int     firstErasableBlock,
    int     numOfErasableBlocks
    )
    {
    FLStatus retVal = flOK;
    CardAddress address;
    int length;
    unsigned volNo = vol.socket->volNo;

    if (flWriteProtected (vol.socket))
        return flWriteProtect;

#ifdef SOCKET_12_VOLTS
    checkStatus (flNeedVpp (vol.socket));
#endif

    address = firstErasableBlock * vol.erasableBlockSize;
    length = numOfErasableBlocks * vol.erasableBlockSize;
    switch (volNo)
        {
        case 0:
            retVal = flashErase (FLASH_DEV_DATAM, address, length);
            break;
        /* lyf del
        case 1:
            retVal = flashErase (FLASH_DEV_DATAB, address, length);
            break;
        case 2:
            retVal = flashErase (FLASH_DEV_VERM, address, length);
            break;
        case 3:
            retVal = flashErase (FLASH_DEV_VERB, address, length);
            break;
        */
        default:
            printf ("%s%d\n", badVolMsg, volNo);
            return(ERROR);
           /* break;*/
        }

    /*retVal = flashErase (FLASH_DEV_FS, address, length);*/

#ifdef SOCKET_12_VOLTS
    flDontNeedVpp (vol.socket);
#endif

    return retVal;
    }

/*******************************************************************************
*
* usrMtdIdentify - MTD identify routine
*
* This routine will be placed on the MTD list in flcustom.h. It must
* be an extern routine.
* On successful identification, the Flash structure is filled out and
* the read, write and erase routines registered.
*
* Parameters:
* vol           : Pointer identifying drive
*
* RETURNS: OK on positive identificaion, failed otherwise
*/

FLStatus usrMtdIdentify
    (
    FLFlash vol
    )
    {
    FLASH_DEV   *dev = NULL;
    unsigned int winSize;
    unsigned     volNo = vol.socket->volNo;

    switch (volNo)
        {
        case 0:
            dev = FLASH_DEV_DATAM;
            break;
        /* lyf del
        case 1:
            dev = FLASH_DEV_DATAB;
            break;
        case 2:
            dev = FLASH_DEV_VERM;
            break;
        case 3:
            dev = FLASH_DEV_VERB;
            break;
        */
        default:
            printf ("%s%d\n", badVolMsg, volNo);
            return (ERROR);
          /*  break;*/
        }

    /*FLASH_DEV *dev = FLASH_DEV_FS;*/

    if (flashInit () != OK)
        return flBadFunction;

    winSize = dev->devSize;
    if (winSize & (winSize - 1))
        {
        winSize = dev->devSize * 2 - 1;
        while (winSize & (winSize - 1))
            winSize &= winSize - 1;
        }

    flSetWindowBusWidth (vol.socket, dev->portSize * 8);
    flSetWindowSpeed (vol.socket, 150);
    flSetWindowSize (vol.socket, winSize >> 12);

    vol.type = (FlashType)(*(UINT16 *)&(dev->unit->phy->flashID->deviceID));
    vol.interleaving = 1;
    vol.noOfChips = 1;
    vol.chipSize = dev->devSize;
    vol.erasableBlockSize = dev->bankCount * dev->devPart->blockSize;

    vol.read  = usrMtdRead;
    vol.write = usrMtdWrite;
    vol.erase = usrMtdErase;

    return flOK;
    }

#endif /* INCLUDE_TFFS */