mirror of https://github.com/tongzx/nt5src
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2771 lines
108 KiB
2771 lines
108 KiB
/*
|
|
* $Log: V:/Flite/archives/TrueFFS5/Src/DISKONC.C_V $
|
|
*
|
|
* Rev 1.33 Apr 15 2002 07:35:04 oris
|
|
* Changed usage and logic of checkToggle to be more intuitive.
|
|
* Added support for new access layer (docsys). MTD now initializes the
|
|
* access layer accessing the DiskOnChip registers.
|
|
* Bug fix - doc2write did not report write faults in case runtime verify
|
|
* write was not required.
|
|
* Bug fix - bad compilation ifdef in readBBT routine might cause a write
|
|
* operation while FL_READ_ONLY is defined or to compile the
|
|
* reconstruct BBT code even if MTD_RECONSTRUCT_BBT is
|
|
* not defined.
|
|
*
|
|
* Rev 1.32 Jan 29 2002 20:07:30 oris
|
|
* Changed sanity check of write IPL modes.
|
|
*
|
|
* Rev 1.31 Jan 28 2002 21:23:58 oris
|
|
* Removed the use of back-slashes in macro definitions.
|
|
* Added FL_IPL_DOWNLOAD flag to writeIPL routine in order to control whether the IPL will be reloaded after the update.
|
|
* Bug fix - writeIPL routine did not support buffers smaller then 1024 bytes.
|
|
* Bug fix - writeIPL routine did not write the second copy of the IPL correctly (for both 512 bytes).
|
|
* Changed docwrite and docset calls to separate DiskOnChip base window pointer and IO registers offset (for address shifting).
|
|
* Replaced FLFlash argument with DiskOnChip memory base pointer in calls to docwrite , docset and docread.
|
|
* Removed win_io initialization (one of FLFlash record fields).
|
|
* Improved check for flSuspend.
|
|
*
|
|
* Rev 1.30 Jan 23 2002 23:31:04 oris
|
|
* Added writeIPL routine (copied from blockdev.c).
|
|
* Made writeIPL and download routines available even when MTD_STANDALONE is defined.
|
|
* Bug fix - checkErase routine was unreasonably slow.
|
|
* Changed DFORMAT_PRINT syntax.
|
|
*
|
|
* Rev 1.29 Jan 21 2002 20:43:50 oris
|
|
* Compilation errors for MTD_STANDALONE with BDK_VERIFY_WRITE.
|
|
* Bug fix - PARTIAL_EDC flag to doc2read was negated prior to readOneSector.
|
|
*
|
|
* Rev 1.28 Jan 20 2002 20:57:00 oris
|
|
* physicalToPointer was called with wrong size argument.
|
|
*
|
|
* Rev 1.27 Jan 20 2002 20:28:06 oris
|
|
* Changed doc2000FreeWindow return type to remove warnings.
|
|
*
|
|
* Rev 1.26 Jan 17 2002 22:57:56 oris
|
|
* Replaced vol with *flash.
|
|
* Removed flPreInit memory access routines.
|
|
* Added new memory access routine implementation.
|
|
* Compilation problems fixed with VERIFY_ERASE
|
|
* Added support for flSuspendMode environment variable.
|
|
*
|
|
* Rev 1.25 Nov 21 2001 11:39:10 oris
|
|
* Changed FL_WITH_VERIFY_WRITE and FL_WITHOUT_VERIFY_WRITE to FL_ON and FL_OFF.
|
|
*
|
|
* Rev 1.24 Nov 20 2001 20:24:58 oris
|
|
* Removed warnings.
|
|
*
|
|
* Rev 1.23 Nov 16 2001 00:19:38 oris
|
|
* Compilation problem for FL_READ_ONLY.
|
|
*
|
|
* Rev 1.22 Nov 08 2001 10:44:30 oris
|
|
* Added run-time control over verify write mode.
|
|
* Added support for more up to 64K units - erase / readbbt
|
|
* Restricted BBT block search to BBT_MAX_DISTANCE and not the entire floor.
|
|
* Bug fix - Replacing a DiskOnChip Millennium with DiskOnChip 2000 failed identifying DiskOnChip2000 (gang).
|
|
*
|
|
* Rev 1.21 Sep 24 2001 18:23:08 oris
|
|
* Removed warnings.
|
|
*
|
|
* Rev 1.20 Sep 15 2001 23:44:42 oris
|
|
* Placed YIELD_CPU definition under ifdef to prevent redeclaration.
|
|
* Changed doc2erase to support up to 64K erase blocks.
|
|
* Added reconstruct flag to readBBT routine - stating whether to reconstruct BBT if it is not available.
|
|
* Added support for block multiplication in readBBT - several erase blocks in a single unit.
|
|
* Added support for 128MB flashes.
|
|
*
|
|
* Rev 1.19 Jul 29 2001 16:14:06 oris
|
|
* Support for number of units per floor not power of 2
|
|
*
|
|
* Rev 1.18 Jul 16 2001 22:47:58 oris
|
|
* Compilation error when using the FL_READ_ONLY compilation flag.
|
|
*
|
|
* Rev 1.17 Jul 15 2001 20:44:48 oris
|
|
* Removed warnings.
|
|
* Bug fix - virgin card dformat print was repeated for DiskOnChip with several floors.
|
|
*
|
|
* Rev 1.16 Jul 13 2001 00:59:42 oris
|
|
* Added docsys.h include.
|
|
* Improved VERIFY_WRITE support - added socket readBack buffer.
|
|
* Added PARTIAL_EDC read flag to the read routine.
|
|
* Revised checkErase routine to include extra area.
|
|
* Revised readBBT routine not to use MTD buffer.
|
|
* Added dformat debug print massages.
|
|
* Changed firstUsable block to 0 for DOC2000 tsop.
|
|
*
|
|
* Rev 1.15 Jun 17 2001 08:17:02 oris
|
|
* Added brackets to remove warnnings.
|
|
* Changed NO_READ_BBT_CODE to MTD_NO_READ_BBT_CODE.
|
|
*
|
|
* Rev 1.14 May 16 2001 21:16:32 oris
|
|
* Removed warnings.
|
|
* Changed code variable name to flCode (avoid name clashes).
|
|
*
|
|
* Rev 1.13 May 09 2001 00:31:28 oris
|
|
* Changed the DOC2000_TSOP_SUPPORT and READ_BBT_CODE compilation flags to NO_READ_BBT_CODE.
|
|
*
|
|
* Rev 1.12 May 07 2001 10:00:04 oris
|
|
* Compilation problems under MTD_STANDLAONE compilation flag.
|
|
*
|
|
* Rev 1.11 May 06 2001 22:41:22 oris
|
|
* Added the READ_BBT_CODE to allow reading the BBT even in the MTD_STANDALONE mode.
|
|
* Removed warnings.
|
|
*
|
|
* Rev 1.10 May 02 2001 06:44:38 oris
|
|
* Bug fix - readBBT routine.
|
|
* Removed the lastUsableBlock variable.
|
|
*
|
|
* Rev 1.9 Apr 30 2001 17:58:18 oris
|
|
* Added EDC check when reading the BBT.
|
|
*
|
|
* Rev 1.8 Apr 24 2001 17:06:22 oris
|
|
* Removed warrnings.
|
|
* Added lastUsableBlock initialization field in the FLFlash record.
|
|
*
|
|
* Rev 1.7 Apr 16 2001 13:04:20 oris
|
|
* Removed warrnings.
|
|
*
|
|
* Rev 1.6 Apr 12 2001 06:49:06 oris
|
|
* Added forceDownload routine
|
|
* Changed checkWinForDoc routine to be under ifndef MTD_STANDALONE.
|
|
*
|
|
* Rev 1.5 Apr 10 2001 16:39:16 oris
|
|
* Added multiple floor support for readbbt routine.
|
|
* Added call for docSocketInit which initializes the socket routines.
|
|
* Added validity check after flMap call in order to support pccard premoutn routine.
|
|
*
|
|
* Rev 1.4 Apr 09 2001 14:58:40 oris
|
|
* Removed debug buffer from readBBT routine.
|
|
* Bug fix in doc2000Identify if ASIC id was not mdoc 8 is was assumed to be doc2000.
|
|
* Added if_cfg field initialization in doc2000Identify.
|
|
*
|
|
* Rev 1.3 Apr 01 2001 07:38:58 oris
|
|
* Moved include diskonc.h from docsys.h.
|
|
* Removed waitForReadyWithYieldCPU for MTD_STANDALONE configuration.
|
|
* Removed NO_PPP compilation flag support.
|
|
* Left alligned all # directives.
|
|
* Moved pageSize,noOfFloors filed from the MTDs internal stucture to FLFlash record.
|
|
* Changed writeOneSector,doc2Write,readOneSector,doc2Read prototype.
|
|
* Added readbbt routine for alon.
|
|
* Removed pageAndTailSize from mtdVars record.
|
|
*
|
|
* Rev 1.2 Mar 01 2001 14:15:56 vadimk
|
|
* Add proper MDOC and DOC2300 support
|
|
*
|
|
* Rev 1.1 Feb 07 2001 18:28:38 oris
|
|
* Bug fix - restored antialise mechanizm to flDocWindowBaseAddress
|
|
* Added seperetaed floors compilation flag
|
|
* Changed mdoc \ alon distingishing algorithm
|
|
* Removed checkWinForDoc routine under the mtd_standalone comilation flag
|
|
* removed MAX_FLASH_DEVICES_MDOC define since alone DiskOnChips can support 16 chips just like doc2000
|
|
*
|
|
* Rev 1.0 Feb 02 2001 15:35:38 oris
|
|
* Initial revision.
|
|
*
|
|
*/
|
|
|
|
/************************************************************************/
|
|
/* */
|
|
/* FAT-FTL Lite Software Development Kit */
|
|
/* Copyright (C) M-Systems Ltd. 1995-2001 */
|
|
/* */
|
|
/************************************************************************/
|
|
|
|
#include "reedsol.h"
|
|
#include "diskonc.h"
|
|
|
|
extern NFDC21Vars docMtdVars[SOCKETS];
|
|
|
|
/* When the MTD is used as a standalone package some of the routine */
|
|
/* are replaced with the following macroes */
|
|
|
|
#ifdef MTD_STANDALONE
|
|
|
|
#define flReadBackBufferOf(a) &(globalReadBack[a][0])
|
|
|
|
#define flSocketNoOf(volume) 0 /* currently we support only a single device */
|
|
|
|
#define flMap(socket,address) addToFarPointer(socket->base,address & (socket->size - 1));
|
|
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
/* Yield CPU time in msecs */
|
|
#ifndef YIELD_CPU
|
|
#define YIELD_CPU 10
|
|
#endif /* YIELD_CPU */
|
|
|
|
/* maximum waiting time in msecs */
|
|
#define MAX_WAIT 30
|
|
|
|
#ifndef NO_EDC_MODE
|
|
|
|
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ.*/
|
|
/* EDC control */
|
|
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ.*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* e c c O N r e a d */
|
|
/* */
|
|
/* Enable ECC in read mode and reset it. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void eccONread (FLFlash * flash)
|
|
{
|
|
flWrite8bitReg(flash,NECCconfig,ECC_RESET);
|
|
flWrite8bitReg(flash,NECCconfig,ECC_EN);
|
|
}
|
|
#ifndef FL_READ_ONLY
|
|
/*----------------------------------------------------------------------*/
|
|
/* e c c O n w r i t e */
|
|
/* */
|
|
/* Enable ECC in write mode and reset it. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static void eccONwrite (FLFlash * flash)
|
|
{
|
|
flWrite8bitReg(flash,NECCconfig,ECC_RESET);
|
|
flWrite8bitReg(flash,NECCconfig,(ECC_RW | ECC_EN));
|
|
}
|
|
#endif /* FL_READ_ONLY */
|
|
#endif
|
|
/*----------------------------------------------------------------------*/
|
|
/* e c c O F F */
|
|
/* */
|
|
/* Disable ECC. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void eccOFF (FLFlash * flash)
|
|
{
|
|
flWrite8bitReg(flash,NECCconfig,ECC_RESERVED);
|
|
}
|
|
|
|
#ifndef NO_EDC_MODE
|
|
/*----------------------------------------------------------------------*/
|
|
/* e c c E r r o r */
|
|
/* */
|
|
/* Check for EDC error. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static FLBoolean eccError (FLFlash * flash)
|
|
{
|
|
register int i;
|
|
volatile Reg8bitType junk = 0;
|
|
Reg8bitType ret;
|
|
|
|
if( NFDC21thisVars->flags & MDOC_ASIC ) {
|
|
for(i=0;( i < 2 ); i++)
|
|
junk += flRead8bitReg(flash,NECCconfig);
|
|
ret = flRead8bitReg(flash,NECCconfig);
|
|
}
|
|
else {
|
|
for(i=0;( i < 2 ); i++)
|
|
junk += flRead8bitReg(flash,NECCstatus);
|
|
ret = flRead8bitReg(flash,NECCstatus);
|
|
}
|
|
ret &= ECC_ERROR;
|
|
return ((FLBoolean)ret);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ.*/
|
|
/* Miscellaneous routines */
|
|
/*ÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ.*/
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* m a k e C o m m a n d */
|
|
/* */
|
|
/* Set Page Pointer to Area A, B or C in page. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* cmd : receives command relevant to area */
|
|
/* addr : receives the address to the right area. */
|
|
/* modes : mode of operation (EXTRA ...) */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void makeCommand ( FLFlash * flash, PointerOp *cmd,
|
|
CardAddress *addr, int modes )
|
|
{
|
|
dword offset;
|
|
|
|
#ifdef BIG_PAGE_ENABLED
|
|
if ( !(flash->flags & BIG_PAGE) )
|
|
{ /* 2 Mb components */
|
|
if( modes & EXTRA )
|
|
{
|
|
offset = (*addr) & (SECTOR_SIZE - 1);
|
|
*cmd = AREA_C;
|
|
if( offset < EXTRA_LEN ) /* First half of extra area */
|
|
*addr += 0x100; /* ... assigned to 2nd page */
|
|
else /* Second half of extra area */
|
|
*addr -= EXTRA_LEN; /* ... assigned to 1st page */
|
|
}
|
|
else
|
|
*cmd = AREA_A;
|
|
}
|
|
else
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
{ /* 4 Mb components */
|
|
offset = (word)(*addr) & NFDC21thisVars->pageMask; /* offset within device Page */
|
|
*addr -= offset; /* align at device Page */
|
|
|
|
if(modes & EXTRA)
|
|
offset += SECTOR_SIZE;
|
|
|
|
if( offset < NFDC21thisVars->pageAreaSize ) /* starting in area A */
|
|
*cmd = AREA_A;
|
|
else if( offset < flash->pageSize ) /* starting in area B */
|
|
*cmd = AREA_B;
|
|
else /* got into area C */
|
|
*cmd = AREA_C;
|
|
|
|
offset &= (NFDC21thisVars->pageAreaSize - 1); /* offset within area of device Page */
|
|
*addr += offset;
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* b u s y */
|
|
/* */
|
|
/* Check if the selected flash device is ready. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* Zero is ready. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
static FLBoolean busy (FLFlash * flash)
|
|
{
|
|
register int i;
|
|
Reg8bitType stat;
|
|
volatile Reg8bitType junk = 0;
|
|
Reg8bitType ret;
|
|
/* before polling for BUSY status perform 4 read operations from
|
|
CDSN_control_reg */
|
|
|
|
for(i=0;( i < 4 ); i++ )
|
|
junk += flRead8bitReg(flash,NNOPreg);
|
|
|
|
/* read BUSY status */
|
|
|
|
stat = flRead8bitReg(flash,Nsignals);
|
|
|
|
/* after BUSY status is obtained perform 2 read operations from
|
|
CDSN_control_reg */
|
|
|
|
for(i=0;( i < 2 ); i++ )
|
|
junk += flRead8bitReg(flash,NNOPreg);
|
|
ret = (!(stat & (Reg8bitType)RB));
|
|
return ((FLBoolean)ret);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* w a i t F o r R e a d y */
|
|
/* */
|
|
/* Wait until flash device is ready or timeout. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* Returns: */
|
|
/* FALSE if timeout error, otherwise TRUE. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLBoolean waitForReady (FLFlash * flash)
|
|
{
|
|
int i;
|
|
for(i=0;( i < BUSY_DELAY ); i++)
|
|
{
|
|
if( busy(flash) )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
return( TRUE ); /* ready at last.. */
|
|
}
|
|
|
|
DEBUG_PRINT(("Debug: timeout error in NFDC 2148.\r\n"));
|
|
return( FALSE );
|
|
}
|
|
|
|
#ifndef MTD_STANDALONE
|
|
#ifndef DO_NOT_YIELD_CPU
|
|
/*----------------------------------------------------------------------*/
|
|
/* w a i t F o r R e a d y W i t h Y i e l d C P U */
|
|
/* */
|
|
/* Wait until flash device is ready or timeout. */
|
|
/* The function yields CPU while it waits till flash is ready */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* Returns: */
|
|
/* FALSE if timeout error, otherwise TRUE. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLBoolean waitForReadyWithYieldCPU (FLFlash * flash,
|
|
int millisecToSleep)
|
|
{
|
|
int i;
|
|
|
|
for (i=0; i < (millisecToSleep / YIELD_CPU); i++) {
|
|
#ifndef NT5PORT
|
|
flsleep(YIELD_CPU);
|
|
#endif /*NT5PORT*/
|
|
if( busy(flash) )
|
|
continue;
|
|
return( TRUE ); /* ready at last.. */
|
|
}
|
|
|
|
return( FALSE );
|
|
}
|
|
#endif /* DO_NOT_YIELD_CPU */
|
|
#endif /* MTD_STANDALONE */
|
|
/*----------------------------------------------------------------------*/
|
|
/* w r i t e S i g n a l s */
|
|
/* */
|
|
/* Write to CDSN_control_reg. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* val : Value to write to register */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void writeSignals (FLFlash * flash, Reg8bitType val)
|
|
{
|
|
register int i;
|
|
volatile Reg8bitType junk = 0;
|
|
|
|
flWrite8bitReg(flash,Nsignals,val);
|
|
|
|
/* after writing to CDSN_control perform 2 reads from there */
|
|
|
|
for(i = 0;( i < 2 ); i++ )
|
|
junk += flRead8bitReg(flash,NNOPreg);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* s e l e c t C h i p */
|
|
/* */
|
|
/* Write to deviceSelector register. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* dev : Chip to select. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void selectChip (FLFlash * flash, Reg8bitType dev)
|
|
{
|
|
flWrite8bitReg(flash,NdeviceSelector,dev);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c h k A S I C m o d e */
|
|
/* */
|
|
/* Check mode of ASIC and if RESET set to NORMAL. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void chkASICmode (FLFlash * flash)
|
|
{
|
|
if( flRead8bitReg(flash,NDOCstatus) == ASIC_CHECK_RESET ) {
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
|
|
#ifndef SEPARATED_CASCADED
|
|
NFDC21thisVars->currentFloor = 0;
|
|
#endif /* SEPARATED_CASCADED */
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* s e t A S I C m o d e */
|
|
/* */
|
|
/* Set mode of ASIC. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* mode : mode to set. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void setASICmode (FLFlash * flash, Reg8bitType mode)
|
|
{
|
|
NDOC2window p = (NDOC2window)flMap(flash->socket, 0);
|
|
if (p!=NULL)
|
|
{
|
|
flWrite8bitReg(flash,NDOCcontrol,mode);
|
|
flWrite8bitReg(flash,NDOCcontrol,mode);
|
|
#ifdef SEPARATED_CASCADED
|
|
flWrite8bitReg(flash,NASICselect,NFDC21thisVars->currentFloor);
|
|
#endif /* SEPARATED_CASCADED */
|
|
}
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c h e c k T o g g l e */
|
|
/* */
|
|
/* Check DiskOnChip toggle bit. Verify this is not simple RAM. */
|
|
/* */
|
|
/* Note : This routine assumes that the memory access routines have */
|
|
/* already been initialized by the called routine. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* FLFlash : Pointer to flash structure. */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus: TRUE if the bit toggles verifing that this is indeed */
|
|
/* a DiskOnChip device, otherwise FALSE. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLBoolean checkToggle(FLFlash * flash)
|
|
{
|
|
volatile Reg8bitType toggle1;
|
|
volatile Reg8bitType toggle2;
|
|
|
|
if(flRead8bitReg(flash,NchipId) == CHIP_ID_MDOC ) {
|
|
toggle1 = flRead8bitReg(flash,NECCconfig);
|
|
toggle2 = toggle1 ^ flRead8bitReg(flash,NECCconfig);
|
|
}
|
|
else {
|
|
toggle1 = flRead8bitReg(flash,NECCstatus);
|
|
toggle2 = toggle1 ^ flRead8bitReg(flash,NECCstatus);
|
|
}
|
|
if( (toggle2 & TOGGLE) == 0 )
|
|
return FALSE;
|
|
return TRUE;
|
|
}
|
|
|
|
#ifndef MTD_STANDALONE
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c h e c k W i n F o r D O C */
|
|
/* */
|
|
/* Check for a DiskOnChip on a specific socket and memory windows */
|
|
/* */
|
|
/* Parameters: */
|
|
/* socketNo : Number of socket to check. */
|
|
/* memWinPtr : Pointer to DiskOnChip memory window. */
|
|
/* */
|
|
/* Returns: TRUE if this is an MDOCP, otherwise FALSE. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
FLBoolean checkWinForDOC(unsigned socketNo, NDOC2window memWinPtr)
|
|
{
|
|
FLFlash * flash = flFlashOf(socketNo);
|
|
|
|
/* Initialize socket memory access routine */
|
|
flash->win = memWinPtr;
|
|
|
|
#ifndef FL_NO_USE_FUNC
|
|
if(setBusTypeOfFlash(flash, flBusConfig[socketNo] |
|
|
FL_8BIT_DOC_ACCESS | FL_8BIT_FLASH_ACCESS))
|
|
return FALSE;
|
|
#endif /* FL_NO_USE_FUNC */
|
|
|
|
/* set ASIC to RESET MODE */
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_RESET_MODE);
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_RESET_MODE);
|
|
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
|
|
|
|
if( (flRead8bitReg(flash,NchipId) != CHIP_ID_DOC ) &&
|
|
(flRead8bitReg(flash,NchipId) != CHIP_ID_MDOC))
|
|
return FALSE;
|
|
|
|
return checkToggle(flash);
|
|
}
|
|
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
#ifndef NO_IPL_CODE
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f o r c e D o w n l o a d */
|
|
/* */
|
|
/* Force download of IPL code. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus forceDownLoad(FLFlash * flash)
|
|
{
|
|
flWrite8bitReg(flash, NfoudaryTest, 0x36);
|
|
flWrite8bitReg(flash, NfoudaryTest, 0x63);
|
|
flDelayMsecs(1000);
|
|
return flOK;
|
|
}
|
|
|
|
#ifndef FL_READ_ONLY
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* w r i t e I P L */
|
|
/* */
|
|
/* Write new IPL. */
|
|
/* */
|
|
/* Note : Can not start write operation from middle of IPL , unless */
|
|
/* previous operation started from offset 0. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive. */
|
|
/* buffer : buffer to write from. */
|
|
/* length : number of bytes to write - must use full 512 bytes. */
|
|
/* offset : sector number to start from. */
|
|
/* flags : Modes to write IPL : */
|
|
/* FL_IPL_MODE_NORMAL - Normal mode (none Strong Arm). */
|
|
/* FL_IPL_DOWNLOAD - Download new IPL when done */
|
|
/* FL_IPL_MODE_SA - Strong Arm IPL mode */
|
|
/* FL_IPL_MODE_XSCALE - X-Scale IPL mode */
|
|
/* */
|
|
/* Returns: */
|
|
/* flOK on success, none zero otherwise. */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus writeIPL(FLFlash * flash, const void FAR1 * buffer,
|
|
word length,byte offset, unsigned flags)
|
|
{
|
|
dword curWrite;
|
|
dword addrOffset = (dword)offset << SECTOR_SIZE_BITS;
|
|
|
|
if((flags & (FL_IPL_MODE_SA | FL_IPL_MODE_XSCALE)) != 0)
|
|
{
|
|
DFORMAT_PRINT(("ERROR - DiskOnChip does not support this IPL mode.\r\n"));
|
|
return flFeatureNotSupported;
|
|
}
|
|
|
|
if ((flash->erase != NULL)||(flash->write != NULL))
|
|
{
|
|
if ((length + addrOffset > 1024) || /* required length to long */
|
|
(offset>1) ) /* only single sector or none */
|
|
{
|
|
DFORMAT_PRINT(("ERROR - IPL size or offset are too big for this DiskOnChip.\r\n"));
|
|
return flBadLength;
|
|
}
|
|
if((length % SECTOR_SIZE) != 0)
|
|
{
|
|
DFORMAT_PRINT(("ERROR - IPL size must be a multiplication of 512 bytes.\r\n"));
|
|
return flBadLength;
|
|
}
|
|
|
|
if(offset==0) /* Erase only if offset is 0 */
|
|
checkStatus(flash->erase(flash,0,1));
|
|
|
|
for (addrOffset = addrOffset << 1 ; length > 0 ;
|
|
addrOffset += (SECTOR_SIZE<<1))
|
|
{
|
|
curWrite = TFFSMIN(length,SECTOR_SIZE);
|
|
checkStatus(flash->write(flash,addrOffset,buffer,curWrite,PARTIAL_EDC));
|
|
checkStatus(flash->write(flash,addrOffset+SECTOR_SIZE,buffer,curWrite,PARTIAL_EDC));
|
|
buffer = (byte FAR1 *)BYTE_ADD_FAR(buffer,SECTOR_SIZE);
|
|
length -= (word)curWrite;
|
|
}
|
|
if((flags & FL_IPL_DOWNLOAD) == 0)
|
|
return flOK;
|
|
|
|
if(flash->download != NULL)
|
|
return flash->download(flash);
|
|
DFORMAT_PRINT(("ERROR - IPL was not downloaded since MTD does not support the feature\r\n"));
|
|
}
|
|
DFORMAT_PRINT(("ERROR - IPL was not written since MTD is in read only mode\r\n"));
|
|
return flFeatureNotSupported;
|
|
}
|
|
|
|
#endif /* FL_READ_ONLY */
|
|
#endif /* NO_IPL_CODE */
|
|
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l D o c W i n d o w B a s e A d d r e s s */
|
|
/* */
|
|
/* Return the host base address of the window. */
|
|
/* If the window base address is programmable, this routine selects */
|
|
/* where the base address will be programmed to. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* socketNo FLite socket No (0..SOCKETS-1) */
|
|
/* lowAddress, */
|
|
/* highAddress : host memory range to search for DiskOnChip 2000 */
|
|
/* memory window */
|
|
/* */
|
|
/* Returns: */
|
|
/* Host physical address of window divided by 4 KB */
|
|
/* nextAddress : The address of the next DiskOnChip. */
|
|
/*----------------------------------------------------------------------*/
|
|
static unsigned flDocWindowBaseAddress(byte socketNo, dword lowAddress,
|
|
dword highAddress, dword *nextAddress)
|
|
{
|
|
#ifndef NT5PORT
|
|
FLBoolean stopSearch = FALSE;
|
|
volatile byte deviceSearch;
|
|
dword winSize;
|
|
FLFlash *flash;
|
|
|
|
|
|
#ifdef SEPARATED_CASCADED
|
|
/* This flag is used to seperate the cascaded devices into SEPARATED volumes */
|
|
/* Only the first floor responds therfore once it is found all the others are */
|
|
/* reported without searching */
|
|
|
|
static byte noOfFloors = 0; /* floor counter of the cascaded device */
|
|
static socketOfFirstFloor = 0; /* Number of sockets already found */
|
|
static dword savedNextAddress; /* Next search address (skipping aliases */
|
|
|
|
switch ( noOfFloors )
|
|
{
|
|
case 0 : /* First access to a device */
|
|
socketOfFirstFloor = noOfSockets;
|
|
break;
|
|
|
|
case 1 : /* Last floor of a cascaded device */
|
|
*nextAddress = savedNextAddress;
|
|
|
|
default : /* One of a cascaded device floors */
|
|
docMtdVars[noOfSockets].currentFloor = noOfSockets - socketOfFirstFloor;
|
|
noOfFloors--;
|
|
return((unsigned)(lowAddress >> 12));
|
|
}
|
|
#endif /* SEPARATED_CASCADED */
|
|
|
|
/* if memory range to search for DiskOnChip 2000 window is not specified */
|
|
/* assume the standard x86 PC architecture where DiskOnChip 2000 appears */
|
|
/* in a memory range reserved for BIOS expansions */
|
|
if (lowAddress == 0x0L) {
|
|
lowAddress = START_ADR;
|
|
highAddress = STOP_ADR;
|
|
}
|
|
|
|
flash = flFlashOf(socketNo);
|
|
|
|
#ifndef FL_NO_USE_FUNC
|
|
/* Initialize socket memory access routine */
|
|
if(setBusTypeOfFlash(flash, flBusConfig[socketNo] |
|
|
FL_8BIT_DOC_ACCESS | FL_8BIT_FLASH_ACCESS))
|
|
return ( 0 );
|
|
#endif /* FL_NO_USE_FUNC */
|
|
|
|
winSize = DOC_WIN;
|
|
|
|
/* set all possible controllers to RESET MODE */
|
|
|
|
for(*nextAddress = lowAddress ; *nextAddress <= highAddress ;
|
|
*nextAddress += winSize)
|
|
{
|
|
flash->win = (NDOC2window )physicalToPointer(*nextAddress,winSize,socketNo);
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_RESET_MODE);
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_RESET_MODE);
|
|
}
|
|
|
|
/* set controller (ASIC) to NORMAL MODE and try and detect it */
|
|
*nextAddress = lowAddress; /* current address initialization */
|
|
for( ; *nextAddress <= highAddress; *nextAddress += winSize)
|
|
{
|
|
flash->win = (NDOC2window)physicalToPointer(*nextAddress,winSize,socketNo);
|
|
/* set controller (ASIC) to NORMAL MODE */
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
|
|
flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
|
|
|
|
if( (flRead8bitReg(flash,NchipId) != CHIP_ID_DOC &&
|
|
flRead8bitReg(flash,NchipId) != CHIP_ID_MDOC))
|
|
{
|
|
if( stopSearch == TRUE ) /* DiskOnChip was found */
|
|
break;
|
|
else continue;
|
|
}
|
|
if( stopSearch == FALSE ) {
|
|
/* detect card - identify bit toggles on consequitive reads */
|
|
if(checkToggle(flash) == FALSE)
|
|
continue;
|
|
/* DiskOnChip found */
|
|
if( flRead8bitReg(flash,NchipId)) {
|
|
flWrite8bitReg(flash,NaliasResolution,ALIAS_RESOLUTION);
|
|
}
|
|
else {
|
|
flWrite8bitReg(flash,NdeviceSelector,ALIAS_RESOLUTION);
|
|
}
|
|
stopSearch = TRUE;
|
|
lowAddress = *nextAddress; /* save DiskOnChip address */
|
|
}
|
|
else { /* DiskOnChip found, continue to skip aliases */
|
|
if( (flRead8bitReg(flash,NchipId) != CHIP_ID_DOC) &&
|
|
(flRead8bitReg(flash,NchipId) != CHIP_ID_MDOC) )
|
|
break;
|
|
/* detect card - identify bit toggles on consequitive reads */
|
|
if(checkToggle(flash) == FALSE)
|
|
break;
|
|
/* check for Alias */
|
|
deviceSearch = (byte)((flRead8bitReg(flash,NchipId) == CHIP_ID_MDOC) ?
|
|
flRead8bitReg(flash,NaliasResolution) :
|
|
flRead8bitReg(flash,NdeviceSelector));
|
|
if( deviceSearch != ALIAS_RESOLUTION )
|
|
break;
|
|
}
|
|
}
|
|
if( stopSearch == FALSE ) /* DiskOnChip 2000 memory window not found */
|
|
return( 0 );
|
|
|
|
#ifdef SEPARATED_CASCADED
|
|
/* count the number of floors cascaded to this address */
|
|
|
|
flash->win = (NDOC2window)physicalToPointer(lowAddress,winSize,socketNo);
|
|
for ( noOfFloors=1; noOfFloors < MAX_FLASH_DEVICES_DOC ;noOfFloors++)
|
|
{
|
|
flWrite8bitReg(flash,NASICselect,noOfFloors);
|
|
if(checkToggle(flash) == FALSE)
|
|
break;
|
|
}
|
|
/* If there are more then 1 floor on this address save the next device address and report
|
|
that the next device is actualy on the same address as the current */
|
|
|
|
if ( noOfFloors > 1)
|
|
{
|
|
flWrite8bitReg(flash,NASICselect,0);
|
|
savedNextAddress = *nextAddress;
|
|
*nextAddress = lowAddress;
|
|
}
|
|
noOfFloors--;
|
|
#endif /* SEPARATED_CASCADED */
|
|
return((unsigned)(lowAddress >> 12));
|
|
#else /*NT5PORT*/
|
|
DEBUG_PRINT(("Tffsport mdocplus.c :flDocWindowBaseAddress(): Before returning baseAddress()\n"));
|
|
return (unsigned)(((ULONG_PTR)pdriveInfo[socketNo].winBase)>> 12);
|
|
#endif /*NT5PORT*/
|
|
|
|
}
|
|
/*----------------------------------------------------------------------*/
|
|
/* s e t A d d r e s s */
|
|
/* */
|
|
/* Latch address to selected flash device. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : address to set. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void setAddress (FLFlash * flash, CardAddress address)
|
|
{
|
|
address &= (flash->chipSize * flash->interleaving - 1); /* address within flash device */
|
|
|
|
#ifdef BIG_PAGE_ENABLED
|
|
if ( flash->flags & BIG_PAGE )
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
{
|
|
/*
|
|
bits 0..7 stays as are
|
|
bit 8 is thrown away from address
|
|
bits 31..9 -> bits 30..8
|
|
*/
|
|
address = ((address >> 9) << 8) | ((byte)address);
|
|
}
|
|
|
|
writeSignals (flash, FLASH_IO | ALE | CE);
|
|
|
|
#ifdef SLOW_IO_FLAG
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)address);
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)address);
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)(address >> 8));
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 8));
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)(address >> 16));
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 16));
|
|
if( flash->flags & BIG_ADDR ) {
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)(address >> 24));
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 24));
|
|
}
|
|
#else
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)address);
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 8));
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 16));
|
|
if( flash->flags & BIG_ADDR )
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 24));
|
|
#endif
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
|
|
|
|
writeSignals (flash, ECC_IO | FLASH_IO | CE);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c o m m a n d */
|
|
/* */
|
|
/* Latch command byte to selected flash device. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* code : Command to set. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void command(FLFlash * flash, Reg8bitType flCode)
|
|
{
|
|
writeSignals (flash, FLASH_IO | CLE | CE);
|
|
|
|
#ifdef SLOW_IO_FLAG
|
|
flWrite8bitReg(flash,NslowIO,flCode);
|
|
#endif
|
|
|
|
flWrite8bitReg(flash,NFDC21thisIO,flCode);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,flCode);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* s e l e c t F l o o r */
|
|
/* */
|
|
/* Select floor (0 .. totalFloors-1). */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : Select floor for this address. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
#ifndef SEPARATED_CASCADED
|
|
|
|
static void selectFloor (FLFlash * flash, CardAddress *address)
|
|
{
|
|
if( flash->noOfFloors > 1 )
|
|
{
|
|
byte floorToUse = (byte)((*address) / NFDC21thisVars->floorSize);
|
|
|
|
NFDC21thisVars->currentFloor = floorToUse;
|
|
flWrite8bitReg(flash,NASICselect,floorToUse);
|
|
*address -= (floorToUse * NFDC21thisVars->floorSize);
|
|
}
|
|
}
|
|
|
|
#endif /* SEPARATED_CASCADED */
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* m a p W i n */
|
|
/* */
|
|
/* Map window to selected flash device. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : Map window to this address. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void mapWin (FLFlash * flash, CardAddress *address)
|
|
{
|
|
/* NOTE: normally both ways to obtain DOC 2000 window segment should
|
|
return the same value. */
|
|
NFDC21thisWin = (NDOC2window)flMap(flash->socket, 0);
|
|
#ifndef SEPARATED_CASCADED
|
|
selectFloor (flash, address);
|
|
#else
|
|
flWrite8bitReg(flash,NASICselect,NFDC21thisVars->currentFloor);
|
|
#endif /* SEPARATED_CASCADED */
|
|
/* select chip within floor */
|
|
selectChip (flash, (Reg8bitType)((*address) / (flash->chipSize * flash->interleaving))) ;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* r d B u f */
|
|
/* */
|
|
/* Auxiliary routine for Read(), read from page. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* buf : Buffer to read into. */
|
|
/* howmany : Number of bytes to read. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void rdBuf (FLFlash * flash, byte FAR1 *buf, word howmany)
|
|
{
|
|
volatile Reg8bitType junk = 0;
|
|
register word i;
|
|
#ifdef SLOW_IO_FLAG
|
|
/* slow flash requires first read to be done from CDSN_Slow_IO
|
|
and only second one from CDSN_IO - this extends read access */
|
|
|
|
for( i = 0 ;( i < howmany ); i++ ) {
|
|
junk = flRead8bitReg(flash,NslowIO);
|
|
buf[i] = (byte)flRead8bitReg(flash,NFDC21thisIO+(i & 0x01));
|
|
}
|
|
#else
|
|
if( NFDC21thisVars->flags & MDOC_ASIC ) {
|
|
junk += flRead8bitReg(flash,NreadPipeInit);
|
|
howmany--;
|
|
i = TFFSMIN( howmany, MDOC_ALIAS_RANGE );
|
|
docread(flash->win,NFDC21thisIO,buf,i);
|
|
}
|
|
else i = 0;
|
|
if( howmany > i )
|
|
docread(flash->win,NFDC21thisIO,buf+i,(word)(howmany-i));
|
|
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
buf[howmany] = flRead8bitReg(flash,NreadLastData);
|
|
#endif
|
|
}
|
|
#ifndef FL_READ_ONLY
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* w r B u f */
|
|
/* */
|
|
/* Auxiliary routine for Write(), write to page from buffer. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* buf : Buffer to write from. */
|
|
/* howmany : Number of bytes to write. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void wrBuf (FLFlash * flash, const byte FAR1 *buf, word howmany )
|
|
{
|
|
#ifdef SLOW_IO_FLAG
|
|
register int i;
|
|
/* slow flash requires first write go to CDSN_Slow_IO and
|
|
only second one to CDSN_IO - this extends write access */
|
|
|
|
for ( i = 0 ;( i < howmany ); i++ ) {
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)buf[i]);
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)buf[i]);
|
|
}
|
|
#else
|
|
docwrite(flash->win,NFDC21thisIO,(byte FAR1 *)buf,howmany);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
|
|
#endif
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* w r S e t */
|
|
/* */
|
|
/* Auxiliary routine for Write(), set page data. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* ch : Set page to this byte */
|
|
/* howmany : Number of bytes to set. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void wrSet (FLFlash * flash, const Reg8bitType ch, word howmany )
|
|
{
|
|
#ifdef SLOW_IO_FLAG
|
|
register int i;
|
|
/* slow flash requires first write go to CDSN_Slow_IO and
|
|
only second one to CDSN_IO - this extends write access */
|
|
|
|
for (i = 0 ;( i < howmany ); i++ ) {
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)ch);
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)ch);
|
|
}
|
|
#else
|
|
docset(flash->win,NFDC21thisIO,howmany,ch);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
|
|
#endif
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* r e a d S t a t u s */
|
|
/* */
|
|
/* Read status of selected flash device. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* Chip status. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static Reg8bitType readStatus (FLFlash * flash)
|
|
{
|
|
Reg8bitType chipStatus;
|
|
volatile Reg8bitType junk = 0;
|
|
|
|
flWrite8bitReg(flash,NFDC21thisIO,READ_STATUS);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,READ_STATUS);
|
|
writeSignals (flash, FLASH_IO | CE | WP);
|
|
|
|
if( NFDC21thisVars->flags & MDOC_ASIC ) {
|
|
junk += flRead8bitReg(flash,NreadPipeInit); /* load first data into pipeline */
|
|
chipStatus = flRead8bitReg(flash,NreadLastData); /* read flash status */
|
|
}
|
|
else {
|
|
junk += flRead8bitReg(flash,NslowIO);
|
|
chipStatus = flRead8bitReg(flash,NFDC21thisIO);
|
|
}
|
|
return chipStatus;
|
|
}
|
|
#endif /* FL_READ_ONLY */
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* r e a d C o m m a n d */
|
|
/* */
|
|
/* Issue read command. */
|
|
/* */
|
|
/* Parametes: */
|
|
/* flash : Pointer identifying drive */
|
|
/* cmd : Command to issue (according to area). */
|
|
/* addr : address to read from. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void readCommand (FLFlash * flash, PointerOp cmd, CardAddress addr)
|
|
{
|
|
command (flash, (Reg8bitType)cmd); /* move flash pointer to respective area of the page */
|
|
setAddress (flash, addr);
|
|
waitForReady(flash);
|
|
}
|
|
#ifndef FL_READ_ONLY
|
|
/*----------------------------------------------------------------------*/
|
|
/* w r i t e C o m m a n d */
|
|
/* */
|
|
/* Issue write command. */
|
|
/* */
|
|
/* Parametes: */
|
|
/* flash : Pointer identifying drive */
|
|
/* cmd : Command to issue (according to area). */
|
|
/* addr : address to write to. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void writeCommand (FLFlash * flash, PointerOp cmd, CardAddress addr)
|
|
{
|
|
if( flash->flags & FULL_PAGE ) {
|
|
command (flash, RESET_FLASH);
|
|
waitForReady(flash);
|
|
if( cmd != AREA_A ) {
|
|
#ifdef SLOW_IO_FLAG
|
|
flWrite8bitReg(flash,NslowIO,(byte)cmd);
|
|
#endif
|
|
flWrite8bitReg(flash,NFDC21thisIO,(byte)cmd);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,(byte)cmd);
|
|
}
|
|
}
|
|
else
|
|
command (flash, (Reg8bitType)cmd); /* move flash pointer to respective area of the page */
|
|
|
|
#ifdef SLOW_IO_FLAG
|
|
flWrite8bitReg(flash,NslowIO,SERIAL_DATA_INPUT);
|
|
#endif
|
|
|
|
flWrite8bitReg(flash,NFDC21thisIO,SERIAL_DATA_INPUT);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,SERIAL_DATA_INPUT);
|
|
|
|
setAddress (flash, addr);
|
|
|
|
waitForReady(flash);
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* w r i t e E x e c u t e */
|
|
/* */
|
|
/* Execute write. */
|
|
/* */
|
|
/* Parametes: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failed. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus writeExecute (FLFlash * flash)
|
|
{
|
|
command (flash, SETUP_WRITE); /* execute page program */
|
|
waitForReady(flash);
|
|
|
|
if( readStatus(flash) & (byte)(FAIL) ) {
|
|
DEBUG_PRINT(("Debug: NFDC 2148 write failed.\r\n"));
|
|
return( flWriteFault );
|
|
}
|
|
|
|
return( flOK );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* w r i t e O n e S e c t o r */
|
|
/* */
|
|
/* Write data in one 512-byte block to flash. */
|
|
/* Assuming that EDC mode never requested on partial block writes. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : Address of sector to write to. */
|
|
/* buffer : buffer to write from. */
|
|
/* length : number of bytes to write (up to sector size). */
|
|
/* modes : OVERWRITE, EDC flags etc. */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failed. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus writeOneSector(FLFlash * flash,
|
|
CardAddress address,
|
|
const void FAR1 *buffer,
|
|
word length,
|
|
word modes)
|
|
{
|
|
byte FAR1 *pbuffer = (byte FAR1 *)buffer; /* to write from */
|
|
FLStatus status;
|
|
#ifndef NO_EDC_MODE
|
|
byte syndrom[SYNDROM_BYTES];
|
|
static byte anandMark[2] = { 0x55, 0x55 };
|
|
#endif
|
|
PointerOp cmd = AREA_A ;
|
|
word prePad;
|
|
#ifdef BIG_PAGE_ENABLED
|
|
word toFirstPage = 0, toSecondPage = 0;
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
|
|
#ifndef MTD_STANDALONE
|
|
if (flWriteProtected(flash->socket))
|
|
return( flWriteProtect );
|
|
#endif
|
|
|
|
mapWin(flash, &address); /* select flash device */
|
|
|
|
/* move flash pointer to areas A,B or C of page */
|
|
makeCommand(flash, &cmd, &address, modes);
|
|
|
|
if( (flash->flags & FULL_PAGE) && (cmd == AREA_B) ) {
|
|
prePad = (word)(2 + ((word) address & NFDC21thisVars->pageMask));
|
|
writeCommand(flash, AREA_A, address + NFDC21thisVars->pageAreaSize - prePad);
|
|
wrSet(flash, 0xFF, prePad);
|
|
}
|
|
else
|
|
writeCommand(flash, cmd, address);
|
|
|
|
#ifndef NO_EDC_MODE
|
|
if( modes & EDC )
|
|
eccONwrite(flash); /* ECC ON for write */
|
|
#endif
|
|
|
|
#ifdef BIG_PAGE_ENABLED
|
|
if( !(flash->flags & BIG_PAGE) ) /* 2M on INLV=1 */
|
|
{
|
|
/* write up to two pages separately */
|
|
if( modes & EXTRA )
|
|
toFirstPage = EXTRA_LEN - ((word)address & (EXTRA_LEN-1));
|
|
else
|
|
toFirstPage = CHIP_PAGE_SIZE - ((word)address & (CHIP_PAGE_SIZE-1));
|
|
|
|
if(toFirstPage > length)
|
|
toFirstPage = length;
|
|
toSecondPage = length - toFirstPage;
|
|
|
|
wrBuf(flash, pbuffer, toFirstPage); /* starting page .. */
|
|
|
|
if ( toSecondPage > 0 )
|
|
{
|
|
if (toFirstPage > 0) /* started on 1st page */
|
|
checkStatus( writeExecute(flash) ); /* done with 1st page */
|
|
if( modes & EXTRA )
|
|
address -= (CHIP_PAGE_SIZE + ((word)address & (EXTRA_LEN-1)));
|
|
writeCommand(flash, cmd, address + toFirstPage);
|
|
wrBuf (flash, pbuffer + toFirstPage, toSecondPage); /* user data */
|
|
}
|
|
}
|
|
else /* 4M or 8M */
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
|
|
wrBuf (flash, pbuffer, length); /* user data */
|
|
|
|
#ifndef NO_EDC_MODE
|
|
if(modes & EDC)
|
|
{
|
|
register int i;
|
|
|
|
writeSignals (flash, ECC_IO | CE ); /* disable flash access */
|
|
/* 3 dummy zero-writes to clock the data through pipeline */
|
|
if( NFDC21thisVars->flags & MDOC_ASIC ) {
|
|
for( i = 0;( i < 3 ); i++ ) {
|
|
flWrite8bitReg(flash,NNOPreg,(Reg8bitType)0);
|
|
}
|
|
}
|
|
else {
|
|
wrSet (flash, 0x00, 3 );
|
|
}
|
|
writeSignals (flash, ECC_IO | FLASH_IO | CE ); /* enable flash access */
|
|
|
|
docread(flash->win,Nsyndrom,syndrom,SYNDROM_BYTES);
|
|
#ifdef D2TST
|
|
tffscpy(saveSyndromForDumping,syndrom,SYNDROM_BYTES);
|
|
#endif
|
|
eccOFF(flash); /* ECC OFF */
|
|
|
|
wrBuf (flash, (const byte FAR1 *)syndrom, SYNDROM_BYTES);
|
|
|
|
wrBuf (flash, (const byte FAR1 *)anandMark, sizeof(anandMark) );
|
|
}
|
|
#endif /* NO_EDC_MODE */
|
|
|
|
status = writeExecute(flash); /* abort if write failure */
|
|
if(status != flOK)
|
|
return status;
|
|
|
|
writeSignals(flash, FLASH_IO | WP);
|
|
|
|
#ifdef VERIFY_WRITE
|
|
|
|
#ifndef MTD_STANDALONE
|
|
if (flash->socket->verifyWrite==FL_OFF)
|
|
return status;
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
/* Read back after write and verify */
|
|
|
|
if( modes & OVERWRITE )
|
|
pbuffer = (byte FAR1 *) buffer; /* back to original data */
|
|
|
|
readCommand (flash, cmd, address); /* move flash pointer to areas A,B or C of page */
|
|
|
|
#ifdef BIG_PAGE_ENABLED
|
|
|
|
if( !(flash->flags & BIG_PAGE) )
|
|
{
|
|
rdBuf (flash, NFDC21thisVars->readBackBuffer, toFirstPage);
|
|
|
|
if(tffscmp (pbuffer, NFDC21thisVars->readBackBuffer, toFirstPage) ) {
|
|
DEBUG_PRINT(("Debug: NFDC 2148 write failed in verification.\r\n"));
|
|
return( flWriteFault );
|
|
}
|
|
|
|
if ( toSecondPage > 0 )
|
|
{
|
|
readCommand (flash, AREA_A, address + toFirstPage);
|
|
|
|
rdBuf (flash, NFDC21thisVars->readBackBuffer + toFirstPage, toSecondPage);
|
|
|
|
if( tffscmp (pbuffer + toFirstPage, NFDC21thisVars->readBackBuffer + toFirstPage, toSecondPage)) {
|
|
DEBUG_PRINT(("Debug: NFDC 2148 write failed in verification.\r\n"));
|
|
return( flWriteFault );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
{
|
|
rdBuf (flash, NFDC21thisVars->readBackBuffer, length);
|
|
|
|
if( tffscmp (pbuffer, NFDC21thisVars->readBackBuffer, length) ) {
|
|
DEBUG_PRINT(("Debug: NFDC 2148 write failed in verification.\r\n"));
|
|
return( flWriteFault );
|
|
}
|
|
}
|
|
/* then ECC and special ANAND mark */
|
|
|
|
#ifndef NO_EDC_MODE
|
|
if( modes & EDC )
|
|
{
|
|
rdBuf (flash, NFDC21thisVars->readBackBuffer, SYNDROM_BYTES);
|
|
if( tffscmp (syndrom, NFDC21thisVars->readBackBuffer, SYNDROM_BYTES) )
|
|
return( flWriteFault );
|
|
|
|
rdBuf (flash, NFDC21thisVars->readBackBuffer, sizeof(anandMark));
|
|
if( tffscmp (anandMark, NFDC21thisVars->readBackBuffer, sizeof(anandMark)) )
|
|
return( flWriteFault );
|
|
}
|
|
#endif /* NO_EDC_MODE */
|
|
|
|
writeSignals (flash, FLASH_IO | WP);
|
|
waitForReady(flash); /* Serial Read Cycle Entry */
|
|
#endif /* VERIFY_WRITE */
|
|
|
|
return( flOK );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* d o c 2 W r i t e */
|
|
/* */
|
|
/* Write some data to the flash. This routine will be registered as the */
|
|
/* write routine for this MTD. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : Address of sector to write to. */
|
|
/* buffer : buffer to write from. */
|
|
/* length : number of bytes to write (up to sector size). */
|
|
/* modes : OVERWRITE, EDC flags etc. */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failed. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus doc2Write(FLFlash * flash,
|
|
CardAddress address,
|
|
const void FAR1 *buffer,
|
|
dword length,
|
|
word modes)
|
|
{
|
|
char FAR1 *temp = (char FAR1 *)buffer;
|
|
FLStatus status;
|
|
#ifdef BIG_PAGE_ENABLED
|
|
word block = (word)((modes & EXTRA) ? EXTRA_LEN : SECTOR_SIZE);
|
|
#else
|
|
word block = (word)((modes & EXTRA) ? SECTOR_EXTRA_LEN : SECTOR_SIZE);
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
word writeNow = block - ((word)address & (block - 1));
|
|
|
|
#ifdef ENVIRONMENT_VARS
|
|
if(flSuspendMode & FL_SUSPEND_WRITE)
|
|
return flIOCommandBlocked;
|
|
#endif /* ENVIRONMENT_VARS */
|
|
|
|
/* write in BLOCKs; first and last might be partial */
|
|
chkASICmode(flash);
|
|
|
|
while( length > 0 )
|
|
{
|
|
if(writeNow > length)
|
|
writeNow = (word)length;
|
|
/* turn off EDC on partial block write */
|
|
|
|
status = writeOneSector(flash, address, temp, writeNow,
|
|
(word)((writeNow != SECTOR_SIZE) ? (modes &= ~EDC) : modes) );
|
|
if(status!=flOK)
|
|
return status;
|
|
|
|
length -= writeNow;
|
|
address += writeNow;
|
|
temp += writeNow;
|
|
writeNow = block; /* align at BLOCK */
|
|
}
|
|
return( flOK );
|
|
}
|
|
#endif /* FL_READ_ONLY */
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* r e a d O n e S e c t o r */
|
|
/* */
|
|
/* Read up to one 512-byte block from flash. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : Address to read from. */
|
|
/* buffer : buffer to read to. */
|
|
/* length : number of bytes to read (up to sector size). */
|
|
/* modes : EDC flag etc. */
|
|
/* */
|
|
/* Notes: big_page_enabled does not support PARTIAL_EDC FLAG */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failed. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus readOneSector (FLFlash * flash,
|
|
CardAddress address,
|
|
void FAR1 *buffer,
|
|
word length,
|
|
word modes)
|
|
{
|
|
#ifndef NO_EDC_MODE
|
|
byte extraBytes[SYNDROM_BYTES];
|
|
#ifdef MTD_STANDALONE
|
|
int index;
|
|
#endif
|
|
#endif
|
|
FLStatus stat = flOK;
|
|
PointerOp cmd = AREA_A; /* default for .... */
|
|
CardAddress addr = address; /* .... KM29N16000 */
|
|
#ifdef BIG_PAGE_ENABLED
|
|
int toFirstPage, toSecondPage;
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
|
|
mapWin(flash, &addr);
|
|
|
|
makeCommand(flash, &cmd, &addr, modes); /* move flash pointer to areas A,B or C of page */
|
|
|
|
readCommand(flash, cmd, addr);
|
|
|
|
#ifndef NO_EDC_MODE
|
|
if( modes & EDC )
|
|
eccONread(flash);
|
|
#endif
|
|
#ifdef BIG_PAGE_ENABLED
|
|
if( !(flash->flags & BIG_PAGE) )
|
|
{
|
|
/* read up to two pages separately */
|
|
if( modes & EXTRA )
|
|
toFirstPage = EXTRA_LEN - ((word)addr & (EXTRA_LEN-1));
|
|
else
|
|
toFirstPage = CHIP_PAGE_SIZE - ((word)addr & (CHIP_PAGE_SIZE-1));
|
|
|
|
if(toFirstPage > length)
|
|
toFirstPage = length;
|
|
toSecondPage = length - toFirstPage;
|
|
|
|
rdBuf (flash, (byte FAR1 *)buffer, toFirstPage ); /* starting page */
|
|
|
|
if ( toSecondPage > 0 ) /* next page */
|
|
{
|
|
if( modes & EXTRA )
|
|
addr -= (CHIP_PAGE_SIZE + ((word)addr & (EXTRA_LEN-1)));
|
|
readCommand (flash, cmd, addr + toFirstPage);
|
|
rdBuf(flash, (byte FAR1 *)buffer + toFirstPage, toSecondPage );
|
|
}
|
|
}
|
|
else
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
{
|
|
rdBuf(flash, (byte FAR1 *)buffer, length );
|
|
|
|
#ifndef NO_EDC_MODE
|
|
if((modes & PARTIAL_EDC) &&
|
|
(((word)address & NFDC21thisVars->pageMask) == 0))
|
|
{
|
|
/* Partial page read with EDC must let rest of page through
|
|
the HW edc mechanism */
|
|
|
|
word unreadBytes;
|
|
|
|
for (unreadBytes = SECTOR_SIZE - length;unreadBytes > 0;unreadBytes--)
|
|
{
|
|
cmd = (PointerOp)flRead8bitReg(flash, NFDC21thisIO);
|
|
}
|
|
}
|
|
#endif /* NO_EDC_MODE */
|
|
}
|
|
|
|
#ifndef NO_EDC_MODE
|
|
if( modes & EDC )
|
|
{ /* read syndrom to let it through the ECC unit */
|
|
|
|
rdBuf(flash, extraBytes, SYNDROM_BYTES );
|
|
|
|
if( eccError(flash) ) /* An EDC error was found */
|
|
{
|
|
#ifdef MTD_STANDALONE
|
|
/* Check if all of the EDC bytes are FF's. If so ignore the EDC */
|
|
/* assuming that it has'nt been used due to programing of less then */
|
|
/* 512 bytes */
|
|
|
|
for(index=0;index<SYNDROM_BYTES;index++)
|
|
{
|
|
if (extraBytes[index]!=0xFF)
|
|
break;
|
|
}
|
|
|
|
if (index!=SYNDROM_BYTES) /* not all of the EDC bytes are FF's */
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
{
|
|
/* try to fix ECC error */
|
|
if ( modes & NO_SECOND_TRY ) /* 2nd try */
|
|
{
|
|
byte syndrom[SYNDROM_BYTES];
|
|
byte tmp;
|
|
|
|
docread(flash->win,Nsyndrom,syndrom,SYNDROM_BYTES);
|
|
tmp = syndrom[0]; /* Swap 1 and 3 words */
|
|
syndrom[0] = syndrom[4];
|
|
syndrom[4] = tmp;
|
|
tmp = syndrom[1];
|
|
syndrom[1] = syndrom[5];
|
|
syndrom[5] = tmp;
|
|
|
|
if( flCheckAndFixEDC( (char FAR1 *)buffer, (char*)syndrom, 1) != NO_EDC_ERROR)
|
|
{
|
|
DEBUG_PRINT(("Debug: EDC error for NFDC 2148.\r\n"));
|
|
stat = flDataError;
|
|
}
|
|
}
|
|
else /* 1st try - try once more */
|
|
return( readOneSector( flash, address, buffer, length,
|
|
(word)(modes | NO_SECOND_TRY) ) );
|
|
}
|
|
}
|
|
eccOFF(flash);
|
|
}
|
|
#endif /* NO_EDC_MODE */
|
|
|
|
writeSignals (flash, FLASH_IO | WP);
|
|
if( (modes & EXTRA) && /* Serial Read Cycle Entry */
|
|
((length + (((word)addr) & (NFDC21thisVars->tailSize - 1)))
|
|
== NFDC21thisVars->tailSize) )
|
|
waitForReady(flash);
|
|
|
|
return( stat );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* d o c 2 R e a d */
|
|
/* */
|
|
/* Read some data from the flash. This routine will be registered as */
|
|
/* the read routine for this MTD. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : Address to read from. */
|
|
/* buffer : buffer to read to. */
|
|
/* length : number of bytes to read (up to sector size). */
|
|
/* modes : EDC flag etc. */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failed. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus doc2Read(FLFlash * flash,
|
|
CardAddress address,
|
|
void FAR1 *buffer,
|
|
dword length,
|
|
word modes)
|
|
{
|
|
char FAR1 *temp = (char FAR1 *)buffer;
|
|
FLStatus status;
|
|
word readNow;
|
|
|
|
#ifdef BIG_PAGE_ENABLED
|
|
word block = (word)(( modes & EXTRA ) ? EXTRA_LEN : SECTOR_SIZE );
|
|
#else
|
|
word block = (word)(( modes & EXTRA ) ? SECTOR_EXTRA_LEN : SECTOR_SIZE );
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
|
|
#ifdef ENVIRONMENT_VARS
|
|
if((flSuspendMode & FL_SUSPEND_IO) == FL_SUSPEND_IO)
|
|
return flIOCommandBlocked;
|
|
#endif /* ENVIRONMENT_VARS */
|
|
|
|
chkASICmode(flash);
|
|
/* read in BLOCKs; first and last might be partial */
|
|
|
|
readNow = block - ((word)address & (block - 1));
|
|
|
|
while( length > 0 ) {
|
|
if( readNow > length )
|
|
readNow = (word)length;
|
|
/* turn off EDC on partial block read */
|
|
status = readOneSector(flash, address, temp, readNow, (word)(
|
|
((readNow != SECTOR_SIZE) && (modes != PARTIAL_EDC)) ?
|
|
modes &=~PARTIAL_EDC : modes));
|
|
if(status != flOK)
|
|
return status;
|
|
|
|
length -= readNow;
|
|
address += readNow;
|
|
temp += readNow;
|
|
readNow = block; /* align at BLOCK */
|
|
}
|
|
return( flOK );
|
|
}
|
|
|
|
#ifndef FL_READ_ONLY
|
|
|
|
#if (defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT))
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* c h e c k E r a s e */
|
|
/* */
|
|
/* Check if media is truly erased (main areas of page only). */
|
|
/* */
|
|
/* Note to save on memory consumption the 1k read back buffer is used */
|
|
/* Only when the VERIFY_ERASE compilation flag is set. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : Address of page to check. */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 if page is erased, otherwise writeFault. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus checkErase( FLFlash * flash, CardAddress address )
|
|
{
|
|
register int i, j;
|
|
word inc = READ_BACK_BUFFER_SIZE;
|
|
dword * bufPtr = (dword *)NFDC21thisVars->readBackBuffer;
|
|
CardAddress curAddress = address;
|
|
word block = (word)(flash->erasableBlockSize / inc);
|
|
dword * endBufPtr = bufPtr+(inc / sizeof(dword));
|
|
dword * curBufPtr;
|
|
|
|
/* Check main area */
|
|
for ( i = 0 ; i < block ; i++, curAddress += inc )
|
|
{
|
|
if ( doc2Read(flash,curAddress,(void FAR1 *)bufPtr,(dword)inc,0) != flOK )
|
|
return( flWriteFault );
|
|
|
|
for ( curBufPtr = bufPtr ;
|
|
curBufPtr < endBufPtr ; curBufPtr++)
|
|
if ( *bufPtr != 0xFFFFFFFFL )
|
|
return( flWriteFault );
|
|
}
|
|
|
|
/* Check extra area */
|
|
for ( i = 0 ; i < NFDC21thisVars->pagesPerBlock ; i++,address+=SECTOR_SIZE)
|
|
{
|
|
if ( doc2Read(flash,address,(void FAR1 *)bufPtr,
|
|
NFDC21thisVars->tailSize, EXTRA) != flOK )
|
|
return( flWriteFault );
|
|
|
|
for (j=0;j<(NFDC21thisVars->tailSize>>2);j++)
|
|
{
|
|
if (bufPtr[j] != 0xFFFFFFFFL)
|
|
return( flWriteFault );
|
|
}
|
|
}
|
|
return( flOK );
|
|
}
|
|
|
|
#endif /* VERIFY_ERASE or MTD_RECONSTRUCT_BBT */
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* d o c 2 E r a s e */
|
|
/* */
|
|
/* Erase number of blocks. This routine will be registered as the */
|
|
/* erase routine for this MTD. */
|
|
/* */
|
|
/* Note - can not erase all units of 1GB DiskOnChip. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* blockNo : First block to erase. */
|
|
/* blocksToErase : Number of blocks to erase. */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failed. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLStatus doc2Erase(FLFlash * flash,
|
|
word blockNo,
|
|
word blocksToErase)
|
|
{
|
|
FLStatus status = flOK;
|
|
word floorToUse;
|
|
word nextFloorBlockNo, i;
|
|
CardAddress startAddress = (CardAddress)blockNo * flash->erasableBlockSize;
|
|
CardAddress address = startAddress;
|
|
|
|
#ifdef ENVIRONMENT_VARS
|
|
if(flSuspendMode & FL_SUSPEND_WRITE)
|
|
return flIOCommandBlocked;
|
|
#endif /* ENVIRONMENT_VARS */
|
|
|
|
#ifndef MTD_STANDALONE
|
|
if (flWriteProtected(flash->socket))
|
|
return( flWriteProtect );
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
if( (dword)((dword)blockNo + (dword)blocksToErase) >
|
|
(dword)((dword)NFDC21thisVars->noOfBlocks * (dword)flash->noOfChips))
|
|
return( flWriteFault ); /* out of media */
|
|
|
|
chkASICmode(flash);
|
|
/* handle erase accross floors */
|
|
#ifndef SEPARATED_CASCADED
|
|
floorToUse = (word)(startAddress / NFDC21thisVars->floorSize) + 1;
|
|
|
|
if (floorToUse != flash->noOfFloors)
|
|
{
|
|
nextFloorBlockNo = (word)(floorToUse * (NFDC21thisVars->floorSize /
|
|
flash->erasableBlockSize));
|
|
|
|
if( blockNo + blocksToErase > nextFloorBlockNo )
|
|
{ /* erase on higher floors */
|
|
status = ( doc2Erase( flash, nextFloorBlockNo,
|
|
(word)(blocksToErase - (nextFloorBlockNo - blockNo))) );
|
|
blocksToErase = nextFloorBlockNo - blockNo;
|
|
if(status!=flOK)
|
|
return status;
|
|
}
|
|
}
|
|
#endif /* SEPARATED_CASCADED */
|
|
|
|
/* erase on this floor */
|
|
|
|
mapWin (flash, &address);
|
|
|
|
for (i = 0; i < blocksToErase ; i++, blockNo++ ) {
|
|
dword pageNo = ((dword)blockNo * NFDC21thisVars->pagesPerBlock);
|
|
|
|
command(flash, RESET_FLASH);
|
|
writeSignals (flash, FLASH_IO | CE);
|
|
waitForReady(flash);
|
|
|
|
command(flash, SETUP_ERASE);
|
|
|
|
writeSignals (flash, FLASH_IO | ALE | CE);
|
|
#ifdef SLOW_IO_FLAG
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)pageNo);
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)pageNo);
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)(pageNo >> 8));
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(pageNo >> 8));
|
|
if( flash->flags & BIG_ADDR ) {
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)(pageNo >> 16));
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(pageNo >> 16));
|
|
}
|
|
#else
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)pageNo);
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(pageNo >> 8));
|
|
if( flash->flags & BIG_ADDR )
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(pageNo >> 16));
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
|
|
#endif /* SLOW_IO_FLAG */
|
|
writeSignals(flash, FLASH_IO | CE);
|
|
|
|
/* if only one block may be erase at a time then do it */
|
|
/* otherwise leave it for later */
|
|
|
|
command(flash, CONFIRM_ERASE);
|
|
|
|
#ifndef MTD_STANDALONE
|
|
#ifndef DO_NOT_YIELD_CPU
|
|
if(waitForReadyWithYieldCPU(flash,MAX_WAIT)==FALSE)
|
|
#endif /* DO_NOT_YIELD_CPU */
|
|
#endif /* MTD_STANDALONE */
|
|
{
|
|
waitForReady(flash);
|
|
}
|
|
if ( readStatus(flash) & (byte)(FAIL) ) { /* erase operation failed */
|
|
DEBUG_PRINT(("Debug: NFDC 2148 erase failed.\r\n"));
|
|
status = flWriteFault;
|
|
|
|
/* reset flash device and abort */
|
|
|
|
command(flash, RESET_FLASH);
|
|
waitForReady(flash);
|
|
|
|
break;
|
|
}
|
|
else { /* no failure reported */
|
|
#ifdef VERIFY_ERASE
|
|
|
|
if ( checkErase( flash, startAddress + i * flash->erasableBlockSize) != flOK ) {
|
|
DEBUG_PRINT(("Debug: NFDC 2148 erase failed in verification.\r\n"));
|
|
return flWriteFault ;
|
|
}
|
|
|
|
#endif /* VERIFY_ERASE */
|
|
}
|
|
} /* block loop */
|
|
|
|
#ifdef MULTI_ERASE
|
|
/* do multiple block erase as was promised */
|
|
|
|
command(flash, CONFIRM_ERASE);
|
|
#ifndef MTD_STANDALONE
|
|
#ifndef DO_NOT_YIELD_CPU
|
|
waitForReadyWithYieldCPU(flash,MAX_WAIT);
|
|
#endif /* DO_NOT_YIELD_CPU */
|
|
#endif /* MTD_STANDALONE */
|
|
if ( readStatus(flash) & (byte)(FAIL) ) { /* erase operation failed */
|
|
DEBUG_PRINT(("Debug: NFDC 2148 erase failed.\r\n"));
|
|
status = flWriteFault;
|
|
|
|
/* reset flash device and abort */
|
|
|
|
command(flash, RESET_FLASH);
|
|
waitForReady(flash);
|
|
}
|
|
#endif /* MULTI_ERASE */
|
|
|
|
writeSignals (flash, FLASH_IO | WP);
|
|
return( status );
|
|
}
|
|
#endif /* FL_READ_ONLY */
|
|
|
|
#ifndef MTD_STANDALONE
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* d o c 2 M a p */
|
|
/* */
|
|
/* Map through buffer. This routine will be registered as the map */
|
|
/* routine for this MTD. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* address : Flash address to be mapped. */
|
|
/* length : number of bytes to map. */
|
|
/* */
|
|
/* Returns: */
|
|
/* Pointer to the buffer data was mapped to. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static void FAR0 *doc2Map ( FLFlash * flash, CardAddress address, int length )
|
|
{
|
|
doc2Read(flash,address,NFDC21thisBuffer,length, 0);
|
|
/* Force remapping of internal catched sector */
|
|
flash->socket->remapped = TRUE;
|
|
return( (void FAR0 *)NFDC21thisBuffer );
|
|
}
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
#ifdef MTD_READ_BBT
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* R e a d B B T */
|
|
/* */
|
|
/* Read the media Bad Blocks Table to a user buffer. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* unitNo : indicated which unit number to start checking from. */
|
|
/* unitToRead : indicating how many units to check */
|
|
/* buffer : buffer to read into. */
|
|
/* reconstruct : TRUE for reconstruct BBT from virgin card */
|
|
/* */
|
|
/* Note: blocks is a minimal flash erasable area. */
|
|
/* Note: unit can contain several blocks. */
|
|
/* Note: There is no current implementation of a unit that contains */
|
|
/* more then a single block. */
|
|
/* Note: The format of the BBT is byte per unit 0 for bad any other */
|
|
/* value for good. */
|
|
/* Note: global variables changed at doc2Read: */
|
|
/* global variable NFDC21thisVars->currentFloor is updated */
|
|
/* flash->socket.window.currentPage = pageToMap; */
|
|
/* flash->socket.remapped = TRUE; */
|
|
/* Note: At least 4 bytes must be read */
|
|
/* */
|
|
/* RETURNS: */
|
|
/* flOK on success */
|
|
/* flBadLength if one of the units is out of the units range */
|
|
/* flBadBBT on read fault */
|
|
/*----------------------------------------------------------------------*/
|
|
static FLStatus readBBT(FLFlash * flash, dword unitNo, dword unitsToRead,
|
|
byte blockMultiplier, byte FAR1 * buffer,
|
|
FLBoolean reconstruct)
|
|
{
|
|
CardAddress bbtAddr,floorEndAddr;
|
|
CardAddress addr,floorStartAddr,alignAddr;
|
|
dword unitsPerFloor = NFDC21thisVars->floorSize >> flash->erasableBlockSizeBits;
|
|
word curRead,actualRead;
|
|
CardAddress mediaSize = (CardAddress)flash->chipSize*flash->noOfChips;
|
|
FLStatus status = flOK;
|
|
dword unitOffset;
|
|
dword sizeOfBBT;
|
|
word counter;
|
|
|
|
byte FAR1* bufPtr = buffer;
|
|
#if (defined (MTD_RECONSTRUCT_BBT) && !defined(FL_READ_ONLY))
|
|
CardAddress bbtCurAddr;
|
|
dword i;
|
|
byte reconstructBBT = 0;
|
|
#endif /* MTD_RECONSTRUCT_BBT && not FL_READ_ONLY */
|
|
|
|
/* Arg sanity check */
|
|
if (((dword)(unitNo+unitsToRead) <<
|
|
(blockMultiplier+flash->erasableBlockSizeBits)) > mediaSize)
|
|
return flBadParameter;
|
|
|
|
/* Calculate size of BBT blocks */
|
|
for(sizeOfBBT = flash->erasableBlockSize;
|
|
sizeOfBBT < unitsPerFloor ;sizeOfBBT = sizeOfBBT<<1);
|
|
#ifndef MTD_STANDALONE
|
|
/* Force remapping of internal catched sector */
|
|
flash->socket->remapped = TRUE;
|
|
#endif /* MTD_STANDALONE */
|
|
/* Adjust no' of blocks per floor according to blocks multiplier */
|
|
unitsPerFloor = unitsPerFloor >> blockMultiplier;
|
|
/* Mark all user buffer as good units */
|
|
tffsset(buffer,BBT_GOOD_UNIT,unitsToRead);
|
|
|
|
/* Loop over all of the floors */
|
|
for (floorStartAddr = 0 ; (floorStartAddr < mediaSize) && (unitsToRead > 0);
|
|
floorStartAddr += NFDC21thisVars->floorSize)
|
|
{
|
|
floorEndAddr = TFFSMIN(floorStartAddr+NFDC21thisVars->floorSize,mediaSize);
|
|
/* Look for bbt signature in extra area start looking from last unit */
|
|
for(bbtAddr = floorEndAddr - sizeOfBBT,
|
|
counter = BBT_MAX_DISTANCE;
|
|
(bbtAddr > floorStartAddr) && (counter > 0);
|
|
bbtAddr -= flash->erasableBlockSize , counter--)
|
|
{
|
|
status = doc2Read(flash,bbtAddr+8,NFDC21thisBuffer,BBT_SIGN_SIZE,EXTRA);
|
|
if (status != flOK)
|
|
return flBadBBT;
|
|
if(tffscmp(NFDC21thisBuffer,BBT_SIGN,BBT_SIGN_SIZE)==0)
|
|
break;
|
|
}
|
|
|
|
/* No BBT was found virgin card */
|
|
|
|
if((bbtAddr==floorStartAddr) || (counter == 0))
|
|
{
|
|
#if (defined (MTD_RECONSTRUCT_BBT) && !defined(FL_READ_ONLY))
|
|
if (reconstruct == TRUE)
|
|
{
|
|
reconstructBBT++;
|
|
if (reconstructBBT == 1)
|
|
DFORMAT_PRINT(("\rVirgin card rebuilding unit map.\r\n\n"));
|
|
|
|
/* Find good unit for BBT */
|
|
|
|
for(bbtAddr = floorEndAddr - sizeOfBBT ;
|
|
bbtAddr > floorStartAddr ;
|
|
bbtAddr -= flash->erasableBlockSize , status = flOK)
|
|
{
|
|
/* Find enough consequtive units for the BBT */
|
|
for(i=0;(status == flOK)&&(i<sizeOfBBT);i+=flash->erasableBlockSize)
|
|
{
|
|
status = checkErase(flash, bbtAddr+i);
|
|
}
|
|
if(status == flOK)
|
|
break;
|
|
}
|
|
if (bbtAddr == floorStartAddr) /* Could not find place for BBT */
|
|
{
|
|
DFORMAT_PRINT(("Debug: no good block found.\r\n"));
|
|
return flBadBBT;
|
|
}
|
|
|
|
/* Search and mark the entire floor BBT (512 at a time) */
|
|
|
|
bbtCurAddr = bbtAddr;
|
|
for (addr=floorStartAddr;
|
|
addr<floorEndAddr; bbtCurAddr+=SECTOR_SIZE)
|
|
{
|
|
/* Mark all blocks as good */
|
|
tffsset(NFDC21thisBuffer,BBT_GOOD_UNIT,SECTOR_SIZE);
|
|
/* Mark IPL as unused */
|
|
for (i=0;i<SECTOR_SIZE;i++,addr+=flash->erasableBlockSize)
|
|
{
|
|
#ifndef NT5PORT
|
|
DFORMAT_PRINT(("Checking block %u\r",(word)(addr>>flash->erasableBlockSizeBits)));
|
|
#endif// NT5PORT
|
|
/* Bad block table is marked as unavailable */
|
|
if ((addr>=bbtAddr) && (addr<bbtAddr+sizeOfBBT))
|
|
{
|
|
NFDC21thisBuffer[i] = BBT_UNAVAIL_UNIT;
|
|
}
|
|
else /* The unerased blocks are marked as bad */
|
|
{
|
|
if(checkErase(flash, addr) != flOK)
|
|
{
|
|
NFDC21thisBuffer[i] = BBT_BAD_UNIT;
|
|
}
|
|
}
|
|
}
|
|
if(addr == (flash->erasableBlockSize<<SECTOR_SIZE_BITS))
|
|
{
|
|
/* If IPL unit is good mark it as unavailable */
|
|
if(NFDC21thisBuffer[0] != BBT_BAD_UNIT)
|
|
NFDC21thisBuffer[0] = BBT_UNAVAIL_UNIT;
|
|
}
|
|
status = doc2Write(flash,bbtCurAddr,NFDC21thisBuffer,SECTOR_SIZE,EDC);
|
|
if (status != flOK)
|
|
{
|
|
DFORMAT_PRINT(("ERROR - Failed writting bad block table.\r\n"));
|
|
return flBadBBT;
|
|
}
|
|
}
|
|
/* Mark bad blocks table with special mark */
|
|
status = doc2Write(flash,bbtAddr+8,BBT_SIGN, BBT_SIGN_SIZE,EXTRA);
|
|
}
|
|
else
|
|
#endif /* MTD_RECONSTRUCT_BBT && not FL_READ_ONLY */
|
|
{
|
|
return flBadBBT;
|
|
}
|
|
}
|
|
|
|
/* Return only blocks that are in this floor */
|
|
addr = floorStartAddr >> (flash->erasableBlockSizeBits + blockMultiplier);
|
|
|
|
if ((unitNo >= addr) && (unitNo < addr + unitsPerFloor))
|
|
{
|
|
unitOffset = (unitNo % unitsPerFloor);
|
|
curRead = ((word)TFFSMIN(unitsToRead,unitsPerFloor - unitOffset));
|
|
unitsToRead -= curRead;
|
|
|
|
/* Convert to real number of bytes to read and address */
|
|
unitOffset <<= blockMultiplier;
|
|
curRead <<= blockMultiplier;
|
|
alignAddr = ((bbtAddr + unitOffset) >> SECTOR_SIZE_BITS)<<SECTOR_SIZE_BITS;
|
|
|
|
do /* Read and copy into buffer 512 blocks at a time */
|
|
{
|
|
if (doc2Read(flash,alignAddr, NFDC21thisBuffer,SECTOR_SIZE,EDC) != flOK)
|
|
return flBadBBT;
|
|
|
|
unitOffset = unitOffset % SECTOR_SIZE;
|
|
actualRead = (word)TFFSMIN(SECTOR_SIZE - unitOffset,curRead);
|
|
curRead -= actualRead;
|
|
/* Copy relevant blocks into user buffer */
|
|
for (actualRead += (word)unitOffset ;
|
|
unitOffset < actualRead ;
|
|
bufPtr = BYTE_ADD_FAR(bufPtr,1)) /* increment buffer */
|
|
{
|
|
for (counter = 1 << blockMultiplier ; counter > 0 ;
|
|
counter-- , unitOffset++)
|
|
{
|
|
if (NFDC21thisBuffer[unitOffset] != BBT_GOOD_UNIT)
|
|
{
|
|
*bufPtr = NFDC21thisBuffer[unitOffset];
|
|
}
|
|
}
|
|
}
|
|
alignAddr+=SECTOR_SIZE;
|
|
}while(curRead > 0);
|
|
|
|
if (unitsToRead > 0)
|
|
unitNo = addr + unitsPerFloor;
|
|
}
|
|
}
|
|
|
|
#if (defined (MTD_RECONSTRUCT_BBT) && !defined(FL_READ_ONLY))
|
|
if (reconstructBBT > 0)
|
|
DFORMAT_PRINT(("\rMedia has been scanned. \r\n"));
|
|
#endif /* MTD_RECONSTRUCT_BBT && not FL_READ_ONLY */
|
|
|
|
return flOK;
|
|
}
|
|
#endif /* MTD_READ_BBT */
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* i s K n o w n M e d i a */
|
|
/* */
|
|
/* Check if this flash media is supported. Initialize relevant fields */
|
|
/* in data structures. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* vendorId_P : vendor ID read from chip. */
|
|
/* chipId_p : chip ID read from chip. */
|
|
/* dev : dev chips were accessed before this one. */
|
|
/* */
|
|
/* Returns: */
|
|
/* TRUE if this media is supported, FALSE otherwise. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static FLBoolean isKnownMedia( FLFlash * flash, Reg8bitType vendorId_p, Reg8bitType chipId_p, int dev )
|
|
{
|
|
if((dev == 0)
|
|
#ifndef SEPARATED_CASCADED
|
|
&& (NFDC21thisVars->currentFloor == 0)
|
|
#endif /* SEPARATED_CASCADED */
|
|
) { /* First Identification */
|
|
NFDC21thisVars->vendorID = (word)vendorId_p; /* remember for next chips */
|
|
NFDC21thisVars->chipID = (word)chipId_p;
|
|
NFDC21thisVars->pagesPerBlock = PAGES_PER_BLOCK;
|
|
flash->maxEraseCycles = 1000000L;
|
|
flash->flags |= BIG_PAGE;
|
|
flash->pageSize = 0x200;
|
|
switch( (byte)vendorId_p ) {
|
|
case 0xEC : /* Samsung */
|
|
switch( (byte)chipId_p ) {
|
|
#ifdef BIG_PAGE_ENABLED
|
|
case 0x64 : /* 2 Mb */
|
|
case 0xEA :
|
|
flash->type = KM29N16000_FLASH;
|
|
flash->pageSize = 0x100;
|
|
flash->chipSize = 0x200000L;
|
|
flash->flags &= ~BIG_PAGE;
|
|
break;
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
case 0xE3 : /* 4 Mb */
|
|
case 0xE5 :
|
|
flash->type = KM29N32000_FLASH;
|
|
flash->chipSize = 0x400000L;
|
|
break;
|
|
|
|
case 0xE6 : /* 8 Mb */
|
|
flash->type = KM29V64000_FLASH;
|
|
flash->chipSize = 0x800000L;
|
|
break;
|
|
|
|
case 0x73 : /* 16 Mb */
|
|
flash->type = KM29V128000_FLASH;
|
|
flash->chipSize = 0x1000000L;
|
|
NFDC21thisVars->pagesPerBlock *= 2;
|
|
break;
|
|
|
|
case 0x75 : /* 32 Mb */
|
|
flash->type = KM29V256000_FLASH;
|
|
flash->chipSize = 0x2000000L;
|
|
NFDC21thisVars->pagesPerBlock *= 2;
|
|
break;
|
|
|
|
case 0x76 : /* 64 Mb */
|
|
flash->type = KM29V512000_FLASH;
|
|
flash->chipSize = 0x4000000L;
|
|
flash->flags |= BIG_ADDR;
|
|
NFDC21thisVars->pagesPerBlock *= 2;
|
|
break;
|
|
|
|
default : /* Undefined Flash */
|
|
return(FALSE);
|
|
}
|
|
break;
|
|
|
|
case 0x98 : /* Toshiba */
|
|
switch( chipId_p ) {
|
|
#ifdef BIG_PAGE_ENABLED
|
|
case 0x64 : /* 2 Mb */
|
|
case 0xEA :
|
|
flash->type = TC5816_FLASH;
|
|
flash->pageSize = 0x100;
|
|
flash->chipSize = 0x200000L;
|
|
flash->flags &= ~BIG_PAGE;
|
|
break;
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
case 0x6B : /* 4 Mb */
|
|
case 0xE5 :
|
|
flash->type = TC5832_FLASH;
|
|
flash->chipSize = 0x400000L;
|
|
break;
|
|
|
|
case 0xE6 : /* 8 Mb */
|
|
flash->type = TC5864_FLASH;
|
|
flash->chipSize = 0x800000L;
|
|
break;
|
|
|
|
case 0x73 : /* 16 Mb */
|
|
flash->type = TC58128_FLASH;
|
|
flash->chipSize = 0x1000000L;
|
|
NFDC21thisVars->pagesPerBlock *= 2;
|
|
break;
|
|
|
|
case 0x75 : /* 32 Mb */
|
|
flash->type = TC58256_FLASH;
|
|
flash->chipSize = 0x2000000L;
|
|
NFDC21thisVars->pagesPerBlock *= 2;
|
|
break;
|
|
|
|
case 0x76 : /* 64 Mb */
|
|
flash->type = TC58512_FLASH;
|
|
flash->chipSize = 0x4000000L;
|
|
flash->flags |= BIG_ADDR;
|
|
NFDC21thisVars->pagesPerBlock *= 2;
|
|
break;
|
|
|
|
case 0x79: /* 128 Mb */
|
|
flash->type = TC581024_FLASH;
|
|
flash->chipSize = 0x8000000L;
|
|
flash->flags |= BIG_ADDR;
|
|
NFDC21thisVars->pagesPerBlock *= 2;
|
|
break;
|
|
|
|
default : /* Undefined Flash */
|
|
return( FALSE );
|
|
}
|
|
flash->flags |= FULL_PAGE; /* no partial page programming */
|
|
break;
|
|
|
|
default : /* Undefined Flash */
|
|
return( FALSE );
|
|
}
|
|
return( TRUE );
|
|
}
|
|
else /* dev != 0 */
|
|
if( (vendorId_p == NFDC21thisVars->vendorID) && (chipId_p == NFDC21thisVars->chipID) )
|
|
return( TRUE );
|
|
|
|
return( FALSE );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* r e a d F l a s h I D */
|
|
/* */
|
|
/* Read vendor and chip IDs, count flash devices. Initialize relevant */
|
|
/* fields in data structures. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* dev : dev chips were accessed before this one. */
|
|
/* */
|
|
/* Returns: */
|
|
/* TRUE if this media is supported, FALSE otherwise. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
static int readFlashID ( FLFlash * flash, int dev )
|
|
{
|
|
byte vendorId_p, chipId_p;
|
|
register int i;
|
|
volatile Reg8bitType junk = 0;
|
|
|
|
command (flash, READ_ID);
|
|
|
|
writeSignals (flash, FLASH_IO | ALE | CE | WP);
|
|
#ifdef SLOW_IO_FLAG
|
|
flWrite8bitReg(flash,NslowIO,(Reg8bitType)0);
|
|
#endif
|
|
flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)0);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC )
|
|
flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
|
|
writeSignals (flash, FLASH_IO | CE | WP);
|
|
|
|
/* read vendor ID */
|
|
|
|
flDelayMsecs( 10 ); /* 10 microsec delay */
|
|
for( i = 0;( i < 2 ); i++ ) /* perform 2 reads from NOP reg for delay */
|
|
junk += flRead8bitReg(flash,NNOPreg);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC ) {
|
|
junk += flRead8bitReg(flash,NreadPipeInit); /* load first data into pipeline */
|
|
vendorId_p = flRead8bitReg(flash,NreadLastData); /* finally read vendor ID */
|
|
}
|
|
else {
|
|
junk += flRead8bitReg(flash,NslowIO); /* read CDSN_slow_IO ignoring the data */
|
|
vendorId_p = flRead8bitReg(flash,NFDC21thisIO); /* finally read vendor ID */
|
|
}
|
|
|
|
/* read chip ID */
|
|
|
|
flDelayMsecs( 10 ); /* 10 microsec delay */
|
|
for( i = 0;( i < 2 ); i++ ) /* perform 2 reads from NOP reg for delay */
|
|
junk += flRead8bitReg(flash,NNOPreg);
|
|
if( NFDC21thisVars->flags & MDOC_ASIC ) {
|
|
junk += flRead8bitReg(flash,NreadPipeInit); /* load first data into pipeline */
|
|
chipId_p = flRead8bitReg(flash,NreadLastData); /* finally read chip ID */
|
|
}
|
|
else {
|
|
junk += flRead8bitReg(flash,NslowIO); /* read CDSN_slow_IO ignoring the data */
|
|
chipId_p = flRead8bitReg(flash,NFDC21thisIO); /* finally read chip ID */
|
|
}
|
|
|
|
if ( isKnownMedia(flash, vendorId_p, chipId_p, dev) != TRUE ) /* no chip or diff. */
|
|
return( FALSE ); /* type of flash */
|
|
|
|
flash->noOfChips++;
|
|
|
|
writeSignals (flash, FLASH_IO);
|
|
|
|
/* set flash parameters */
|
|
if((dev == 0)
|
|
#ifndef SEPARATED_CASCADED
|
|
&& (NFDC21thisVars->currentFloor == 0)
|
|
#endif /* SEPARATED_CASCADED */
|
|
)
|
|
{
|
|
NFDC21thisVars->pageAreaSize = 0x100;
|
|
|
|
#ifdef BIG_PAGE_ENABLED
|
|
if ( !(flash->flags & BIG_PAGE) )
|
|
NFDC21thisVars->tailSize = EXTRA_LEN; /* = 8 */
|
|
else
|
|
#endif /* BIG_PAGE_ENABLED */
|
|
NFDC21thisVars->tailSize = SECTOR_EXTRA_LEN; /* = 16 */
|
|
|
|
NFDC21thisVars->pageMask = (word)(flash->pageSize - 1);
|
|
flash->erasableBlockSize = NFDC21thisVars->pagesPerBlock * flash->pageSize;
|
|
NFDC21thisVars->noOfBlocks = (word)( flash->chipSize / flash->erasableBlockSize );
|
|
NFDC21thisVars->if_cfg = 8;
|
|
}
|
|
|
|
return( TRUE );
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* d o c 2 I d e n t i f y */
|
|
/* */
|
|
/* Identify flash. This routine will be registered as the */
|
|
/* identification routine for this MTD. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* flash : Pointer identifying drive */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, flUnknownMedia failed. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
#ifndef MTD_STANDALONE
|
|
static
|
|
#endif
|
|
FLStatus doc2000Identify(FLFlash * flash)
|
|
{
|
|
dword address = 0L;
|
|
int maxDevs, dev;
|
|
volatile Reg8bitType toggle1;
|
|
volatile Reg8bitType toggle2;
|
|
byte floorCnt = 0;
|
|
byte floor = 0;
|
|
|
|
#ifdef NT5PORT
|
|
byte socketNo = (byte)flSocketNoOf(flash->socket);
|
|
#else
|
|
byte socketNo = flSocketNoOf(flash->socket);
|
|
#endif NT5PORT
|
|
|
|
|
|
DEBUG_PRINT(("Debug: entering NFDC 2148 identification routine.\r\n"));
|
|
|
|
flash->mtdVars = &docMtdVars[socketNo];
|
|
|
|
#ifndef FL_NO_USE_FUNC
|
|
/* Initialize socket memory access routine */
|
|
if(setBusTypeOfFlash(flash, flBusConfig[socketNo] |
|
|
FL_8BIT_DOC_ACCESS | FL_8BIT_FLASH_ACCESS))
|
|
return flUnknownMedia;
|
|
#endif /* FL_NO_USE_FUNC */
|
|
|
|
|
|
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT))
|
|
/* Get pointer to read back buffer */
|
|
NFDC21thisVars->readBackBuffer = flReadBackBufferOf(socketNo);
|
|
#endif /* VERIFY_WRITE || VERIFY_ERASE || MTD_RECONSTRUCT_BBT */
|
|
|
|
#ifndef MTD_STANDALONE
|
|
/* get pointer to buffer (we assume SINGLE_BUFFER is not defined) */
|
|
NFDC21thisVars->buffer = flBufferOf(socketNo);
|
|
|
|
flSetWindowBusWidth(flash->socket, 16);/* use 8-bits */
|
|
flSetWindowSpeed(flash->socket, 250); /* 250 nsec. */
|
|
#else
|
|
#ifdef MTD_READ_BBT
|
|
NFDC21thisVars->buffer = &globalMTDBuffer;
|
|
#endif /* MTD_READ_BBT */
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
/* assume flash parameters for KM29N16000 */
|
|
|
|
NFDC21thisVars->floorSize = 1L;
|
|
#ifdef SEPARATED_CASCADED
|
|
/* NFDC21thisVars->currentFloor = flSocketNoOf(flash->socket);*/
|
|
#else
|
|
flash->noOfFloors = MAX_FLOORS;
|
|
NFDC21thisVars->currentFloor = MAX_FLOORS;
|
|
#endif /* SEPARATED_CASCADED */
|
|
flash->noOfChips = 0;
|
|
flash->chipSize = 0x200000L; /* Assume something ... */
|
|
flash->interleaving = 1; /* unimportant for now */
|
|
|
|
/* detect card - identify bit toggles on consequitive reads */
|
|
|
|
NFDC21thisWin = (NDOC2window)flMap(flash->socket, 0);
|
|
flash->win = NFDC21thisWin;
|
|
if (NFDC21thisWin == NULL)
|
|
return flUnknownMedia;
|
|
|
|
setASICmode (flash, ASIC_RESET_MODE);
|
|
setASICmode (flash, ASIC_NORMAL_MODE);
|
|
|
|
switch (flRead8bitReg(flash,NchipId))
|
|
{
|
|
case CHIP_ID_MDOC:
|
|
/* Mdoc and alon asics have the same ID only on
|
|
the forth read distigushes them */
|
|
for(dev=0;dev<3;dev++)
|
|
toggle1 = flRead8bitReg(flash,NchipId);
|
|
if (toggle1 != CHIP_ID_MDOC)
|
|
{
|
|
flash->mediaType = DOC2000TSOP_TYPE;
|
|
}
|
|
else
|
|
{
|
|
flash->mediaType = MDOC_TYPE;
|
|
}
|
|
NFDC21thisVars->flags |= MDOC_ASIC;
|
|
NFDC21thisVars->win_io = NIPLpart2;
|
|
break;
|
|
|
|
case CHIP_ID_DOC: /* Doc2000 */
|
|
NFDC21thisVars->flags &= ~MDOC_ASIC;
|
|
NFDC21thisVars->win_io = Nio;
|
|
flash->mediaType = DOC_TYPE;
|
|
break;
|
|
|
|
default:
|
|
DEBUG_PRINT(("Debug: failed to identify NFDC 2148.\r\n"));
|
|
return( flUnknownMedia );
|
|
}
|
|
mapWin (flash, &address);
|
|
|
|
if( NFDC21thisVars->flags & MDOC_ASIC ) {
|
|
toggle1 = flRead8bitReg(flash,NECCconfig);
|
|
toggle2 = toggle1 ^ flRead8bitReg(flash,NECCconfig);
|
|
}
|
|
else {
|
|
toggle1 = flRead8bitReg(flash,NECCstatus);
|
|
toggle2 = toggle1 ^ flRead8bitReg(flash,NECCstatus);
|
|
}
|
|
if ( (toggle2 & TOGGLE) == 0 ) {
|
|
DEBUG_PRINT(("Debug: failed to identify NFDC 2148.\r\n"));
|
|
return( flUnknownMedia );
|
|
}
|
|
|
|
/* reset all flash devices */
|
|
maxDevs = MAX_FLASH_DEVICES_DOC;
|
|
|
|
#ifndef SEPARATED_CASCADED
|
|
for ( NFDC21thisVars->currentFloor = 0 ;
|
|
NFDC21thisVars->currentFloor < MAX_FLOORS ;
|
|
NFDC21thisVars->currentFloor++ )
|
|
{
|
|
/* select floor */
|
|
flWrite8bitReg(flash,NASICselect,(Reg8bitType)NFDC21thisVars->currentFloor);
|
|
#endif /* SEPARATED_CASCADED */
|
|
for ( dev = 0 ; dev < maxDevs ; dev++ ) {
|
|
selectChip(flash, (Reg8bitType)dev );
|
|
command(flash, RESET_FLASH);
|
|
}
|
|
#ifndef SEPARATED_CASCADED
|
|
}
|
|
|
|
NFDC21thisVars->currentFloor = (byte)0;
|
|
/* back to ground floor */
|
|
flWrite8bitReg(flash,NASICselect,(Reg8bitType)NFDC21thisVars->currentFloor);
|
|
#endif /* SEPARATED_CASCADED */
|
|
writeSignals (flash, FLASH_IO | WP);
|
|
|
|
/* identify and count flash chips, figure out flash parameters */
|
|
#ifndef SEPARATED_CASCADED
|
|
for( floor = 0; floor < MAX_FLOORS; floor++ )
|
|
#endif /* SEPARATED_CASCADED */
|
|
for ( dev = 0; dev < maxDevs; dev++ )
|
|
{
|
|
dword addr = address;
|
|
|
|
mapWin(flash, &addr);
|
|
|
|
if ( readFlashID(flash, dev) == TRUE ) /* identified OK */
|
|
{
|
|
floorCnt = (byte)(floor + 1);
|
|
#ifndef SEPARATED_CASCADED
|
|
if (floor == 0)
|
|
#endif /* SEPARATED_CASCADED */
|
|
NFDC21thisVars->floorSize += flash->chipSize * flash->interleaving;
|
|
address += flash->chipSize * flash->interleaving;
|
|
}
|
|
else
|
|
{
|
|
#ifndef SEPARATED_CASCADED
|
|
if (floor != 0)
|
|
{
|
|
dev = maxDevs;
|
|
floor = MAX_FLOORS;
|
|
}
|
|
else
|
|
#endif /* SEPARATED_CASCADED */
|
|
{
|
|
maxDevs = dev;
|
|
NFDC21thisVars->floorSize = maxDevs * flash->chipSize * flash->interleaving;
|
|
}
|
|
}
|
|
}
|
|
#ifndef SEPARATED_CASCADED
|
|
NFDC21thisVars->currentFloor = (byte)0;
|
|
#endif /* SEPARATED_CASCADED */
|
|
flWrite8bitReg(flash,NASICselect,(Reg8bitType)NFDC21thisVars->currentFloor); /* back to ground floor */
|
|
|
|
if (flash->noOfChips == 0) {
|
|
DEBUG_PRINT(("Debug: failed to identify NFDC 2148.\r\n"));
|
|
return( flUnknownMedia );
|
|
}
|
|
|
|
address = 0L;
|
|
mapWin (flash, &address);
|
|
|
|
flash->noOfFloors = floorCnt;
|
|
|
|
eccOFF(flash);
|
|
|
|
/* Register our flash handlers */
|
|
#ifndef FL_READ_ONLY
|
|
flash->write = doc2Write;
|
|
flash->erase = doc2Erase;
|
|
#else
|
|
flash->erase = NULL;
|
|
flash->write = NULL;
|
|
#endif
|
|
flash->read = doc2Read;
|
|
#ifndef MTD_STANDALONE
|
|
flash->map = doc2Map;
|
|
#else
|
|
flash->map = NULL;
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
/* doc2000 tsop uses INFTL instead of NFTL , does not use
|
|
* the last block and has a readBBT routine
|
|
*/
|
|
|
|
if (flash->mediaType == DOC2000TSOP_TYPE)
|
|
{
|
|
#ifdef MTD_READ_BBT
|
|
flash->readBBT = readBBT;
|
|
#endif /* MTD_READ_BBT */
|
|
#ifndef NO_IPL_CODE
|
|
flash->download = forceDownLoad;
|
|
#ifndef FL_READ_ONLY
|
|
flash->writeIPL = writeIPL;
|
|
#endif /* FL_READ_ONLY */
|
|
#endif /* NO_IPL_CODE */
|
|
flash->flags |= INFTL_ENABLED;
|
|
}
|
|
else
|
|
{
|
|
flash->flags |= NFTL_ENABLED;
|
|
}
|
|
#ifndef SEPARATED_CASCADED
|
|
if (flash->mediaType == MDOC_TYPE)
|
|
flash->flags |= EXTERNAL_EPROM; /* Supports external eprom */
|
|
#endif /* SEPARATED_CASCADED */
|
|
|
|
DEBUG_PRINT(("Debug: identified NFDC 2148.\r\n"));
|
|
return( flOK );
|
|
}
|
|
|
|
#ifndef MTD_STANDALONE
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l R e g i s t e r D O C S O C */
|
|
/* */
|
|
/* Installs routines for DiskOnChip 2000 family. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* lowAddress, */
|
|
/* highAddress : host memory range to search for DiskOnChip */
|
|
/* 2000 memory window */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failure */
|
|
/*----------------------------------------------------------------------*/
|
|
#ifndef NT5PORT
|
|
FLStatus flRegisterDOCSOC(dword lowAddress, dword highAddress)
|
|
{
|
|
int serialNo;
|
|
|
|
if( noOfSockets >= SOCKETS )
|
|
return flTooManyComponents;
|
|
|
|
for(serialNo=0;( noOfSockets < SOCKETS );serialNo++,noOfSockets++)
|
|
{
|
|
FLSocket * socket = flSocketOf(noOfSockets);
|
|
|
|
socket->volNo = noOfSockets;
|
|
|
|
docSocketInit(socket);
|
|
|
|
/* call DiskOnChip MTD's routine to search for memory window */
|
|
|
|
flSetWindowSize(socket, 2); /* 4 KBytes */
|
|
|
|
socket->window.baseAddress = flDocWindowBaseAddress
|
|
((byte)socket->volNo, lowAddress, highAddress, &lowAddress);
|
|
|
|
if (socket->window.baseAddress == 0) /* DiskOnChip not detected */
|
|
break;
|
|
}
|
|
if( serialNo == 0 )
|
|
return flAdapterNotFound;
|
|
|
|
return flOK;
|
|
}
|
|
#endif /*NT5PORT*/
|
|
#else /* MTD_STANDALONE */
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* d o c 2 0 0 0 S e a r c h F o r W i n d o w */
|
|
/* */
|
|
/* Search for the DiskOnChip ASIC in a given memory range and */
|
|
/* initialize the given socket record. */
|
|
/* */
|
|
/* Parameters: */
|
|
/* socket : Record used to store the sockets parameters */
|
|
/* lowAddress : host memory range to search for DiskOnChip 2000 */
|
|
/* highAddress : memory window */
|
|
/* */
|
|
/* Output: initialize the following fields in the FLFlash record: */
|
|
/* */
|
|
/* base - Pointer to DiskOnChip window */
|
|
/* size - DiskOnChip window size usualy 8K */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, flDriveNotAvailable on failure. */
|
|
/* */
|
|
/* NOTE: This routine is not used by OSAK. It is used by standalone */
|
|
/* applications using the MTD (BDK for example) as a replacement */
|
|
/* for the OSAK DOCSOC.C file. */
|
|
/* The FLSocket record used by this function is not the one used */
|
|
/* by OSAK defined in flsocket.h but a replacement record defined */
|
|
/* in flflash.h. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
FLStatus doc2000SearchForWindow(FLSocket * socket,
|
|
dword lowAddress,
|
|
dword highAddress)
|
|
{
|
|
dword baseAddress; /* Physical base as a 4K page */
|
|
|
|
socket->size = 2 * 0x1000L; /* 4 KBytes */
|
|
baseAddress = (dword) flDocWindowBaseAddress(0, lowAddress, highAddress, &lowAddress);
|
|
socket->base = physicalToPointer(baseAddress << 12, socket->size,0);
|
|
if (baseAddress) /* DiskOnChip detected */
|
|
return flOK;
|
|
else /* DiskOnChip not detected */
|
|
return flDriveNotAvailable;
|
|
}
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* d o c 2 0 0 0 F r e e W i n d o w */
|
|
/* */
|
|
/* Free any resources used for the DiskOnChip window */
|
|
/* */
|
|
/* Parameters: */
|
|
/* socket : Record used to store the sockets parameters */
|
|
/* */
|
|
/* Returns: None */
|
|
/* */
|
|
/* NOTE: This routine is used only by virtual memory systems in order */
|
|
/* to unmap the DiskOnChip window. */
|
|
/* */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
void doc2000FreeWindow(FLSocket * socket)
|
|
{
|
|
freePointer(socket->base,DOC_WIN);
|
|
}
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
/*----------------------------------------------------------------------*/
|
|
/* f l R e g i s t e r D O C 2 0 0 0 */
|
|
/* */
|
|
/* Registers this MTD for use */
|
|
/* */
|
|
/* Parameters: */
|
|
/* None */
|
|
/* */
|
|
/* Returns: */
|
|
/* FLStatus : 0 on success, otherwise failure */
|
|
/*----------------------------------------------------------------------*/
|
|
|
|
FLStatus flRegisterDOC2000(void)
|
|
{
|
|
if (noOfMTDs >= MTDS)
|
|
return( flTooManyComponents );
|
|
|
|
#ifdef MTD_STANDALONE
|
|
socketTable[noOfMTDs] = doc2000SearchForWindow;
|
|
freeTable[noOfMTDs] = doc2000FreeWindow;
|
|
#endif /* MTD_STANDALONE */
|
|
|
|
mtdTable[noOfMTDs++] = doc2000Identify;
|
|
|
|
return( flOK );
|
|
}
|