amd29lvmtd.c

VxWorks5.5版本下的TrueFFS文件系统demo源代码

/* amd29LvMtd.c - TrueFFS MTD for AMD AM29LV devices */
 
/* Copyright 2000 Wind River, Inc. */

/*
modification history
--------------------
01h,27oct01,mil  Removed inline eieio and replaced with CACHE_PIPE_FLUSH().
01g,11oct01,mil  Merged from post T2.1 release into T2.2.
01f,22aug01,mil  Decoupled this MTD from BSP by using tffsFlashBaseAdrs from
                 sysTffs.c.
01e,21aug01,mil  Created in mcpn765 for TFFS until merged back to
                 target/src/drv/tffs/amdmtd.c.
01d,06aug00,srr  Modified amd29lv323CT support for 16 MB.
01c,31jul00,cak  Renamed from mv2400mtd to amd29lvmtd.
                 Added support for the amd29lv323. 
01b,09may00,add  Fixed erase bug (last 4 sectors are odd sizes)
01a,21apr00,add  Created.
*/

/*
DESCRIPTION
This module implements an TrueFFS MTD for the AMD AM29LV160D and
AM29LV323 flash devices.
 
*/

/* includes */

#include <vxWorks.h>
#include <taskLib.h>
#include <logLib.h>
#include <stdio.h>
#include <cacheLib.h>

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

IMPORT int sysClkRateGet();

/* defines */

#define AMD29LV_MTD_SECTOR_SIZE         (0x40000)
#define AMD29LV_160_CHIP_SIZE           (0x800000)	/*  8MB */
#define AMD29LV_160_LAST_SECTOR_NUM     (AMD29LV_160_CHIP_SIZE / AMD29LV_MTD_SECTOR_SIZE - 1)

#define AMD29LV_323_CHIP_SIZE           (0x1000000)	/* 16MB */
#define AMD29LV_323_LAST_SECTOR_SIZE    (0x8000)
#define AMD29LV_323_LAST_SECTOR_NUM     (AMD29LV_323_CHIP_SIZE / AMD29LV_MTD_SECTOR_SIZE - 1)

#define AMD29LV_MTD_CHIP_CNT            (1)
#define AMD29LV_MTD_INTERLEAVE          (1)

#define DEBUG_READ     0x00000001
#define DEBUG_WRITE    0x00000002
#define DEBUG_PROGRAM  0x00000004
#define DEBUG_ERASE    0x00000008
#define DEBUG_ID       0x00000010
#define DEBUG_MAP      0x00000020
#define DEBUG_PROG32   0x00000040
#define DEBUG_ALWAYS   0xffffffff

#define DEBUG
#ifdef  DEBUG
    LOCAL UINT32 debug;
    #define DEBUG_PRINT(mask, string) \
                if ((debug & mask) || (mask == DEBUG_ALWAYS)) \
                printf string
#else
    #define DEBUG_PRINT(mask, string)
#endif

/* local routines */

LOCAL FLStatus amd29lvSectorRangeErase(FLFlash* pVol, int, int);

LOCAL FLStatus amd29lvProgram(FLFlash*, CardAddress, const void FAR1*, int,
                             FLBoolean);

LOCAL void FAR0* amd29lvMap(FLFlash*, CardAddress, int);

LOCAL void flashReset(FLFlash*, BOOL);
LOCAL void flashIdGet(FLFlash*, UINT16*, UINT16*);
LOCAL void flashUnlock(FLFlash*, BOOL);
LOCAL STATUS flashProgram32Bits(FLFlash*, volatile UINT32*, UINT32, BOOL);
LOCAL void flashRegWrite32Bits(FLFlash*, UINT32, UINT32, BOOL);
LOCAL UINT16 flashRegRead16Bits(FLFlash*, UINT32, BOOL);
LOCAL STATUS flashHalfSectorErase(FLFlash*, int, BOOL);


/******************************************************************************
*
* amd29lvMTDIdentify - MTD identify routine (see TrueFFS Programmer's Guide)
*
* RETURNS: FLStatus
*
*/

