|
|
/*
* $Log: V:/Flite/archives/TrueFFS5/Src/FLFLASH.C_V $ * * Rev 1.12 Apr 15 2002 07:36:38 oris * Bug fix - do not initialize access routines in case of user defined routines - as a result docsys must be included. * * Rev 1.11 Jan 28 2002 21:24:38 oris * Changed memWinowSize to memWindowSize. * * Rev 1.10 Jan 17 2002 23:09:30 oris * Added flFlashOf() routine to allow the use of a single FLFlash record per socket . * Added memory access routines initialization for FLFlash. * Bug fix - if M+ device was registered after 8-bit DiskOnChip and the M+ had a bad download problem , the error would not be reported, but only flUnknown media. * * Rev 1.9 Sep 15 2001 23:46:00 oris * Changed erase routine to support up to 64K erase blocks. * * Rev 1.8 Jul 13 2001 01:04:38 oris * Added new field initialization in FLFlash record - Max Erase Cycles of the flash. * * Rev 1.7 May 16 2001 21:18:24 oris * Removed warnings. * * Rev 1.6 May 02 2001 06:41:26 oris * Removed the lastUsableBlock variable. * * Rev 1.5 Apr 24 2001 17:07:52 oris * Bug fix - missing NULL initialization for several compilation flags. * Added lastUsableBlock field defualt initialization. * * Rev 1.4 Apr 16 2001 13:39:14 oris * Bug fix read and write default routines were not initialized. * Initialize the firstUsableBlock. * Removed warrnings. * * Rev 1.3 Apr 12 2001 06:50:22 oris * Added initialization of download routine pointer. * * Rev 1.2 Apr 09 2001 15:09:04 oris * End with an empty line. * * Rev 1.1 Apr 01 2001 07:54:08 oris * copywrite notice. * Changed prototype of :flashRead. * Removed interface b initialization (experimental MTD interface for mdocp). * Spelling mistake "changableProtectedAreas". * Added check for bad download in flash recognition. * * Rev 1.0 Feb 04 2001 11:21:16 oris * Initial revision. * */
/***********************************************************************************//* M-Systems Confidential *//* Copyright (C) M-Systems Flash Disk Pioneers Ltd. 1995-2001 *//* All Rights Reserved *//***********************************************************************************//* NOTICE OF M-SYSTEMS OEM *//* SOFTWARE LICENSE AGREEMENT *//* *//* THE USE OF THIS SOFTWARE IS GOVERNED BY A SEPARATE LICENSE *//* AGREEMENT BETWEEN THE OEM AND M-SYSTEMS. REFER TO THAT AGREEMENT *//* FOR THE SPECIFIC TERMS AND CONDITIONS OF USE, *//* OR CONTACT M-SYSTEMS FOR LICENSE ASSISTANCE: *//* E-MAIL = [email protected] *//***********************************************************************************/
#include "flflash.h"
#include "docsys.h"
#define READ_ID 0x90
#define INTEL_READ_ARRAY 0xff
#define AMD_READ_ARRAY 0xf0
/* MTD registration information */
int noOfMTDs = 0;
MTDidentifyRoutine mtdTable[MTDS];static FLFlash vols[SOCKETS];
FLStatus dataErrorObject;
/*----------------------------------------------------------------------*//* f l F l a s h O f *//* *//* Gets the flash connected to a volume no. *//* *//* Parameters: *//* volNo : Volume no. for which to get flash *//* *//* Returns: *//* flash of volume no. *//*----------------------------------------------------------------------*/
FLFlash *flFlashOf(unsigned volNo){ return &vols[volNo];}
/*----------------------------------------------------------------------*//* f l a s h M a p *//* *//* Default flash map method: Map through socket window. *//* This method is applicable for all NOR Flash *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : Card address to map *//* length : Length to map (irrelevant here) *//* *//* Returns: *//* Pointer to required card address *//*----------------------------------------------------------------------*/
static void FAR0 *flashMap(FLFlash vol, CardAddress address, int length){ return flMap(vol.socket,address);}
/*----------------------------------------------------------------------*//* f l a s h R e a d *//* *//* Default flash read method: Read by copying from mapped address *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : Card address to read *//* buffer : Area to read into *//* length : Length to read *//* *//*----------------------------------------------------------------------*/
static FLStatus flashRead(FLFlash vol, CardAddress address, void FAR1 *buffer, dword length, word mode){ tffscpy(buffer,vol.map(&vol,address,(word)length),(word)length);
return flOK;}
/*----------------------------------------------------------------------*//* f l a s h N o W r i t e *//* *//* Default flash write method: Write not allowed (read-only mode) *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : Card address to write *//* buffer : Area to write from *//* length : Length to write *//* *//* Returns: *//* Write-protect error *//*----------------------------------------------------------------------*/
static FLStatus flashNoWrite(FLFlash vol, CardAddress address, const void FAR1 *from, dword length, word mode){ return flWriteProtect;}
/*----------------------------------------------------------------------*//* f l a s h N o E r a s e *//* *//* Default flash erase method: Erase not allowed (read-only mode) *//* *//* Parameters: *//* vol : Pointer identifying drive *//* firstBlock : No. of first erase block *//* noOfBlocks : No. of contiguous blocks to erase *//* *//* Returns: *//* Write-protect error *//*----------------------------------------------------------------------*/
static FLStatus flashNoErase(FLFlash vol, word firstBlock, word noOfBlocks){ return flWriteProtect;}
/*----------------------------------------------------------------------*//* s e t N o C a l l b a c k *//* *//* Register power on callback routine. Default: no routine is *//* registered. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//*----------------------------------------------------------------------*/
static void setNoCallback(FLFlash vol){ flSetPowerOnCallback(vol.socket,NULL,NULL);}
/*----------------------------------------------------------------------*//* f l I n t e l I d e n t i f y *//* *//* Identify the Flash type and interleaving for Intel-style Flash. *//* Sets the value of vol.type (JEDEC id) & vol.interleaving. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* amdCmdRoutine : Routine to read-id AMD/Fujitsu style at *//* a specific location. If null, Intel procedure *//* is used. *//* idOffset : Chip offset to use for identification *//* *//* Returns: *//* FLStatus : 0 = OK, otherwise failed (invalid Flash array)*//*----------------------------------------------------------------------*/
void flIntelIdentify(FLFlash vol, void (*amdCmdRoutine)(FLFlash vol, CardAddress, unsigned char, FlashPTR), CardAddress idOffset){ int inlv;
unsigned char vendorId = 0; FlashPTR flashPtr = (FlashPTR) flMap(vol.socket,idOffset); unsigned char firstByte = 0; unsigned char resetCmd = amdCmdRoutine ? AMD_READ_ARRAY : INTEL_READ_ARRAY;
for (inlv = 0; inlv < 15; inlv++) { /* Increase interleaving until failure */ flashPtr[inlv] = resetCmd; /* Reset the chip */ flashPtr[inlv] = resetCmd; /* Once again for luck */ if (inlv == 0) firstByte = flashPtr[0]; /* Remember byte on 1st chip */ if (amdCmdRoutine) /* AMD: use unlock sequence */ amdCmdRoutine(&vol,idOffset + inlv, READ_ID, flashPtr); else flashPtr[inlv] = READ_ID; /* Read chip id */ if (inlv == 0) vendorId = flashPtr[0]; /* Assume first chip responded */ else if (flashPtr[inlv] != vendorId || firstByte != flashPtr[0]) { /* All chips should respond in the same way. We know interleaving = n */ /* when writing to chip n affects chip 0. */
/* Get full JEDEC id signature */ vol.type = (FlashType) ((vendorId << 8) | flashPtr[inlv]); flashPtr[inlv] = resetCmd; break; } flashPtr[inlv] = resetCmd; }
if (inlv & (inlv - 1)) vol.type = NOT_FLASH; /* not a power of 2, no way ! */ else#ifndef NT5PORT
vol.interleaving = inlv;#else
vol.interleaving = (Sword)inlv;#endif /*NT5PORT*/
}
/*----------------------------------------------------------------------*//* i n t e l S i z e *//* *//* Identify the card size for Intel-style Flash. *//* Sets the value of vol.noOfChips. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* amdCmdRoutine : Routine to read-id AMD/Fujitsu style at *//* a specific location. If null, Intel procedure *//* is used. *//* idOffset : Chip offset to use for identification *//* *//* Returns: *//* FLStatus : 0 = OK, otherwise failed (invalid Flash array)*//*----------------------------------------------------------------------*/
FLStatus flIntelSize(FLFlash vol, void (*amdCmdRoutine)(FLFlash vol, CardAddress, unsigned char, FlashPTR), CardAddress idOffset){ unsigned char resetCmd = amdCmdRoutine ? AMD_READ_ARRAY : INTEL_READ_ARRAY; FlashPTR flashPtr = (FlashPTR) vol.map(&vol,idOffset,0);
if (amdCmdRoutine) /* AMD: use unlock sequence */ amdCmdRoutine(&vol,0,READ_ID, flashPtr); else flashPtr[0] = READ_ID; /* We leave the first chip in Read ID mode, so that we can */ /* discover an address wraparound. */
for (vol.noOfChips = 0; /* Scan the chips */ vol.noOfChips < 2000; /* Big enough ? */ vol.noOfChips += vol.interleaving) { int i;
flashPtr = (FlashPTR) vol.map(&vol,vol.noOfChips * vol.chipSize + idOffset,0);
/* Check for address wraparound to the first chip */ if (vol.noOfChips > 0 && (FlashType) ((flashPtr[0] << 8) | flashPtr[vol.interleaving]) == vol.type) goto noMoreChips; /* wraparound */
/* Check if chip displays the same JEDEC id and interleaving */ for (i = (vol.noOfChips ? 0 : 1); i < vol.interleaving; i++) { if (amdCmdRoutine) /* AMD: use unlock sequence */ amdCmdRoutine(&vol,vol.noOfChips * vol.chipSize + idOffset + i, READ_ID, flashPtr); else flashPtr[i] = READ_ID; if ((FlashType) ((flashPtr[i] << 8) | flashPtr[i + vol.interleaving]) != vol.type) goto noMoreChips; /* This "chip" doesn't respond correctly, so we're done */
flashPtr[i] = resetCmd; } }
noMoreChips: flashPtr = (FlashPTR) vol.map(&vol,idOffset,0); flashPtr[0] = resetCmd; /* reset the original chip */
return (vol.noOfChips == 0) ? flUnknownMedia : flOK;}
/*----------------------------------------------------------------------*//* i s R A M *//* *//* Checks if the card memory behaves like RAM *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* 0 = not RAM-like, other = memory is apparently RAM *//*----------------------------------------------------------------------*/
static FLBoolean isRAM(FLFlash vol){#ifndef NT5PORT
FlashPTR flashPtr = (FlashPTR) flMap(vol.socket,0); unsigned char firstByte = flashPtr[0]; char writeChar = (firstByte != 0) ? 0 : 0xff; volatile int zero=0;#else
FlashPTR flashPtr = (FlashPTR) flMap(vol.socket,0); unsigned char firstByte; char writeChar; volatile int zero=0; if(flashPtr == NULL){ DEBUG_PRINT(("Debug:isRAM(): NULL Pointer.\n")); } firstByte = flashPtr[0]; writeChar = (firstByte != 0) ? 0 : 0xff;#endif //NT5PORT
flashPtr[zero] = writeChar; /* Write something different */ if (flashPtr[zero] == writeChar) { /* Was it written ? */ flashPtr[zero] = firstByte; /* must be RAM, undo the damage */
DEBUG_PRINT(("Debug: error, socket window looks like RAM.\r\n")); return TRUE; } return FALSE;}
/*----------------------------------------------------------------------*//* f l I d e n t i f y F l a s h *//* *//* Identify the current Flash medium and select an MTD for it *//* *//* Parameters: *//* socket : Socket of flash *//* vol : New volume pointer *//* *//* Returns: *//* FLStatus : 0 = Flash was identified *//* other = identification failed *//*----------------------------------------------------------------------*/
FLStatus flIdentifyFlash(FLSocket *socket, FLFlash vol){ FLStatus status = flUnknownMedia; int iMTD; dword blockSize;
vol.socket = socket;
#ifndef FIXED_MEDIA
/* Check that we have a media */ flResetCardChanged(vol.socket); /* we're mounting anyway */ checkStatus(flMediaCheck(vol.socket));#endif
#ifdef ENVIRONMENT_VARS
if(flUseisRAM==1) {#endif
if ( isRAM(&vol)) return flUnknownMedia; /* if it looks like RAM, leave immediately */#ifdef ENVIRONMENT_VARS
}#endif
/* Install default methods */ vol.type = NOT_FLASH; vol.mediaType = NOT_DOC_TYPE; vol.pageSize = 0; vol.flags = 0; vol.map = flashMap; vol.read = flashRead; vol.setPowerOnCallback = setNoCallback; vol.erase = flashNoErase; vol.write = flashNoWrite; vol.readBBT = NULL; vol.writeIPL = NULL; vol.readIPL = NULL;#ifdef HW_OTP
vol.otpSize = NULL; vol.readOTP = NULL; vol.writeOTP = NULL; vol.getUniqueId = NULL;#endif /* HW_OTP */
#ifdef HW_PROTECTION
vol.protectionBoundries = NULL; vol.protectionKeyInsert = NULL; vol.protectionKeyRemove = NULL; vol.protectionType = NULL; vol.protectionSet = NULL;#endif /* HW_PROTECTION */
vol.download = NULL; vol.enterDeepPowerDownMode = NULL;#ifndef FL_NO_USE_FUNC
if(flBusConfig[flSocketNoOf(socket)] != FL_ACCESS_USER_DEFINED); { vol.memRead = NULL; vol.memWrite = NULL; vol.memSet = NULL; vol.memRead8bit = NULL; vol.memWrite8bit = NULL; vol.memRead16bit = NULL; vol.memWrite16bit = NULL; vol.memWindowSize = NULL; }#endif /* FL_NO_USE_FUNC */
/* Setup arbitrary parameters for read-only mount */ vol.chipSize = 0x100000L; vol.erasableBlockSize = 0x1000L; vol.noOfChips = 1; vol.interleaving = 1; vol.noOfFloors = 1; vol.totalProtectedAreas = 0; vol.changeableProtectedAreas = 0; vol.ppp = 5; vol.firstUsableBlock = 0; vol.maxEraseCycles = 100000L; /* Defaul for NOR */
#ifdef NT5PORT
vol.readBufferSize = 0; vol.readBuffer = NULL;#endif /*NT5PORT*/
/* Attempt all MTD's */ for (iMTD = 0; (iMTD < noOfMTDs) && (status != flOK) && (status != flBadDownload); iMTD++) status = mtdTable[iMTD](&vol);
if (status == flBadDownload) { DEBUG_PRINT(("Debug: Flash media reported bad download error.\r\n")); return flBadDownload; }
if (status != flOK) /* No MTD recognition */ { DEBUG_PRINT(("Debug: did not identify flash media.\r\n")); return flUnknownMedia; }
/* Calculate erasable Block Size Bits */ for(blockSize = vol.erasableBlockSize>>1,vol.erasableBlockSizeBits = 0; blockSize>0; vol.erasableBlockSizeBits++,blockSize = blockSize >> 1);
return flOK;
}
#ifdef NT5PORT
VOID * mapThroughBuffer(FLFlash vol, CardAddress address, LONG length){ if ((ULONG) length > vol.readBufferSize) { vol.readBufferSize = 0; if (vol.readBuffer) { FREE(vol.readBuffer); } vol.readBuffer = MALLOC(length); if (vol.readBuffer == NULL) { return vol.readBuffer; } vol.readBufferSize = length; } vol.read(&vol,address,vol.readBuffer,length,0); return vol.readBuffer;}#endif /* NT5PORT */
|