FLStatus amd29lvMTDIdentify
    (
    FLFlash* pVol
    )
    {
    UINT16 manCode;
    UINT16 devCode;

    flashIdGet(pVol, &manCode, &devCode);

    if (manCode != 0x0001)
        {
        DEBUG_PRINT(DEBUG_ALWAYS,
                    ("amd29lvMTDIdentify Manufacturer unknown: 0x%02x\n",
                    manCode));
        return(flUnknownMedia);
        }

    if (devCode == 0x22C4)		/* amd29LV160BT */
	{
	pVol->type = 0x01C4;
	pVol->erasableBlockSize = AMD29LV_MTD_SECTOR_SIZE;
	pVol->chipSize = AMD29LV_160_CHIP_SIZE;
	pVol->noOfChips = AMD29LV_MTD_CHIP_CNT;
	pVol->interleaving = AMD29LV_MTD_INTERLEAVE;
	pVol->write = amd29lvProgram;
	pVol->erase = amd29lvSectorRangeErase;
	pVol->map = amd29lvMap;
	}
    else if (devCode == 0x2250)		/* amd29LV323CT */
	{
	pVol->type = 0x0150;
	pVol->erasableBlockSize = AMD29LV_MTD_SECTOR_SIZE;
	pVol->chipSize = AMD29LV_323_CHIP_SIZE;
	pVol->noOfChips = AMD29LV_MTD_CHIP_CNT;
	pVol->interleaving = AMD29LV_MTD_INTERLEAVE;
	pVol->write = amd29lvProgram;
	pVol->erase = amd29lvSectorRangeErase;
	pVol->map = amd29lvMap;
	}
    else
        {
        DEBUG_PRINT(DEBUG_ALWAYS,
                    ("amd29lvMTDIdentify Device unknown: 0x%02x\n",
                    devCode));
        return(flUnknownMedia);
        }    

    DEBUG_PRINT(DEBUG_ID, ("amd29lvMTDIdentify succeeds!\n"));
    return(flOK);
    }

/******************************************************************************
*
* amd29lvProgram - MTD write routine (see TrueFFS Programmer's Guide)
*
* RETURNS: FLStatus
*
*/

LOCAL FLStatus amd29lvProgram
    (
    FLFlash*          pVol,
    CardAddress       address,
    const void FAR1*  buffer,
    int               length,
    FLBoolean         overwrite
    )

    {
    volatile UINT32* pFlash;
    UINT32* pBuffer;
    STATUS rc = OK;
    BOOL upper;
    int i;
    BOOL doFree = FALSE;

    DEBUG_PRINT(DEBUG_PROGRAM,
                ("Program: 0x%08x, 0x%08x, %d\n", (unsigned int) address,
                 length, overwrite));

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

    /* Check alignment */

    if (((address & 0x03) != 0) || (((UINT32) buffer) &  0x03))
        {
        DEBUG_PRINT(DEBUG_ALWAYS, ("amd29lvProgram: Alignment error\n"));
        return(flBadParameter);
        }

    if (overwrite && length == 2)
        {
        int sector;
        int offset;

        pFlash = (volatile UINT32*) pVol->map(pVol, address, length);

        pBuffer = (UINT32*) malloc(AMD29LV_MTD_SECTOR_SIZE);

        if (pBuffer == 0)
            {
            DEBUG_PRINT(DEBUG_ALWAYS, ("amd29lvProgram: No memory\n"));
            return(flBadParameter);
            }

        /* Determine sector and offset */

        sector = address / AMD29LV_MTD_SECTOR_SIZE;
        offset = address % AMD29LV_MTD_SECTOR_SIZE;

        DEBUG_PRINT(DEBUG_PROGRAM,("Overwrite sector: 0x%08x, offset: 0x%08x\n",
                    sector,offset));

        /* Get a pointer to the flash sector */

        pFlash = (volatile UINT32*) pVol->map(pVol,
                                              sector * AMD29LV_MTD_SECTOR_SIZE,
                                              AMD29LV_MTD_SECTOR_SIZE);


        /* Copy the sector from flash to memory */

        memcpy(pBuffer, (void*) pFlash, AMD29LV_MTD_SECTOR_SIZE);

        /* Overwrite the sector in memory */

       memcpy(((UINT8*) pBuffer) + offset, buffer, length);

        /* Erase sector */

        rc = amd29lvSectorRangeErase(pVol, sector, 1);
        if (rc != flOK)
            {
            free(pBuffer);
            return(rc);
            }

        length = AMD29LV_MTD_SECTOR_SIZE;
        doFree = TRUE;
        }

    else
        {
        if ((length & 0x03) != 0)
            {
            DEBUG_PRINT(DEBUG_ALWAYS, ("amd29lvProgram: length: %d\n", length));

            return(flBadParameter);
            }

        pBuffer = (UINT32*) buffer;
        pFlash = (volatile UINT32*) pVol->map(pVol, address, length);
        }

    /* Program 'length' bytes (4 bytes each iterations) */

    upper = ((((UINT32) pFlash) & 0x04) != 0);
    for (i = 0; i < (length / 4); i++, pFlash++, upper = !upper)
        {

        /* Don't bother programming if buffer data == format value */

        if (pBuffer[i] == 0xffffffff)
            continue;

        /* Program 32 bits */

        rc = flashProgram32Bits(pVol, pFlash, pBuffer[i], upper);
        if (rc != OK)
            break;
        }

    if (doFree)
        {
        free(pBuffer);
        }

    return((rc == OK) ? flOK : flTimedOut);

    }

/******************************************************************************
*
* amd29lvSectorRangeErase - MTD erase routine (see TrueFFS Programmer's Guide)
*
* RETURNS: FLStatus
*
*/

LOCAL FLStatus amd29lvSectorRangeErase
    (
    FLFlash* pVol,
    int sectorNum,
    int sectorCount
    )
    {
    int i;
    STATUS rc;

    /* Check for valid range */

    if (pVol->type == 0x1C4)			/* amd29LV160BT */
	{
	if (sectorNum + sectorCount >  AMD29LV_160_LAST_SECTOR_NUM + 1)
	    {
	    DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n",
	                sectorNum, sectorCount));
	    }

	/* Last sector is really 4 seperately erasable sectors */

	if (sectorNum + sectorCount == AMD29LV_160_LAST_SECTOR_NUM + 1)
	    {
	    sectorCount += 3;
	    }
	}
    else					 /* amd29LV323CT */
	{
	if (sectorNum + sectorCount >  AMD29LV_323_LAST_SECTOR_NUM + 1)
	    {
	    DEBUG_PRINT(DEBUG_ALWAYS, ("Invalid sector range: %d - %d\n",
	                sectorNum, sectorCount));
	    }

	/* Last sector is really 8 seperately erasable sectors */

	if (sectorNum + sectorCount == AMD29LV_323_LAST_SECTOR_NUM + 1)
	    {
	    sectorCount += 7;
	    }
	}

    for (i = 0; i < sectorCount; i++)
        {

        /* Erase lower half */

        rc = flashHalfSectorErase(pVol, sectorNum + i, FALSE);
        if (rc != OK)
            return(flTimedOut);

        /* Erase upper half */

        rc = flashHalfSectorErase(pVol, sectorNum + i, TRUE);
        if (rc != OK)
            return(flTimedOut);
        }
    return(flOK);
    }


/******************************************************************************
*
* amd29lvMap - MTD map routine (see TrueFFS Programmer's Guide)
*
* RETURNS: FLStatus
*
*/
LOCAL void FAR0* amd29lvMap
    (
    FLFlash* pVol,
    CardAddress address,
    int length
    )
    {
    UINT32 flashBaseAddr = (pVol->socket->window.baseAddress << 12);
    void FAR0* pFlash = (void FAR0*) (flashBaseAddr + address);
    DEBUG_PRINT(DEBUG_MAP, ("Mapping 0x%08x bytes at 0x%08x to %p\n", length,
                (unsigned int) address, pFlash));
    return(pFlash);
    }


/******************************************************************************
*
* flashProgram32Bits - Program 32 bits at 4 byte aligned address.
*
* RETURNS: OK or ERROR
*
*/