able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/storage/tffsport/mdocplus.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

4082 lines
175 KiB
C
Raw Permalink Blame History

/*
* $Log: V:/Flite/archives/TrueFFS5/Src/MDOCPLUS.C_V $
*
* Rev 1.45 Apr 15 2002 07:37:38 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.
* Added macro's for several special DiskOnChip registers.
* Remove interleave if statement since new access layer simply uses different routine for int-1 and int-2.
* Bug fix - setAsicMode routine should first exit power down before checking for access error.
* Bug fix - forceDownload routine did not issue the download command to all DiskOnChip floors.
* Bug fix - added verify write support for uneven address and length.
* Bug fix - doc2write routine might not report flHWProtection when in FL_OFF mode.
* Bug fix - readBBT when reading less then 8 bytes.
* Bug fix - writeIPL routine did not write all copies of IPL
* Bug fix - readIPL routine did not set Max Id properly.
*
* Rev 1.44 Feb 19 2002 21:00:40 oris
* Replaced flTimeOut status with flTimedOut.
* Bug fix - missing initialization of returned status in otpSize routine.
* Bug fix - read OTP routine when offset != 0
* Bug fix - unique ID is now read with EDC.
*
* Rev 1.43 Jan 29 2002 20:09:40 oris
* Switched arguments sent to docPlusSet.
* Added support for FL_IPL_MODE_XSCALE and changed support for FL_IPL_MODE_SA in writeIPL routine acording to new spec.
* Added sanity check for write IPL modes.
*
* Rev 1.42 Jan 28 2002 21:26:06 oris
* Removed the use of back-slashes in macro definitions.
* 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 , docread, wrBuf and wrSet.
* Removed win_io initialization (one of FLFlash record fields).
* Improved check for flSuspend.
* Added FL_IPL_DOWNLOAD flag to writeIPL routine in order to control whether the IPL will be reloaded after the update.
* Removed wrBuf and wrSet macros.
*
* Rev 1.41 Jan 23 2002 23:33:38 oris
* Bug fix - checkErase routine was unreasonably slow.
* Changed DFORMAT_PRINT syntax
* Bug fix - bad offset of writeIPL routine caused only first 512 bytes to be written.
* Changed readOTP not to use PARTIAL_EDC code.
*
* Rev 1.40 Jan 21 2002 20:45:12 oris
* Compilation errors for MTD_STANDALONE with BDK_VERIFY_WRITE.
* Missing casting causes compilation error in readIPL.
*
* Rev 1.39 Jan 20 2002 20:57:02 oris
* physicalToPointer was called with wrong size argument.
*
* Rev 1.38 Jan 20 2002 20:28:58 oris
* Removed warnings.
* Restored readIPL function initialization.
*
* Rev 1.37 Jan 20 2002 12:12:26 oris
* Removed warnings.
*
* Rev 1.36 Jan 20 2002 10:10:52 oris
* Moved mtdVars to docsoc.c (common with diskonc.c)
* Removed warnings.
* Replaced vol with *flash.
* Removed flPreInitXXXX memory access routines.
* Added new memory access routine implementation.
* Simplified docsys interleave-1 operations (interleave-1 operations use only 1 byte per operation. The if was made in docsys and is now a part of the MTD)
* Bug in implementation of VERIFY_ERASE extra area was fixed.
* Added support for flSuspendMode environment variable.
* Added support for 16MB Plus DiskOnChip :
* - Revised write IPL code
* - Revised read IPL code - now reads from SRAM and not flash causes download of protection logic.
* - OTP / Unique ID offsets were updated to be interleave dependent.
* - readBBT routine was changed to support DiskOnChip Millennium Plus.
* - Identification routine was changed.
* Changed checkStatus with if != flOK
* Added interrupt support under ifdef (ENABLE_EDGE__INTERRUPT / ENABLE_LEVEL__INTERRUPT)
* Changed NO_READ_BBT_CODE ifdef to MTD_READ_BBT.
* Big fix in erasable Block Size Bits field of the flash record when changing interleave.
* Added force remmapping of internal sector buffer.
*
* Rev 1.35 Nov 22 2001 19:48:46 oris
* Power consumption bug fix - chip select to the flash was remained open causing the power down mode to be ignored and the ideal current consumption to be twice the normal current.
* Made sure that when preventing the BUSY# signal to be asserted by the download operation all other bits of the output controll register remain as they were.
*
* Rev 1.34 Nov 21 2001 11:38:14 oris
* Changed FL_WITH_VERIFY_WRITE and FL_WITHOUT_VERIFY_WRITE to FL_ON and FL_OFF.
*
* Rev 1.33 Nov 20 2001 20:25:36 oris
* Bug fix - deep power down mode was released after access due to check of access error.
* Bug fix - download operation did assert the BUSY#.
*
* Rev 1.32 Nov 16 2001 00:23:04 oris
* Restored byte (if_cfg=8) access for reading syndrome registers.
*
* Rev 1.31 Nov 08 2001 10:49:48 oris
* Removed warnings.
* Added run-time control over verify write mode buffers.
*
* Rev 1.30 Oct 18 2001 22:17:22 oris
* Bug fix - incorrect read and write when performed from the middle of the page, incomplete pages , more then 1k when EDC is not requested.
*
* Rev 1.29 Oct 11 2001 23:55:10 oris
* Bug fix - Read operation to the MTD from 2 different pages (for example read operation to BDK with length > 1K) the logic that determined whether to read the last data from the pipeline is incorrect.
*
* 1) When reading with EDC data will be read from the I/O registers and not from the pipeline - This is not a problem, since the pipeline is not necessary.
* 2) When reading without EDC data will be read both from the I/O registers and from the pipeline casing overwriting the last 2 bytes with 0xff.
*
* Rev 1.28 Oct 10 2001 19:48:02 oris
* Bug fix - WORD_ADD_FAR macro was misused using casing bad casting to unaligned buffers. Replaced it with read operation to an intermidiate variable and then copy byte after byte.
*
* Rev 1.27 Sep 24 2001 18:24:08 oris
* Removed warnings.
* Added support for readBBT call for less then 8 bytes.
* Removed DOC_PLUS_ACCESS_TYPE ifdef.
*
* Rev 1.26 Sep 15 2001 23:47:20 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.
* Changed all memory access routine to DiskOnChip Millennium Plus dedicated routines.
* Changed recoverFromAccessError and setAsicMode routine to use standard memory access routines and not preInit routines.
* Bug fix - read\write from uneven address.
* Bug fix - read full 1k with no EDC.
* Bug fix - first 4 blocks are not reported correctly by the readBBT()
* Added debug print when BBT is not read well.
*
* Rev 1.25 Jul 29 2001 19:15:30 oris
* Changed file calls to macros.
*
* Rev 1.24 Jul 13 2001 01:08:08 oris
* Bug fix - rewritten VERIFY_WRITE compilation option.
* Prevent calls to docPlusRead with 0 length.
* Bug fix - added support for platforms that can not access single bytes.
* Added PARTIAL_EDC read flag to the read routine.
* Revised checkErase routine to include extra area.
* Bug fix - missing check of write protection in doc2erase.
* Bug fix - read bbt .
* Insert key before writing IPL since it might be protected with the default protection.
* Bug fix - set floor to 0 in all OTP calls.
* Use PARTIAL_EDC in read OTP routine.
* Added initialization of max erase cycles FLFlash field.
*
* Rev 1.23 Jun 17 2001 16:39:10 oris
* Improved documentation and remove warnings.
*
* Rev 1.22 Jun 17 2001 08:17:52 oris
* Bug fix - caused changing to interleave 1 even if already in this mode.
* Changed NO_READ_BBT_CODE to MTD_NO_READ_BBT_CODE.
*
* Rev 1.21 May 30 2001 21:16:06 oris
* Bug fix - pages per blocks might be used uninitialized.
*
* Rev 1.20 May 17 2001 19:21:10 oris
* Removed warnings.
*
* Rev 1.19 May 16 2001 21:20:34 oris
* Added failsafe mechanism for the download operation.
* Changed code variable name to flCode (avoid name clashes).
* Bug fix - read operation from extra area of second sector of page starting from offset 6 reading more then 2 bytes.
* Bug fix - write OTP and read OTP routines - Wrong usage of buffers.
* Removed warnings.
* Bug fix - enable power down routine while in MTD_STANDALONE mode.
*
* Rev 1.18 May 09 2001 00:33:12 oris
* Changed IPL_CODE to NO_IPL_CODE , READ_BBT_CODE to NO_READ_BBT_CODE.
* Made sure that forceddownload is active when HW_OTP compilation flag is defined.
* Removed 2 redundant ALE down calls.
* Change all 2 consequative read operation to for in order to prevent compiler optimizations.
*
* Rev 1.17 May 06 2001 22:41:52 oris
* Bug fix - checking for access error was moved. After every set address operation and after erase confirm.
* Bug fix - readBBT for unaligned units.
* Removed warnings.
* redundant was misspelled.
*
* Rev 1.16 May 02 2001 07:29:50 oris
* flInterleaveError was misspelled.
* Added the BBT_UNAVAIL_UNIT defintion.
*
* Rev 1.15 May 01 2001 14:22:56 oris
* Bug fix - reading BBT of cascaded device.
*
* Rev 1.14 Apr 30 2001 18:01:54 oris
* Bug fix - Several ifdef caused exception since MTD buffer was not allocated.
* Use erasableBlockSizeBits instead of erasableBlockSize when posible.
* Added EDC check when reading the BBT.
* Removed warrnings.
*
* Rev 1.13 Apr 24 2001 17:11:14 oris
* Bug fix - Wrong data when reading 2 bytes from data area.
* Removed compilation problems when USE_FUNC is defined.
* Bug fix - read\write operation with the EDC flags ignored the EXTRA flag.
* Bug fix - ipl and otp routines causes exception in MTD_STANDALONE mode.
* Rebuild OTP routine.
*
* Rev 1.12 Apr 18 2001 21:24:54 oris
* Bug fix - bad status code when writting in interleave - 1 fails, because changeInterleave routine is called while in access error.
* Bug fix - removed download operation after write IPL.
* Bug fix - Fixed casting problem in flash type identification.
* Bug fix - Bad status code in doc2erase.
* Bug fix - OTP area written\ read in interleave - 1
* Bug fix - bad endian handling in OTP routines.
* Moved forced download routine from under the MTD_STANDALONE compilation flag.
* Removed warrnings.
*
* Rev 1.11 Apr 18 2001 11:17:30 oris
* Bug fix in getUniqueId routine.
*
* Rev 1.10 Apr 18 2001 09:27:38 oris
* Removed warrnings.
*
* Rev 1.9 Apr 16 2001 21:46:58 oris
* Bug fix - aliasing mechanism fixed.
*
* Rev 1.8 Apr 16 2001 13:54:34 oris
* Removed warrnings.
* Bug fix - uninitialized buffer in read operation from uneven address.
* Bug fix - report hw protection fault on write and erase operations.
*
* Rev 1.7 Apr 12 2001 06:52:06 oris
* Added setFloor in chkAsicMode in order to make sure floor does not change.
* Added powerDown routine and registration.
* Added download routine registration.
* Added support for reading and writing uneven address or length.
* Removed warrnings.
* Bug fix for memory lick in readBBT.
* Changed several routines to static.
*
* Rev 1.6 Apr 10 2001 23:55:30 oris
* Bug fix - in readbbt routine buffer was not incremented correctly.
*
* Rev 1.5 Apr 10 2001 16:43:14 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 19:02:34 oris
* Removed unused variables.
* Bug fix on erase operation to more then 1 unit.
* Comment forced download in device identification routine.
*
*/
/*********************************************************************/
/* */
/* FAT-FTL Lite Software Development Kit */
/* Copyright (C) M-Systems Ltd. 1995-2001 */
/* */
/*********************************************************************/
/*********************************************************************
* *
* DESCRIPTION: basic mtd functions for MDOC32 *
* interleave 1 *
* page organization : *
* 512 bytes data sector 0, *
* 6 bytes ecc sector 0, *
* 2 bytes sector 0 flag, *
* 8 bytes unit data sector 0, *
* interleave 2 *
* page organization : *
* 512 bytes data sector 0, *
* 6 bytes ecc sector 0, *
* 2 bytes sector 0 flag, *
* 2 bytes sector 1 flags, *
* 512 bytes data sector 1 , *
* 6 bytes ecc sector 1, *
* 8 bytes unit data sector 0, *
* 8 bytes unit data sector 1 *
* *
* AUTHOR: arie tamam *
* *
* HISTORY: created november 14 2000 *
* *
*********************************************************************/
/*********************************************************************/
/* | Physical address of interleave - 2 page */
/* Area -----------------------------------------------------*/
/* | First Sector | Second Sector */
/*-------------------------------------------------------------------*/
/* Extra: | 512-519, 1040-1047 | 1034-1039, 520-521, 1048-1055 */
/* Sector data | 0-511 | 522-1033 */
/* Sector flags | 518-519 | 520-521 */
/* Unit data | 1040-1047 | 1048-1055 */
/* Edc | 512-517 | 1034-1039 */
/*********************************************************************/
/* Note: The address is given as a page offset 0-n where n is the */
/* number of bytes the area has fo a sector (16 for extra , 2 for */
/* sector flags, 8 for unit data and 512 for sector data). The */
/* second sector address is given in a simmilar fation + 512. */
/* Note: Extra area is exported in the floowing order: */
/* sector data , edc , sector flags , unit data. */
/*********************************************************************/
/* Area A : 0 - 511 | Area B : 512 - 1023 | Area C : 1024 - 1055 */
/*********************************************************************/
/*********************************************************************/
/* Area | Physical address of interleave - 1 page */
/*-------------------------------------------------------------------*/
/* Extra: | 512 - 517 , 518 - 519 , 520 - 527 */
/* Sector data | 0 - 511 */
/* Edc | 512 - 517 */
/* Sector flags | 518 - 519 */
/* Unit data | 520 - 527 */
/*********************************************************************/
/* Note: The address is given as a page offset 0-n where n is the */
/* number of bytes the area has for a sector (16 for extra , 2 for */
/* sector flags, 8 for unit data and 512 for sector data). */
/* Note: Extra area is exported in the floowing order: */
/* sector data , edc , sector flags , unit data. */
/*********************************************************************/
/* Area A : 0 - 255 | Area B : 256 - 511 | Area C : 512 - 528 */
/*********************************************************************/
/** include files **/
#include "mdocplus.h"
#include "reedsol.h"
#ifdef HW_PROTECTION
#include "protectp.h"
#endif /* HW_PROTECTION */
/* Yield CPU time in msecs */
#ifndef YIELD_CPU
#define YIELD_CPU 10
#endif /* YIELD_CPU */
/* maximum waiting time in msecs */
#define MAX_WAIT 30
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(socket) 0 /* currently we support only a single device */
#define flMap(socket,address) addToFarPointer(socket->base, address & (socket->size - 1));
#endif /* MTD_STANDALONE */
#ifndef FL_NO_USE_FUNC
/*----------------------------------------------------------------------*/
/* c h o o s e D e f a u l t I F _ C F G */
/* */
/* Choose the default IF_CFG to use before is can actually be detected */
/* */
/* Parameters: */
/* busConfig : Socket access discriptor */
/* */
/* Returns: */
/* Suspected IF_CFG configuration (either 8 or 16). */
/*----------------------------------------------------------------------*/
static byte chooseDefaultIF_CFG(dword busConfig)
{
if(( busConfig & FL_BUS_HAS_8BIT_ACCESS )&&
((busConfig & FL_XX_ADDR_SHIFT_MASK) == FL_NO_ADDR_SHIFT) )
{
/* Assume if_cfg was set to 0. Interleave is irelevant */
return 8;
}
/* Assume if_cfg was set to 1. Interleave is irelevant */
return 16;
}
/*----------------------------------------------------------------------*/
/* s e t D O C P l u s B u s T y p e */
/* */
/* Check validity and set the proper memory access routines for MTD. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* busConfig : Socket access discriptor */
/* interleave : Interleave factor (1,2) */
/* if_cfg : if_cfg state: */
/* 8 - 8 bit */
/* 16 - 16 bit */
/* */
/* Returns: */
/* TRUE if routines are available and fit the DiskOnChip */
/* configuration otherwise FALSE. */
/* */
/* The variable pointer to by busConfig is added TrueFFS private */
/* MTD descriptors. */
/*----------------------------------------------------------------------*/
static FLBoolean setDOCPlusBusType(FLFlash * flash,
dword busConfig,
byte interleave,
byte if_cfg)
{
switch(interleave)
{
case 1: /* No interleave */
busConfig |= FL_8BIT_FLASH_ACCESS;
break;
case 2: /* 2 flashes are interleaved */
busConfig |= FL_16BIT_FLASH_ACCESS;
break;
default:
DEBUG_PRINT(("ERROR: No such interleave factor (setDOCPlusBusType).\r\n"));
return FALSE;
}
switch(if_cfg)
{
case 8: /* No interleave */
busConfig |= FL_8BIT_DOC_ACCESS;
break;
case 16: /* 2 flashes are interleaved */
busConfig |= FL_16BIT_DOC_ACCESS;
break;
default:
DEBUG_PRINT(("ERROR: Invalid if_cfg value (setDOCPlusBusType).\r\n"));
return FALSE;
}
if(setBusTypeOfFlash(flash, busConfig) != flOK)
return FALSE;
return TRUE;
}
#endif /* FL_NO_USE_FUNC */
#ifndef NO_EDC_MODE
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.*/
/* EDC control */
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>.*/
/*----------------------------------------------------------------------*/
/* e c c E r r o r */
/* */
/* Check for EDC error. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Returns TRUE if an EDC detected an error, otherwise FALSE. */
/*----------------------------------------------------------------------*/
static FLBoolean eccError (FLFlash * flash)
{
register int i;
for(i=0;( i < 2 ); i++)
flWrite8bitRegPlus(flash,NNOPreg, 0);
return ((FLBoolean)flRead8bitRegPlus(flash,NECCcontrol) & ECC_CNTRL_ERROR_MASK);
}
/*----------------------------------------------------------------------*/
/* e c c O F F */
/* */
/* Disable ECC. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/*----------------------------------------------------------------------*/
#define eccOFF(vol) flWrite8bitRegPlus(vol,NECCcontrol,ECC_CNTRL_IGNORE_MASK)
/*----------------------------------------------------------------------*/
/* e c c O N r e a d */
/* */
/* Enable ECC in read mode and reset it. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/*----------------------------------------------------------------------*/
#define eccONread(flash) flWrite8bitRegPlus(flash,NECCcontrol,ECC_RESET); flWrite8bitRegPlus(flash,NECCcontrol,ECC_CNTRL_ECC_EN_MASK)
#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 */
/* */
/*----------------------------------------------------------------------*/
#define eccONwrite(flash) flWrite8bitRegPlus(flash,NECCcontrol,ECC_RESET); flWrite8bitRegPlus(flash,NECCcontrol,ECC_CNTRL_ECC_RW_MASK | ECC_CNTRL_ECC_EN_MASK);
#endif /* FL_READ_ONLY */
#endif /* NO_EDC_MODE */
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
/* Auxiliary methods */
/*<2A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*/
/*----------------------------------------------------------------------*/
/* s e l e c t C h i p */
/* */
/* Write to deviceSelector register. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* wp : FLS_SEL_WP_MASK to write protect the flashes 0 to */
/* remove write protection. */
/* dev : Chip to select.(not used in mdocp). */
/* */
/* NOTE: write protection signal is common for all of the flash devices.*/
/*----------------------------------------------------------------------*/
#define selectChip(flash, writeProtect) flWrite8bitRegPlus(flash,NflashSelect, writeProtect)
/*----------------------------------------------------------------------*/
/* c h k I n t e r l e v e */
/* */
/* Check the current intelreave mode. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Returns: Returns 1 for interleave-1 or 2 interleave-2. */
/*----------------------------------------------------------------------*/
#define chkInterleave(flash) (byte)(((flRead8bitRegPlus(flash,NconfigInput) & CONFIG_INTLV_MASK) == CONFIG_INTLV_MASK) ? 2 : 1)
/*----------------------------------------------------------------------*/
/* c h k I F _ C F G */
/* */
/* Check the current if_cfg mode (number of active DiskOnChip data bits */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Returns: Either 8 or 16. */
/*----------------------------------------------------------------------*/
#define chkIF_CFG(flash) (byte)((flRead8bitRegPlus(flash,NconfigInput) & CONFIG_IF_CFG_MASK) ? 16 : 8)
/*----------------------------------------------------------------------*/
/* s e t I p l S i z e */
/* */
/* Open the extended IPL of cascaded DiskOnChip and return previous */
/* max ID number. */
/* */
/* Note floor 0 resides of offset 0 */
/* floor 1 resides of offset 0x400 */
/* floor 2 resides of offset 0x1800 */
/* floor 3 resides of offset 0x1c00 */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* noOfFloors : Number of floors to open */
/* */
/* */
/* Returns: The previous max ID number. */
/*----------------------------------------------------------------------*/
static byte setIplSize(FLFlash * flash, byte noOfFloors)
{
byte prevMaxId = flRead8bitRegPlus(flash,NconfigInput);
flWrite8bitRegPlus(flash,NconfigInput,(byte)((prevMaxId & (~CONFIG_MAX_ID_MASK))|((noOfFloors-1)<<4)));
return (prevMaxId & CONFIG_MAX_ID_MASK);
}
/*----------------------------------------------------------------------*/
/* g e t C o n t r o l l e r I D */
/* */
/* Get the controller (ASIC) indetification byte from offset 0x1000. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Returns: One of the following values. */
/* CHIP_ID_MDOCP - 0x40 - DiskOnChip Millennium Plus 32MB */
/* CHIP_ID_MDOCP - 0x41 - DiskOnChip Millennium Plus 16MB */
/* other - Unknown DiskOnChip */
/*----------------------------------------------------------------------*/
#define getControllerID(flash) flRead8bitRegPlus(flash,NchipId)
/*----------------------------------------------------------------------*/
/* b u s y */
/* */
/* Pole the selected flash busy signal. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Returns TRUE if the flash is busy, otherwise FALSE. */
/*----------------------------------------------------------------------*/
#define busy(flash) (((flRead8bitRegPlus(flash,NflashControl) & (Reg8bitType)FLS_FR_B_MASK) == FLS_FR_B_MASK) ? FALSE:TRUE)
/*----------------------------------------------------------------------*/
/* 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)
{
volatile Reg8bitType junk = 0;
int i;
/* before polling for BUSY status perform 4 read operations from
NNOPreg */
for(i=0;( i < 4 ); i++ )
junk += flRead8bitRegPlus(flash,NNOPreg);
for(i=0;( i < BUSY_DELAY ); i++)
{
if( busy(flash) )
{
continue; /* it's not ready */
}
return( TRUE ); /* ready at last.. */
}
DEBUG_PRINT(("Debug: timeout error in waitForReady routine.\r\n"));
/* Restore write proection to reduce power consumption */
selectChip(flash,MPLUS_SEL_WP);
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, word 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 */
/*----------------------------------------------------------------------*/
/* s e l e c t F l o o r */
/* */
/* Change the floor according to the given address. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* address : Address of the new floor */
/* */
/* Note - global variable NFDC21thisVars->currentFloor is updated */
/*----------------------------------------------------------------------*/
static void selectFloor (FLFlash * flash, CardAddress address)
{
if( flash->noOfFloors > 1 )
{
NFDC21thisVars->currentFloor = (byte)(address >> NFDC21thisVars->floorSizeBits);
setFloor(flash,NFDC21thisVars->currentFloor); /* select ASIC */
}
}
/*----------------------------------------------------------------------*/
/* r e l e a s e P o w e r D o w n */
/* */
/* Release the controller (ASIC) from power down mode. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Note - While in power down the registers can not be read or written */
/* to. */
/*----------------------------------------------------------------------*/
void releasePowerDown(FLFlash * flash)
{
int i;
volatile Reg8bitType junk = 0;
/* perform 3 reads + 1 from 0x1fff */
for(i = 0;( i < 4 ); i++ )
junk += flRead8bitRegPlus(flash,NreleasePowerDown);
}
/*----------------------------------------------------------------------*/
/* i s A c c e s s E r r o r */
/* */
/* Check if protection violation had accured. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Note - While in protection violation state, the registers can not be */
/* read or written to. */
/* */
/* Returns: TRUE on protection violation, otherwise FALSE. */
/*----------------------------------------------------------------------*/
#define isAccessError(flash) ((flRead8bitRegPlus(flash,NprotectionStatus) & PROTECT_STAT_ACCERR) ? TRUE:FALSE)
/*----------------------------------------------------------------------*/
/* r e c o v e r A c c e s s E r r o r */
/* */
/* Recover from protection violation. */
/* */
/* Note : DiskOnChip must already be in Normal mode. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Note : If the device was indeed in access error the routine will */
/* force the device into reset mode. */
/* */
/* Returns: flOK on success, otherwise flHWProtection. */
/*----------------------------------------------------------------------*/
static FLStatus recoverFromAccessError(FLFlash * flash)
{
int i = 0;
/* Check if there realy is an access error if not return */
if(isAccessError(flash)==FALSE)
return flOK;
/* Folloing is the sequance to remove the protection violation */
/* Write 0xff to the flash command register */
/* Write twice to the write pipeline termination register */
/* Write once to the NOop register */
flWrite8bitRegPlus(flash,NflashCommand,(Reg8bitType)RESET_FLASH);
for(i = 0; i< 2; i++)
flWrite8bitRegPlus(flash,NwritePipeTerm,(Reg8bitType)0);
flWrite8bitRegPlus(flash,NNOPreg,(Reg8bitType)0);
/* Check if access error was removed */
if (flRead8bitRegPlus(flash,NprotectionStatus) & PROTECT_STAT_ACCERR)
{
DEBUG_PRINT(("Can't recover from protection violation\r\n"));
return flHWProtection;
}
return flOK;
}
/*----------------------------------------------------------------------*/
/* s e t A S I C m o d e */
/* */
/* Set the controller (ASIC) operation mode. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* mode : One of the modes below: */
/* DOC_CNTRL_MODE_RESET - Reset mode */
/* DOC_CNTRL_MODE_NORMAL - Normal mode */
/* DOC_CNTRL_MODE_PWR_DWN - Power down mode */
/* */
/* Note: The mode is common to all cascaded floors. */
/* */
/* Returns: flOK on success, otherwise flHWProtection. */
/*----------------------------------------------------------------------*/
static FLStatus setASICmode (FLFlash * flash, Reg8bitType mode)
{
volatile Reg8bitType stat = 0;
/* Get out of power down mode - just in case */
releasePowerDown(flash);
/* Set ASIC state
* Use default bit values to all bits but the last 2 mode bits
* ORed with the given mode. The mode is written to the the
* NDOCcontrol register and its complement to the
* NDOCcontrolConfirm register
*/
stat = DOC_CNTRL_DEFAULT | mode;
flWrite8bitRegPlus(flash,NDOCcontrol,stat); /* the control data */
flWrite8bitRegPlus(flash,NDOCcontrolConfirm, (Reg8bitType)~stat); /* confirm */
if (mode & DOC_CNTRL_MODE_PWR_DWN)
return flOK;
/* Read Controller's (ASIC) modes register */
stat = flRead8bitRegPlus(flash,NDOCcontrol);
/* Check for power down mode */
if (stat & DOC_CNTRL_MODE_NORMAL)
{
/* Check for protection violation */
return recoverFromAccessError(flash);
}
return flOK;
}
/*----------------------------------------------------------------------*/
/* c h k A S I C m o d e */
/* */
/* Check the controller (ASIC) mode and change it to normal. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Note: The mode is common to all cascaded floors. */
/* Note: This routine is called by each of the MTD exported routine. */
/* */
/* Returns: flOK on success, otherwise flHWProtection. */
/*----------------------------------------------------------------------*/
FLStatus chkASICmode (FLFlash * flash)
{
volatile Reg8bitType stat;
FLStatus status = flOK;
stat = flRead8bitRegPlus(flash,NDOCcontrol);
if ((isAccessError(flash) == TRUE) || /* Protection violation */
(!(stat & DOC_CNTRL_MODE_NORMAL))) /* already in normal mode */
{
status = setASICmode(flash,DOC_CNTRL_MODE_NORMAL);
setFloor (flash, NFDC21thisVars->currentFloor);
}
return status;
}
/*----------------------------------------------------------------------*/
/* c h k I P L D o w n l o a d */
/* */
/* Check if IPL was downloaded without an IPL dwonload error. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Returns: TRUE if download was succesfull on both copies. */
/*----------------------------------------------------------------------*/
#define chkIPLDownload(flash) ((flRead8bitRegPlus(flash, NdownloadStatus) & (DWN_STAT_IPL0 | DWN_STAT_IPL1)) ? FALSE : TRUE)
/*----------------------------------------------------------------------*/
/* c h k A S I C D o w n l o a d */
/* */
/* Check if DPS and OTP were downloaded without any error from the */
/* specified floor. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* floor : The floor to check */
/* */
/* Note - The routine changes the controller (ASIC) mode to normal. */
/* */
/* Returns: */
/* FLStatus : 0 on success, flBadDownload on download error */
/* and flHWProtection if controller mode could */
/* not be changed. */
/*----------------------------------------------------------------------*/
static FLStatus chkASICDownload (FLFlash * flash,byte floorNo)
{
FLStatus status;
status = setASICmode(flash, DOC_CNTRL_MODE_NORMAL);
if(status != flOK)
return status;
setFloor(flash,floorNo);
if(flRead8bitRegPlus(flash,NdownloadStatus) & DWN_STAT_DWLD_ERR)
return flBadDownload;
return flOK;
}
/*----------------------------------------------------------------------*/
/* p o w e r D o w n */
/* */
/* Change the device mode to minimal power consumption (but not active) */
/* and back to normal mode. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* state : DEEP_POWER_DOWN flag for entering power down */
/* otherwise return to normal mode. */
/* */
/* Returns: */
/* FLStatus : 0 on success, otherwise fail. */
/*----------------------------------------------------------------------*/
static FLStatus powerDown(FLFlash * flash, word state)
{
if (state & DEEP_POWER_DOWN)
{
return setASICmode (flash, DOC_CNTRL_MODE_PWR_DWN);
}
else
{
return chkASICmode (flash);
}
}
#if (defined(HW_PROTECTION) || !defined(NO_IPL_CODE) || defined (HW_OTP))
/*----------------------------------------------------------------------*/
/* f o r c e D o w n l o a d */
/* */
/* Force download of protection mechanism and IPL code. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Note - The routine changes the controller (ASIC) mode to normal. */
/* */
/* Returns: */
/* FLStatus : 0 on success, flBadDownload on download error */
/* and flHWProtection if controller mode could */
/* not be changed. */
/*----------------------------------------------------------------------*/
static FLStatus forceDownLoad(FLFlash * flash)
{
volatile Reg8bitType val;
register byte i;
dword counter = 0;
FLStatus status;
/* Prevent assertion of the BUSY# signal */
for(i=0;i<flash->noOfFloors;i++)
{
/* Select floor */
setFloor(flash,i);
/* Remove last bit */
val = flRead8bitRegPlus(flash, NoutputControl) & OUT_CNTRL_BSY_DISABLE_MASK;
flWrite8bitRegPlus(flash, NoutputControl, val);
}
/* Force download */
flWrite8bitRegPlus(flash, NfoudaryTest, FOUNDRY_WRITE_ENABLE);
flWrite8bitRegPlus(flash, NfoudaryTest, FOUNDRY_DNLD_MASK);
flDelayMsecs(100);
/* Check that the download is really over. The Device does not
respond while in download state therfore we try to write and
read to a harmless register 10 times assuming if all 10 times
are good then the download is over */
do
{
/* Set device to normal mode */
flWrite8bitRegPlus(flash,NDOCcontrol,DOC_CNTRL_DEFAULT | DOC_CNTRL_MODE_NORMAL);
flWrite8bitRegPlus(flash,NDOCcontrolConfirm,(byte)(~(DOC_CNTRL_DEFAULT | DOC_CNTRL_MODE_NORMAL)));
for (i=0; i<10; i++,counter++) /* must get expecetd result 10 times in a row */
{
val = (i & 1 ? 0x55 : 0xAA) + i; /* generate various data for the test pattern */
flWrite8bitRegPlus(flash,NaliasResolution,(byte)val); /* write the test data */
flWrite8bitRegPlus(flash,NNOPreg,(byte)~val); /* put the complement on the data bus */
if (flRead8bitRegPlus(flash,NaliasResolution) != (byte)val) /* verify test data */
break; /* still downloading so start over */
}
} while ((i < 10) && (counter < DOWNLOAD_BUSY_DELAY)); /* i==10 only when download has completed */
/* Check for download errors on all floors */
for (i=0;i<flash->noOfFloors;i++)
{
status = chkASICDownload(flash,i);
if(status != flOK)
return status;
}
return flOK;
}
#endif /* HW_PROTECTION or !NO_IPL_CODE or HW_OTP */
/*----------------------------------------------------------------------*/
/* c h e c k T o g g l e */
/* */
/* Read the toggle bit twice making sure it toggles. */
/* */
/* 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;
toggle1 = flRead8bitRegPlus(flash,NECCcontrol);
toggle2 = toggle1 ^ flRead8bitRegPlus(flash,NECCcontrol);
if( (toggle2 & ECC_CNTRL_TOGGLE_MASK) == 0 )
{
return FALSE;
}
return TRUE;
}
#ifndef MTD_STANDALONE
/*----------------------------------------------------------------------*/
/* c h e c k W i n F o r D O C P L U S */
/* */
/* Send commands to release MDOCP from power down, reset it and set it */
/* normal mode. Then make sure this is an MDOCP by reading chip ID and */
/* check the toggle bit. */
/* */
/* Parameters: */
/* socketNo : Device number */
/* memWinPtr : Pointer to DiskOnChip window */
/* */
/* Returns: TRUE if this is an MDOCP, otherwise FALSE. */
/*----------------------------------------------------------------------*/
FLBoolean checkWinForDOCPLUS(unsigned socketNo, NDOC2window memWinPtr)
{
register int i;
volatile Reg8bitType junk = 0;
Reg8bitType prevNDOCcontrol, prevNDOCcontrolConfirm;
FLFlash * flash = flFlashOf(socketNo);
/* Initialize socket memory access routine */
flash->win = memWinPtr;
#ifndef FL_NO_USE_FUNC
if(setDOCPlusBusType(flash, flBusConfig[socketNo] , 1,
chooseDefaultIF_CFG(flBusConfig[socketNo])) == FALSE)
return FALSE;
#endif /* FL_NO_USE_FUNC */
/* release from Power Down Mode */
/* perform 3 reads from anywhere + 1 from 0x1fff */
for(i = 0;( i < 4 ); i++ )
junk += flRead8bitRegPlus(flash,NreleasePowerDown);
/* Save memory data before writting it */
prevNDOCcontrol = flRead8bitRegPlus(flash,NDOCcontrol);
prevNDOCcontrolConfirm = flRead8bitRegPlus(flash,NDOCcontrolConfirm);
/* set ASIC to RESET MODE */
junk = DOC_CNTRL_DEFAULT | DOC_CNTRL_MODE_RESET;
flWrite8bitRegPlus(flash,NDOCcontrol,junk); /* the control data */
flWrite8bitRegPlus(flash,NDOCcontrolConfirm,(Reg8bitType)~junk); /* confirm */
/* set ASIC to NORMAL MODE */
junk |= DOC_CNTRL_MODE_NORMAL; /* write normal mode */
flWrite8bitRegPlus(flash,NDOCcontrol,junk); /* the control data */
flWrite8bitRegPlus(flash,NDOCcontrolConfirm,(Reg8bitType)~junk); /* confirm */
/* check if it's MDOCP ID + check the toggle bit */
junk = getControllerID(flash);
if((junk == CHIP_ID_MDOCP) || (junk == CHIP_ID_MDOCP16))
{
#ifndef FL_NO_USE_FUNC
/* Check if_cfg before checking toggle bit */
if(setDOCPlusBusType(flash,flBusConfig[socketNo],1,chkIF_CFG(flash)) == FALSE)
{
setDOCPlusBusType(flash,flBusConfig[socketNo],1,
chooseDefaultIF_CFG(flBusConfig[socketNo]));
}
else
#endif /* FL_NO_USE_FUNC */
{
if(checkToggle(flash))
return TRUE;
}
}
/* If this is not a MDOCP return the previous values */
flWrite8bitRegPlus(flash,NDOCcontrol,prevNDOCcontrol);
flWrite8bitRegPlus(flash,NDOCcontrolConfirm,prevNDOCcontrolConfirm);
return FALSE;
}
#endif /* MTD_STANDALONE */
/*----------------------------------------------------------------------*/
/* 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 Plus */
/* 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
dword winSize;
FLFlash *flash;
FLBoolean stopSearch = FALSE;
volatile Reg8bitType junk = 0;
/* if memory range to search for DiskOnChip window is not specified */
/* assume the standard x86 PC architecture where DiskOnChip Plus appears */
/* in a memory range reserved for BIOS expansions */
if (lowAddress == 0x0L)
{
lowAddress = START_ADR;
highAddress = STOP_ADR;
}
/* Initialize socket memory access routine */
flash = flFlashOf(socketNo);
#ifndef FL_NO_USE_FUNC
if(setDOCPlusBusType(flash, flBusConfig[socketNo], 1,
chooseDefaultIF_CFG(flBusConfig[socketNo])) == FALSE)
return ( 0 );
#endif /* FL_NO_USE_FUNC */
winSize = DOC_WIN;
/* set all possible controllers (ASIC) to RESET MODE */
for(*nextAddress = lowAddress; *nextAddress <= highAddress;
*nextAddress += winSize)
{
flash->win = (NDOC2window)physicalToPointer(*nextAddress,winSize,socketNo);
junk = DOC_CNTRL_DEFAULT | DOC_CNTRL_MODE_RESET;
flWrite8bitRegPlus(flash,NDOCcontrol,junk); /* the control data */
flWrite8bitRegPlus(flash,NDOCcontrolConfirm,(Reg8bitType)~junk); /* confirm */
}
/* current address initialization */
for(*nextAddress = lowAddress ; *nextAddress <= highAddress ;
*nextAddress += winSize)
{
flash->win = (NDOC2window)physicalToPointer(*nextAddress,winSize,socketNo);
/* set controller (ASIC) to NORMAL MODE */
junk = DOC_CNTRL_DEFAULT | DOC_CNTRL_MODE_NORMAL; /* write normal mode */
flWrite8bitRegPlus(flash,NDOCcontrol,junk); /* the control data */
flWrite8bitRegPlus(flash,NDOCcontrolConfirm,(Reg8bitType)~junk); /* confirm */
junk = getControllerID(flash);
if((junk != CHIP_ID_MDOCP) && (junk != CHIP_ID_MDOCP16))
{
if( stopSearch == TRUE ) /* DiskOnChip was found */
break;
else
continue;
}
if( stopSearch == FALSE )
{
/* detect card - identify bit toggles on consequitive reads */
#ifndef FL_NO_USE_FUNC
/* Check if_cfg before checking toggle bit */
if(setDOCPlusBusType(flash,flBusConfig[socketNo],1,chkIF_CFG(flash)) == FALSE)
{
setDOCPlusBusType(flash,flBusConfig[socketNo], 1,
chooseDefaultIF_CFG(flBusConfig[socketNo]));
continue;
}
#endif /* FL_NO_USE_FUNC */
if(checkToggle(flash) == FALSE)
continue;
/* DiskOnChip found, mark alias resolution register */
flWrite8bitRegPlus(flash,NaliasResolution,(Reg8bitType)ALIAS_RESOLUTION);
stopSearch = TRUE;
lowAddress = *nextAddress; /* save DiskOnChip address */
}
else /* DiskOnChip found, continue to skip aliases */
{
/* skip Aliases that have the mark */
if(flRead8bitRegPlus(flash,NaliasResolution) != ALIAS_RESOLUTION)
break;
}
}
if( stopSearch == FALSE ) /* DiskOnChip memory window not found */
return( 0 );
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 : byte address to latch. */
/* */
/*----------------------------------------------------------------------*/
static FLStatus setAddress (FLFlash * flash, CardAddress address)
{
/*
* bits 0..7 stays as are
* bit 8 is thrown away from address
* bits 31..9 -> bits 30..8
*/
address &= NFDC21thisVars->floorSizeMask; /* Convert to floor offset */
address = address >> (flash->interleaving-1); /* Convert to interleaved address */
address = ((address >> 9) << 8) | ((byte)address); /* Remove bit 8 */
/* Send 3 bytes addres */
flWrite8bitRegPlus(flash,NflashAddress,(byte)address);
flWrite8bitRegPlus(flash,NflashAddress,(byte)(address >> 8));
flWrite8bitRegPlus(flash,NflashAddress,(byte)(address >> 16));
/* write twice to pipeline termination register */
flWrite8bitRegPlus(flash,NwritePipeTerm,(Reg8bitType)0);
flWrite8bitRegPlus(flash,NwritePipeTerm,(Reg8bitType)0);
if (waitForReady(flash)==FALSE) /* wait for ready */
return flTimedOut;
if (isAccessError(flash) == TRUE) /* Protection violation */
{
/* Restore write proection to reduce power consumption */
selectChip(flash,MPLUS_SEL_WP);
return flHWProtection;
}
return flOK;
}
/*----------------------------------------------------------------------*/
/* 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)
{
/* write the command to the flash */
flWrite8bitRegPlus(flash,NflashCommand,flCode);
/* write twice to pipline termination register */
flWrite8bitRegPlus(flash,NwritePipeTerm,flCode);
flWrite8bitRegPlus(flash,NwritePipeTerm,flCode);
}
/*----------------------------------------------------------------------*/
/* r d B u f */
/* */
/* Auxiliary routine for reading from flash I\O registers. */
/* It can be data,status or flash ID. */
/* */
/* Note - The read procedure is devided into 3 parts: */
/* 1) pipeline initialization. */
/* 2) read data from aliased I\O registers. */
/* 3) read the last 2 bytes from the last data read register. */
/* Note - Only the last 2 bytes are read from the pipeline (not 4). */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* buf : Buffer to read into. */
/* howmany : Number of bytes to read. */
/* */
/*----------------------------------------------------------------------*/
static void rdBuf (FLFlash * flash, void FAR1 *buf, word howmany)
{
volatile Reg16bitType junkWord = 0;
register int i;
word length = TFFSMAX(0,(Sword)howmany-2);
switch(NFDC21thisVars->if_cfg)
{
case 16: /* Host access type is 16 bit */
switch (flash->interleaving)
{
case 1:
/* Pineline init */
for (i = 0; i < ((howmany == 1) ? 1 : 2); i++)
junkWord = flRead16bitRegPlus(flash, NreadPipeInit);
/* Read data */
if (length > 0) /* Can use only one byte (int1 operation) */
{
docPlusRead(flash->win,NFDC21thisIO,(byte FAR1 *)buf,length);
}
/* Before reading the last data perform dummy read cycles */
for (i=0; i< ((howmany > 1) ? 0 : 2 ); i++)
junkWord = flRead16bitRegPlus(flash, NreadLastData_1);
/* Read last data from last data read registers */
for (i = length ; i < howmany ; i++)
*BYTE_ADD_FAR(buf,i) = flRead8bitRegPlus(flash, NreadLastData_1);
break;
case 2:
/* Pineline init */
for (i=0; i< ((howmany < 4) ? 1 : 2); i++)
junkWord = flRead16bitRegPlus(flash, NreadPipeInit);
/* Read data */
if (length > 0)
{
docPlusRead(flash->win,NFDC21thisIO,(byte FAR1 *)buf,length);
}
/* Before reading the last data perform dummy read cycles */
for (i = 0; i < ((howmany > 3) ? 0 : 2) ; i++)
junkWord = flRead16bitRegPlus(flash, NreadLastData_1);
/* Read last data from last data read registers */
for (i = length ; i < howmany ; i += flash->interleaving)
{
junkWord = flRead16bitRegPlus(flash, NreadLastData_1);
*BYTE_ADD_FAR(buf,i) = ((byte FAR1*)(&junkWord))[0];
*BYTE_ADD_FAR(buf,i+1) = ((byte FAR1*)(&junkWord))[1];
}
}
break;
case 8: /* Host access type is 8 bit */
/* Pineline init */
for (i=0; i< ((howmany >> (flash->interleaving -1)) ==1 ?1:2); i++)
junkWord += flRead8bitRegPlus(flash, NreadPipeInit);
/* Read data */
if (length > 0)
docPlusRead(flash->win,NFDC21thisIO,(byte FAR1 *)buf,length);
/* Before reading the last data perform dummy read cycles */
for (i=0; ( i < ((howmany >> (flash->interleaving -1)) > 1 ?
0 : ((flash->interleaving == 2) ? 4:2)));i++)
junkWord = flRead8bitRegPlus(flash, NreadLastData_1);
/* Read last data from last data read registers */
for (i=length ; i< howmany ; i++)
{
*BYTE_ADD_FAR(buf,i) = flRead8bitRegPlus(flash, NreadLastData_1);
}
break;
}
}
/*----------------------------------------------------------------------*/
/* r d B u f S */
/* */
/* Auxiliary routine for reading from flash I\O registers. */
/* This routine is the pipeline initialization of the full rdBuf func'. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* howmany : Number of bytes to read. */
/* */
/*----------------------------------------------------------------------*/
static void rdBufS (FLFlash * flash, word howmany)
{
volatile Reg16bitType junkWord = 0;
register int i;
switch(NFDC21thisVars->if_cfg)
{
case 16: /* Host access type is 16 bit */
/* Pineline init */
for (i=0; i< ((howmany >> (flash->interleaving -1)) ==1 ?1:2); i++)
junkWord = flRead16bitRegPlus(flash, NreadPipeInit);
break;
case 8: /* Host access type is 8 bit */
/* Pineline init */
for (i=0; i< ((howmany >> (flash->interleaving -1)) ==1 ?1:2); i++)
junkWord += flRead8bitRegPlus(flash, NreadPipeInit);
break;
}
}
/*----------------------------------------------------------------------*/
/* r e a d C o m m a n d */
/* */
/* Issue read command. */
/* */
/* Note - The routine also checks that the controller is in normal mode */
/* , latches the address and waits for the ready signal. */
/* */
/* Parametes: */
/* flash : Pointer identifying drive */
/* cmd : Command to issue (AREA_A, AREA_B or AREA_C). */
/* addr : address to read from. */
/* */
/* Returns: flOK on success, flTimedOut or flHWProtection on failures. */
/*----------------------------------------------------------------------*/
static FLStatus readCommand (FLFlash * flash, CardAddress addr, Reg8bitType cmd)
{
FLStatus status;
selectFloor(flash,addr);
/* Check mode of ASIC and set to NORMAL.*/
status = chkASICmode(flash);
if(status != flOK)
return status;
/* Select the device and remove flash write protection */
selectChip(flash,MPLUS_SEL_CE|MPLUS_SEL_WP);
/* Move flash pointer to respective area of the page */
command (flash, cmd);
/* Latche the address */
status = setAddress (flash, addr);
if(status != flOK)
return status;
/* ALE down */
flWrite8bitRegPlus(flash,NflashControl, 0x0);
/* Write twice to NOP */
flWrite8bitRegPlus(flash,NNOPreg, 0x0);
flWrite8bitRegPlus(flash,NNOPreg, 0x0);
return flOK;
}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*/
/* r e a d S t a t u s */
/* */
/* Read status of selected flash device. */
/* */
/* Note - The status indicated success of write and erase operations. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* */
/* Returns: TRUE for failed status, FALSE for success. */
/*----------------------------------------------------------------------*/
static FLBoolean readStatus (FLFlash * flash)
{
word status;
/* send command to read status */
command(flash,READ_STATUS);
rdBuf(flash, &status,2);
return ((status & 1) ? TRUE:FALSE);
}
/*----------------------------------------------------------------------*/
/* w r i t e C o m m a n d */
/* */
/* Issue write command. */
/* */
/* Note - The routine also checks that the controller is in normal mode */
/* , latches the address and waits for the ready signal. */
/* */
/* Parametes: */
/* flash : Pointer identifying drive */
/* cmd : Command to issue (AREA_A, AREA_B or AREA_C). */
/* addr : address to read from. */
/* */
/* Returns: flOK on success, flTimedOut or flHWProtection on failures. */
/*----------------------------------------------------------------------*/
static FLStatus writeCommand (FLFlash * flash, CardAddress addr, Reg8bitType cmd)
{
FLStatus status;
selectFloor(flash,addr);
/* Check mode of ASIC and set to NORMAL.*/
status = chkASICmode(flash);
if(status != flOK)
return status;
/* Select the device and remove flash write protection */
selectChip(flash,MPLUS_SEL_CE);
/* Prepare flash for write operation */
command (flash, RESET_FLASH); /* Reset flash */
if (waitForReady(flash)==FALSE) /* always wait after flash reset */
return flTimedOut;
/* Move flash pointer to respective area of the page */
flWrite8bitRegPlus(flash,NflashCommand, (Reg8bitType)cmd); /* page area */
command (flash,SERIAL_DATA_INPUT); /* data input stream type */
/* Latche the address */
return setAddress(flash, addr); /* set page pointer */
}
/*----------------------------------------------------------------------*/
/* 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)
{
/* Pipe termination to preceeding write cycle */
flWrite8bitRegPlus(flash,NwritePipeTerm,(byte)0);
flWrite8bitRegPlus(flash,NwritePipeTerm,(byte)0);
command (flash, SETUP_WRITE); /* execute page program */
if (waitForReady(flash)==FALSE) /* wait for ready signal */
return flTimedOut;
if( readStatus(flash) )
{
DEBUG_PRINT(("Debug: NFDC MDOCP write failed.\r\n"));
return( flWriteFault );
}
selectChip(flash,MPLUS_SEL_WP);
return( flOK );
}
#ifndef NO_EDC_MODE
/*----------------------------------------------------------------------*/
/* w r i t e D a t a P l u s E D C */
/* */
/* Write 512 bytes data with edc */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* buffer : Pointer to user buffer to write from */
/* */
/*----------------------------------------------------------------------*/
static void writeDataPlusEDC(FLFlash * flash, const byte FAR1 *buffer)
{
register int i;
static byte syndrom[SYNDROM_BYTES];
eccONwrite(flash); /* ECC ON for write */
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, SECTOR_SIZE); /* user data */
/* clock data thru pipeline prior reading ECC syndrome*/
for(i=0; i<3; i++)
flWrite8bitRegPlus(flash,NNOPreg, 0);
/* read the syndrom bits */
if (NFDC21thisVars->if_cfg == 8)
{
for(i=0; i<SYNDROM_BYTES; i++)
syndrom[i] = flRead8bitRegPlus(flash,(word)(Nsyndrom+i));
}
else
{
for(i=0; i<SYNDROM_BYTES; i+=2)
*(word *)(syndrom + i) = flRead16bitRegPlus(flash,(word)(Nsyndrom+i));
}
#ifdef D2TST
tffscpy(saveSyndromForDumping,syndrom,SYNDROM_BYTES);
#endif
eccOFF(flash); /* ECC OFF */
docPlusWrite(flash->win,NFDC21thisIO,(byte FAR1 *)syndrom,SYNDROM_BYTES);
}
#endif /* NO_EDC_MODE */
#endif /* FL_READ_ONLY */
#ifndef NO_EDC_MODE
/*----------------------------------------------------------------------*/
/* r e a d D a t a P l u s E D C */
/* */
/* Read 512 bytes data with edc */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* buffer : Pointer to user buffer to read into */
/* length : Length to read */
/* modes : With or without second try option */
/* address : Address to read from */
/* cmd : Area command to read from */
/* endhere : Flag indicating if more bytes are needed from */
/* this page. Importent for last byte read operation */
/* */
/* Return: flOK on success, otherwise flDataError. */
/*----------------------------------------------------------------------*/
static FLStatus readDataPlusEDC(FLFlash * flash, const byte FAR1 *buffer,
word length, word modes, CardAddress address,
byte cmd,FLBoolean endHere)
{
byte syndrom[SYNDROM_BYTES];
word unreadBytes = SECTOR_SIZE - length;
volatile word tmp;
FLStatus status;
#ifdef LOG_FILE
FILE *out;
#endif /* LOG_FILE */
/* To avoid page fault, read first and last bytes of the page */
if (length > 0)
{
((byte FAR1 *)buffer)[0] = 0;
((byte FAR1 *)buffer)[length-1] = 0;
}
/* activate ecc mechanism */
eccONread(flash);
/* read the sector data */
docPlusRead(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, length);
/* read syndrom to let it through the ECC unit */
if ((NFDC21thisVars->if_cfg == 16) && (flash->interleaving == 2))
{
/* Partial page read with EDC must let rest of page through
the HW edc mechanism */
for (;unreadBytes > 0;unreadBytes -=2)
{
tmp = flRead16bitRegPlus(flash, NFDC21thisIO);
}
/* read syndrom using 16 bits access */
for (tmp=0; tmp<SYNDROM_BYTES-2; tmp+=2) /* read the 4 syndrome */
*(word *)(syndrom+tmp) = flRead16bitRegPlus(flash, NFDC21thisIO); /* bytes & store them */
/* If this is the last data read from this page read the last 2 bytes
from a dedicated register otherwise from NFDC IO register */
*(word *)(syndrom + SYNDROM_BYTES - 2) = (endHere == TRUE) ?
flRead16bitRegPlus(flash, NreadLastData_1):
flRead16bitRegPlus(flash, NFDC21thisIO);
}
else
{
/* Partial page read with EDC must let rest of page through
the HW edc mechanism */
for (;unreadBytes > 0;unreadBytes--)
{
tmp = flRead8bitRegPlus(flash, NFDC21thisIO);
}
/* read syndrom using 8 bits access */
for (tmp=0; tmp<SYNDROM_BYTES-2; tmp++) /* read the 4 syndrome */
syndrom[tmp] = flRead8bitRegPlus(flash, NFDC21thisIO); /* bytes & store them */
/* If this is the last data read from this page read the last 2 bytes
from a dedicated register */
for (tmp=SYNDROM_BYTES-2;tmp<SYNDROM_BYTES;tmp++)
syndrom[tmp] = flRead8bitRegPlus(flash, (word)(((endHere == TRUE) ?
NreadLastData_1 : NFDC21thisIO)));
}
if( eccError(flash) )
{ /* try to fix ECC error */
#ifdef LOG_FILE
out=FL_FOPEN("EDCerr.txt","a");
FL_FPRINTF(out,"error on address %lx\n",address);
FL_FCLOSE(out);
#endif /* LOG_FILE */
if ( modes & NO_SECOND_TRY ) /* 2nd try */
{
#ifdef LOG_FILE
out=FL_FOPEN("EDCerr.txt","a");
FL_FPRINTF(out,"second read failed as well on address %lx",address);
#endif /* LOG_FILE */
if (NFDC21thisVars->if_cfg != 16)
{
/* read syndrom using 8 bits access */
for(modes=0; modes<SYNDROM_BYTES; modes++)
syndrom[modes] = flRead8bitRegPlus(flash,(word)(Nsyndrom+modes));
}
else
{
/* read syndrom using 16 bits access */
for(modes=0; modes<SYNDROM_BYTES; modes+=2)
*(word *)(syndrom + modes) = flRead16bitRegPlus(flash,(word)(Nsyndrom+modes));
}
tmp = (word)syndrom[0]; /* Swap 1 and 3 words */
syndrom[0] = syndrom[4];
syndrom[4] = (byte)tmp;
tmp = (word)syndrom[1];
syndrom[1] = syndrom[5];
syndrom[5] = (byte)tmp;
if(flCheckAndFixEDC((char FAR1 *)buffer,(char*)syndrom, 1) !=
NO_EDC_ERROR)
{
#ifdef LOG_FILE
FL_FPRINTF(out," Could not be fixed\n");
FL_FCLOSE(out);
#endif /* LOG_FILE */
DEBUG_PRINT(("Debug: EDC error for NFDC MDOCP.\r\n"));
return flDataError;
}
#ifdef LOG_FILE
FL_FPRINTF(out," But is was fixed\n");
FL_FCLOSE(out);
#endif /* LOG_FILE */
}
else /* 1st try - try once more */
{
status = readCommand(flash, address, cmd);
if(status != flOK)
return status;
rdBufS(flash, SECTOR_SIZE);
return readDataPlusEDC(flash,buffer,length,(word)(modes | NO_SECOND_TRY),address,cmd,endHere);
}
}
eccOFF(flash);
return flOK;
}
#endif /* NO_EDC_MODE */
/*----------------------------------------------------------------------*/
/* s e t E x t r a P t r */
/* */
/* Calculate the physical address and page offset according to the */
/* logical address given with an EXTRA mode flag */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* offset : Logical page offset given to the MTD */
/* length : Size to write\read (migh have implication) */
/* */
/* Return: */
/* cmd : Returns the page area. */
/* offset : Physical offset of the page. */
/*----------------------------------------------------------------------*/
/*****************************************************************************/
/* 0-5 | 6-7 | 518-519 |512-517| 8-15 | 520-527 */
/*****************************************************************************/
/* 0-2 | 3 | 4 | 5-7 | 8-11 | 12-15 */
/* edc 0 | sector flag 0 | sector flag 1 | edc 1 | unit data 0 | unit data 1 */
/*****************************************************************************/
/* AREA_B | AREA_C */
/*****************************************************************************/
static void setExtraPtr(FLFlash * flash, word * offset, dword length,
Reg8bitType * cmd)
{
*cmd = AREA_C;
if (*offset >= SECTOR_SIZE) /* Second sector */
{
*offset &= SECTOR_SIZE_MASK; /* sector offset */
if (*offset < EDC_PLUS_SECTOR_FLAGS ) /* not unit data */
{
if ((*offset >= EDC_SIZE) || /* start after edc area */
(*offset + length > EDC_SIZE)) /* or with sector flags */
{
*offset = SECOND_SECTOR_FLAGS_OFFSET; /* sector flags */
*cmd = AREA_B;
}
else /* Only edc of second sector */
{
*offset += END_OF_SECOND_SECTOR_DATA; /* area c + 10 */
}
}
else /* unit data */
{
*offset += UNIT_DATA_OFFSET; /* after first sector unit data (area c) */
}
}
else /* First sector */
{
if (flash->interleaving==2) /* otherwise do not change offset */
{
if (*offset < EDC_PLUS_SECTOR_FLAGS) /* not unit data */
{
*cmd = AREA_B; /* start from edc */
} /* if it is unit data keep offset as is in area c */
else
{
*offset += UNIT_DATA_OFFSET_MINUS_8; /* minus current offset */
}
}
}
}
/*----------------------------------------------------------------------*/
/* s e t S e c t o r D a t a P t r */
/* */
/* Calculate the physical area and offset according to the logical */
/* address given when no area mode flags was given (sector data area). */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* offset : Logical offset send to the MTD */
/* markFlag : True if the sector flags need to be addressed */
/* */
/* Return: */
/* cmd : Returns the page area. */
/* offset : Physical offset of the page. */
/*----------------------------------------------------------------------*/
static void setSectorDataPtr(FLFlash * flash,word * offset,Reg8bitType * cmd,
FLBoolean markFlag)
{
if (*offset >= SECTOR_SIZE) /* second sector */
{
if ((markFlag)&&(*offset == SECTOR_SIZE)) /* write operation */
{
*offset = SECOND_SECTOR_FLAGS_OFFSET; /* Write sector flags first */
*cmd = AREA_B;
return;
}
else
{
*offset += START_OF_SECOND_SECTOR_DATA; /* Start from actual data */
}
}
if (*offset < NFDC21thisVars->pageAreaSize)
{
*cmd = AREA_A;
}
else if (*offset < flash->pageSize)
{
*cmd = AREA_B;
}
else
{
*cmd = AREA_C;
}
*offset &= (NFDC21thisVars->pageAreaSize-1);
}
/*----------------------------------------------------------------------*/
/* r e a d E x t r a A r e a */
/* */
/* Read from the extra area. */
/* */
/* Note - Only the last 2 bytes are read from the pipeline (not 4). */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* address : Physical flash address */
/* buffer : Buffer to write from */
/* length : Size to write */
/* */
/* Return: */
/* FLStatus : 0 on success, otherwise failed. */
/*----------------------------------------------------------------------*/
static FLStatus readExtraArea (FLFlash * flash, dword address,
void FAR1 *buffer, dword length)
{
FLStatus status;
word offset = (word)(address & NFDC21thisVars->pageMask);
word savedOffset = (word)(offset & (SECTOR_SIZE-1));
word readNow;
byte cmd;
/* Arg check */
if (length + savedOffset > 16)
return flBadLength;
/* Calculate page offset and address */
setExtraPtr(flash, &offset, length , &cmd);
address = (address & ~NFDC21thisVars->pageMask) + offset;
/* Set flash to write mode and pointer to repective page ofset */
status = readCommand(flash, address, cmd);
if(status != flOK)
return status;
if (flash->interleaving == 1)
{
readNow = (word)TFFSMIN((word)(TOTAL_EXTRA_AREA - savedOffset), length);
rdBuf (flash, buffer, readNow);
length -= readNow;
}
else
{
if (cmd == AREA_C) /* unit data / second sector edc */
{
if (offset >= EDC_PLUS_SECTOR_FLAGS) /* either sectors unit data */
{
readNow = (word)TFFSMIN((word)(TOTAL_EXTRA_AREA - savedOffset), length);
}
else /* only edc data (already verified in setExtraAreaPtr */
{
readNow = (word)TFFSMIN((word)(EDC_SIZE - savedOffset), length);
}
rdBuf (flash, buffer, readNow);
length -= readNow;
}
else /* first sector edc / both sectors sector flags */
{
if (offset < EDC_PLUS_SECTOR_FLAGS) /* start from first sector */
{
readNow = (word)TFFSMIN((word)(EDC_PLUS_SECTOR_FLAGS - savedOffset), length);
rdBuf (flash, buffer, readNow);
length -= readNow;
if (length > 0) /* continue to sector unit data area */
{
return readExtraArea(flash,address - offset +
EDC_PLUS_SECTOR_FLAGS,
addToFarPointer(buffer,readNow),length);
}
}
else /* Start form sector flags of second sector */
{
/* Switch sector flags to be compatible with interleave 2 */
rdBuf (flash, BYTE_ADD_FAR(buffer,EDC_SIZE - savedOffset), SECTOR_FLAG_SIZE);
length -= SECTOR_FLAG_SIZE;
if (length > 0) /* continue with edc data of second sector */
{
readNow = (EDC_SIZE - savedOffset);
address = address - offset + savedOffset + SECTOR_SIZE;
if (readNow > 0)
{
status = readExtraArea(flash,address,buffer,readNow);
if(status != flOK)
return status;
length -= readNow;
}
if (length > 0) /* continue with unit data of second sector */
{
readNow = (word)TFFSMIN(UNIT_DATA_SIZE, length);
return readExtraArea(flash,address - savedOffset +
UNIT_DATA_SIZE,addToFarPointer(buffer,
EDC_PLUS_SECTOR_FLAGS - savedOffset),readNow);
}
}
}
}
}
selectChip(flash,MPLUS_SEL_WP);
return flOK;
}
/*----------------------------------------------------------------------*/
/* r e a d S e c t o r D a t a */
/* */
/* Read sector data from the page. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* address : Physical flash address */
/* buffer : Buffer to write from */
/* length : Size to write */
/* edc : EDC to add edc after data and write sector flags */
/* */
/* Note: Sector flags area written automaticly as 0x55 , 0x55. */
/* Note: Sector flags are written only if edc is on. */
/* */
/* Note - Only the last 2 bytes are read from the pipeline (not 4). */
/* */
/* Return: */
/* FLStatus : 0 on success, otherwise failed. */
/*----------------------------------------------------------------------*/
static FLStatus readSectorData(FLFlash * flash, CardAddress address,
byte FAR1 *buffer, dword length, word modes)
{
word offset = (word)(address & NFDC21thisVars->pageMask);
word savedOffset = offset;
word lenInPage = (word)TFFSMIN(length, (dword)(flash->pageSize - savedOffset));
word readNow = 0; /* Initialized to remove warrnings */
byte cmd;
FLStatus status;
register int i;
/******************************************************/
/* Loop over pages while reading the proper area data */
/******************************************************/
setSectorDataPtr(flash,&offset , &cmd,0);
address = (address & ~NFDC21thisVars->pageMask) + offset;
while (length > 0)
{
/* Set flash to write mode and pointer to repective page offset */
status = readCommand(flash, address, cmd);
if(status != flOK)
return status;
/* Calculate the bytes neaded to be read from this page */
length -= lenInPage;
/* Send read pipeline init */
rdBufS(flash, lenInPage);
/* Read First sector of page */
if ((cmd == AREA_A) || (flash->interleaving == 1))
{
readNow = (word)TFFSMIN((word)(SECTOR_SIZE - savedOffset), lenInPage);
/* EDC and sector flags 0x5555 are written only if EDC is required.
* and a full 512 bytes area written */
#ifndef NO_EDC_MODE
if ( /* Full 512 bytes + EDC requested */
((readNow == SECTOR_SIZE) && (modes & EDC)) ||
/* Partial page with EDC requested */
((modes == PARTIAL_EDC) && (savedOffset == 0)))
{
status = readDataPlusEDC(flash,buffer,readNow,modes,address,
cmd,(lenInPage == readNow) ? TRUE:FALSE);
if(status != flOK)
return status;
}
else
#endif /* NO_EDC_MODE */
{
/* user data (the last 2 bytes are read from a diffrent register */
word realyReadNow = (word)((lenInPage == readNow) ?
(readNow - 2) : readNow);
docPlusRead(flash->win,NFDC21thisIO,buffer,realyReadNow);
}
lenInPage -= readNow;
}
/* Read Second sector of page */
if ((lenInPage > 0)&&(flash->interleaving==2))
{
if (cmd == AREA_A) /* Started from first sector */
{
byte tmpBuf[10];
#ifndef NO_EDC_MODE
if ((readNow != SECTOR_SIZE) || /* not Full 512 bytes */
!(modes & EDC)) /* or EDC not requesed */
#endif /* NO_EDC_MODE */
{
docPlusRead(flash->win,NFDC21thisIO,tmpBuf, EDC_SIZE); /* skip edc and sector flags */
}
docPlusRead(flash->win,NFDC21thisIO,tmpBuf, SECTOR_FLAG_SIZE<<1); /* skip 2 sector flags */
buffer = BYTE_ADD_FAR(buffer,readNow);
savedOffset = SECTOR_SIZE;
address += (readNow+START_OF_SECOND_SECTOR_DATA);
cmd = AREA_B;
}
readNow = lenInPage;
#ifndef NO_EDC_MODE
if ( /* Full 512 bytes + EDC requested */
((readNow == SECTOR_SIZE) && (modes & EDC)) ||
/* Partial page with EDC requested */
((savedOffset == SECTOR_SIZE) && (modes & PARTIAL_EDC)) )
{
status = readDataPlusEDC(flash,buffer,readNow,modes,address,
cmd,(lenInPage == readNow) ? TRUE:FALSE);
if(status != flOK)
return status;
}
else
#endif /* NO_EDC_MODE */
{
/* user data (the last 2 bytes are read from a diffrent register */
docPlusRead(flash->win,NFDC21thisIO,buffer, (word)((lenInPage == readNow) ?
(readNow - 2) : readNow));
}
}
#ifndef NO_EDC_MODE
/* If no EDC, Read last data from dedicated register */
if (((modes & EDC) == 0) || /* EDC not requesed */
((readNow != SECTOR_SIZE) && /* not Full 512 bytes */
((modes & PARTIAL_EDC) == 0))) /* And not PARTIAL page EDC */
#endif /* NO_EDC_MODE */
{
if ((NFDC21thisVars->if_cfg == 16) && (flash->interleaving == 2))
{
volatile Reg16bitType junkWord;
/* Before reading the last data perform dummy read cycles */
for (i=0; i< ((readNow >> (flash->interleaving -1)) > 1 ?0:2); i++)
offset = flRead16bitRegPlus(flash, NreadLastData_1); /* junk */
/* Now read the data from the last data read register make
sure not to cast pointer to word since it might not be
word aligned */
junkWord = flRead16bitRegPlus(flash, NreadLastData_1);
*BYTE_ADD_FAR(buffer,readNow-2) = ((byte FAR1*)(&junkWord))[0];
*BYTE_ADD_FAR(buffer,readNow-1) = ((byte FAR1*)(&junkWord))[1];
}
else
{
/* Before reading the last data perform dummy read cycles */
for (i=0; ( i < ((readNow >> (flash->interleaving -1)) > 1 ?
0 : ((flash->interleaving == 2) ? 4:2)));i++)
cmd = flRead8bitRegPlus(flash, NreadLastData_1); /* junk */
/* Now read the data from the last data read register */
for (i=2;i>0;i--)
{
*BYTE_ADD_FAR(buffer,readNow-i) = flRead8bitRegPlus(flash, NreadLastData_1);
}
}
}
/* Calculate next address and page offset */
if (length > 0)
{
buffer = BYTE_ADD_FAR(buffer,readNow);
address = (address & (~NFDC21thisVars->pageMask)) + flash->pageSize;
lenInPage = (word)TFFSMIN(length,flash->pageSize);
savedOffset = 0;
cmd = AREA_A;
}
selectChip(flash,MPLUS_SEL_WP);
}
return flOK;
}
/*----------------------------------------------------------------------*/
/* 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. */
/* */
/* Note - address + length must reside inside media. */
/* Note - global variables changed: */
/* global variable NFDC21thisVars->currentFloor is updated */
/* flash->socket.window.currentPage = pageToMap; */
/* flash->socket.remapped = TRUE; */
/* */
/* Note - PARTIAL_EDC mode must not be called with an uneven number of */
/* bytes. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* address : Address of sector to write to. */
/* buffer : buffer to write from. */
/* length : number of bytes to write. */
/* modes : EDC / EXTRA flags. */
/* */
/* Returns: */
/* FLStatus : 0 on success, otherwise failed. */
/*----------------------------------------------------------------------*/
static FLStatus doc2Read(FLFlash * flash, CardAddress address,
void FAR1 *buffer, dword length, word modes)
{
FLStatus status;
byte align[2];
#ifdef ENVIRONMENT_VARS
if((flSuspendMode & FL_SUSPEND_IO) == FL_SUSPEND_IO)
return flIOCommandBlocked;
#endif /* ENVIRONMENT_VARS */
if (address & 1) /* Start from uneven address */
{
status = doc2Read(flash,address-1,align,2,0);
if(status != flOK)
return status;
*(byte FAR1*)buffer = align[1];
buffer = BYTE_ADD_FAR(buffer,1);
address++;
length--;
}
if (length & 1) /* Read an uneven length */
{
length--;
status = doc2Read(flash,address+length,align,2,modes);
if(status != flOK)
return status;
*BYTE_ADD_FAR(buffer,length) = align[0];
}
if(modes & EXTRA) /* EXTRA AREA */
{
return readExtraArea(flash,address, buffer , length);
}
else
{
return readSectorData(flash,address, (byte FAR1 *)buffer, length , modes);
}
}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*/
/* w r i t e E x t r a A r e a */
/* */
/* Write to the extra area. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* address : Physical flash address */
/* buffer : Buffer to write from */
/* length : Size to write */
/* */
/* Return: */
/* FLStatus : 0 on success, otherwise failed. */
/*----------------------------------------------------------------------*/
static FLStatus writeExtraArea (FLFlash * flash, dword address,
const void FAR1 *buffer, dword length)
{
word offset = (word)(address & NFDC21thisVars->pageMask);
word savedOffset = (word)(offset & (SECTOR_SIZE-1));
word writeNow = 0;
FLStatus status;
byte sectorFlags [2];
byte cmd;
/* Calculate page offset */
setExtraPtr(flash, &offset, length , &cmd);
address = (address & ~NFDC21thisVars->pageMask) + offset;
/* Set flash to write mode and pointer to repective page ofset */
status = writeCommand(flash, address, cmd);
if(status != flOK)
return status;
if (flash->interleaving == 1)
{
writeNow = (word)TFFSMIN((byte)(TOTAL_EXTRA_AREA - savedOffset), length);
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, writeNow);
length -= writeNow;
}
else
{
if (cmd == AREA_C) /* unit data / second sector edc */
{
if (offset >= EDC_PLUS_SECTOR_FLAGS) /* either sectors unit data */
{
writeNow = (word)TFFSMIN((byte)(TOTAL_EXTRA_AREA - savedOffset), length);
}
else /* only edc data (already verified in setExtraAreaPtr */
{
writeNow = (word)TFFSMIN((byte)(EDC_PLUS_SECTOR_FLAGS - savedOffset), length);
}
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, writeNow);
length -= writeNow;
}
else /* first sector edc + both sectors sector flags */
{
if (offset < EDC_PLUS_SECTOR_FLAGS)
{
/* start from first sector edc and sector flags */
writeNow = (word)TFFSMIN((byte)(EDC_PLUS_SECTOR_FLAGS - savedOffset), length);
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, writeNow);
length -= writeNow;
if (length > 0) /* continue to sector unit data area */
{
buffer = addToFarPointer(buffer,writeNow);
/* skip second sector to reach the unit data area */
docPlusSet(flash->win,NFDC21thisIO,SECTOR_SIZE+EDC_PLUS_SECTOR_FLAGS,0xff);
/* unit data */
writeNow = (word)TFFSMIN(UNIT_DATA_SIZE , length);
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, writeNow);
length -= writeNow;
}
}
else /* Start form sector flags of second sector */
{
/* Switch sector flags to be compatible with interleave 2 */
sectorFlags[0] = *BYTE_ADD_FAR(buffer,6 - savedOffset);
sectorFlags[1] = *BYTE_ADD_FAR(buffer,7 - savedOffset);
#ifndef NT5PORT
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)&sectorFlags, SECTOR_FLAG_SIZE);
#else /*NT5PORT*/
docPlusWrite(flash->win,NFDC21thisIO, sectorFlags, SECTOR_FLAG_SIZE);
#endif /*NT5PORT*/
length -= SECTOR_FLAG_SIZE;
if (length > 0) /* continue with edc data of second sector */
{
docPlusSet (flash->win,NFDC21thisIO, (word)(SECTOR_SIZE + savedOffset), 0xff); /* skip second sector data */
/* + offset in edc */
writeNow = EDC_SIZE - savedOffset;
docPlusWrite(flash->win, NFDC21thisIO, (byte FAR1 *)buffer, writeNow);
length -= writeNow;
if (length > 0) /* continue with unit data of second sector */
{
buffer = addToFarPointer(buffer,writeNow+SECTOR_FLAG_SIZE);
docPlusSet (flash->win, NFDC21thisIO, UNIT_DATA_SIZE, 0xff); /* skip second sector unit data */
writeNow = (word)TFFSMIN(UNIT_DATA_SIZE, length);
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, writeNow);
length -= writeNow;
}
}
}
}
}
/* Exit nicly */
if (length > 0 )
{
return flBadLength;
}
else /* Commit data to flash */
{
return writeExecute (flash);
}
}
/*----------------------------------------------------------------------*/
/* w r i t e S e c t o r D a t a */
/* */
/* Write sector data of the page. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* address : Physical flash address */
/* buffer : Buffer to write from */
/* length : Size to write */
/* edc : EDC to add edc after data and write sector flags */
/* */
/* Return: */
/* FLStatus : 0 on success, otherwise failed. */
/*----------------------------------------------------------------------*/
static FLStatus writeSectorData(FLFlash * flash, CardAddress address,
const byte FAR1 *buffer, dword length,
unsigned edc)
{
static byte anandMark[2] = { 0x55, 0x55 };
FLStatus status;
word offset = (word)(address & NFDC21thisVars->pageMask);
word savedOffset = offset;
word writeNow = 0; /* Initialized to remove warrnings */
byte cmd;
/*******************************************************/
/* Loop over pages while writting the proper area data */
/*******************************************************/
setSectorDataPtr(flash,&offset , &cmd, ((edc & EDC) &&
(length >= SECTOR_SIZE)) ? TRUE:FALSE);
address = (address & ~NFDC21thisVars->pageMask) + offset;
while (length > 0)
{
/* Set flash to write mode and pointer to repective page ofset */
status = writeCommand(flash, address, cmd);
if(status != flOK)
return status;
/* Write First sector of page */
if ((cmd == AREA_A)||(flash->interleaving==1))
{
writeNow = (word)TFFSMIN((word)(SECTOR_SIZE - savedOffset), length);
length -= writeNow;
/* EDC and sector flags 0x5555 are written only if EDC is required.
* and a full 512 bytes area written */
#ifndef NO_EDC_MODE
if ((writeNow == SECTOR_SIZE) && /* Full 512 bytes */
(edc == EDC)) /* And EDC is requesed */
{
writeDataPlusEDC(flash,buffer);
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)anandMark, sizeof(anandMark)); /* sector used */
}
else
#endif /* NO_EDC_MODE */
{
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, writeNow); /* user data */
}
}
/* Write Second sector of page */
if ((length > 0)&&(flash->interleaving==2))
{
/* Skip to begining of sector */
if (cmd == AREA_A) /* Started from first sector */
{
#ifndef NO_EDC_MODE
if ((writeNow != SECTOR_SIZE) || /* not Full 512 bytes */
(edc != EDC)) /* or EDC not requesed */
#endif /* NO_EDC_MODE */
{
docPlusSet (flash->win, NFDC21thisIO, EDC_PLUS_SECTOR_FLAGS, 0xff); /* skip edc and sector flags */
}
buffer = BYTE_ADD_FAR(buffer,writeNow);
savedOffset = SECTOR_SIZE;
}
/* Read sector data */
writeNow = (word)TFFSMIN((word)(flash->pageSize - savedOffset) , length);
#ifndef NO_EDC_MODE
if ((writeNow == SECTOR_SIZE) && /* Full 512 bytes */
(edc == EDC)) /* And EDC is requesed */
{
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)anandMark, sizeof(anandMark)); /* sector used */
writeDataPlusEDC(flash,buffer);
}
else
#endif /* NO_EDC_MODE */
{
if ((savedOffset == SECTOR_SIZE)&&(cmd==AREA_A))
docPlusSet(flash->win, NFDC21thisIO,sizeof(anandMark),0xff); /* Skip sector flags */
docPlusWrite(flash->win,NFDC21thisIO, (byte FAR1 *)buffer, writeNow); /* user data */
}
length -= writeNow;
}
/* Incremeant buffer and address */
buffer = BYTE_ADD_FAR(buffer,writeNow);
address = (address & (~NFDC21thisVars->pageMask)) + flash->pageSize;
savedOffset = 0;
cmd = AREA_A;
/* Commit operation */
status = writeExecute(flash);
if(status != flOK)
return status;
}
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. */
/* */
/* Note - address + length must reside inside media. */
/* Note - global variables changed: */
/* global variable NFDC21thisVars->currentFloor is updated */
/* flash->socket.window.currentPage = pageToMap; */
/* flash->socket.remapped = TRUE; */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* address : Address of sector to write to. */
/* buffer : buffer to write from. */
/* length : number of bytes to write. */
/* modes : EDC flags. */
/* */
/* Returns: */
/* FLStatus : 0 on success, otherwise failed. */
/*----------------------------------------------------------------------*/
static FLStatus doc2Write(FLFlash * flash, CardAddress address,
const void FAR1 *buffer, dword length, word modes)
{
FLStatus status;
byte align[2];
#ifdef ENVIRONMENT_VARS
if(flSuspendMode & FL_SUSPEND_WRITE)
return flIOCommandBlocked;
#endif /* ENVIRONMENT_VARS */
#ifndef MTD_STANDALONE
/* Check if socket is software write protected */
if (flWriteProtected(flash->socket))
return( flWriteProtect );
#endif /* MTD_STANDALONE */
if (address & 1) /* Start from uneven address */
{
align[1] = *(byte FAR1*)buffer;
align[0] = 0xff;
#ifdef VERIFY_WRITE
if (modes & EXTRA) /* EXTRA AREA */
{
status = writeExtraArea(flash,address-1, align , 2);
}
else
{
status = writeSectorData(flash,address-1,
(const byte FAR1 *)align,2,modes);
}
if(status != flOK)
{
/* Restore flash write protection */
selectChip(flash,MPLUS_SEL_WP); /* write protect all chips */
}
checkStatus(doc2Read(flash,address-1,align,2,modes));
if(align[1] != *(byte FAR1*)buffer)
{
DEBUG_PRINT(("reading back data failure of first unaligned byte\r\n"));
return flWriteFault;
}
#else
checkStatus(doc2Write(flash,address-1,align,2,modes));
#endif /* VERIFY_WRITE */
buffer = BYTE_ADD_FAR(buffer,1);
address++;
length--;
}
if (length & 1) /* Write an uneven length */
{
length--;
align[0] = *BYTE_ADD_FAR(buffer,length);
align[1] = 0xff;
#ifdef VERIFY_WRITE
if (modes & EXTRA) /* EXTRA AREA */
{
status = writeExtraArea(flash,address+length, align , 2);
}
else
{
status = writeSectorData(flash,address+length,
(const byte FAR1 *)align,2,modes);
}
if(status != flOK)
{
/* Restore flash write protection */
selectChip(flash,MPLUS_SEL_WP); /* write protect all chips */
}
checkStatus(doc2Read(flash,address+length,align,2,modes));
if(align[0] != *BYTE_ADD_FAR(buffer,length))
{
DEBUG_PRINT(("reading back data failure of last unaligned byte\r\n"));
return flWriteFault;
}
#else
checkStatus(doc2Write(flash,address+length,align,2,modes));
#endif /* VERIFY_WRITE */
}
if (modes & EXTRA) /* EXTRA AREA */
{
status = writeExtraArea(flash,address, buffer , length);
}
else
{
status = writeSectorData(flash,address, (const byte FAR1 *)buffer, length , modes);
}
/* Restore flash write protection */
selectChip(flash,MPLUS_SEL_WP); /* write protect all chips */
#ifdef VERIFY_WRITE
/* Read back after write and verify */
if(
#ifndef MTD_STANDALONE
(flash->socket->verifyWrite==FL_ON) &&
#endif /* MTD_STANDALONE */
(status==flOK) )
{
word curRead = 0;
void FAR1* bufPtr = (void FAR1*)buffer;
for (;length > 0;length -= curRead,
bufPtr = BYTE_ADD_FAR(bufPtr,curRead),address+=curRead)
{
curRead = (word)TFFSMIN(length , READ_BACK_BUFFER_SIZE);
status = doc2Read(flash,address,NFDC21thisVars->readBackBuffer,curRead,modes);
if ((status != flOK) ||
(tffscmp(bufPtr,NFDC21thisVars->readBackBuffer,curRead)))
{
DEBUG_PRINT(("reading back data failure\r\n"));
return flWriteFault;
}
}
}
#endif /* VERIFY_WRITE */
return status;
}
#ifdef VERIFY_ERASE
/*----------------------------------------------------------------------*/
/* c h e c k E r a s e */
/* */
/* Check if media is truly erased (main areas of page only). */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* address : Address of page to check. */
/* */
/* Note - global variables changed at doc2Read: */
/* global variable NFDC21thisVars->currentFloor is updated */
/* flash->socket.window.currentPage = pageToMap; */
/* flash->socket.remapped = TRUE; */
/* */
/* 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++)
{
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 */
/*----------------------------------------------------------------------*/
/* 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. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive */
/* blockNo : First block to erase. */
/* blocksToErase : Number of blocks to erase. */
/* */
/* Note - The amount of blocks to erase must be inside media. */
/* Note - global variables changed at checkErase: */
/* global variable NFDC21thisVars->currentFloor is updated */
/* flash->socket.window.currentPage = pageToMap */
/* flash->socket.remapped = TRUE */
/* */
/* Returns: */
/* FLStatus : 0 on success, otherwise failed. */
/*----------------------------------------------------------------------*/
static FLStatus doc2Erase(FLFlash * flash, word blockNo, word blocksToErase)
{
CardAddress startAddress = (CardAddress)blockNo * flash->erasableBlockSize;
FLStatus status;
dword pageNo;
byte floorToUse = (byte)(startAddress / NFDC21thisVars->floorSize);
dword i;
word nextFloorBlockNo = (word) (((floorToUse + 1) *
NFDC21thisVars->floorSize) / flash->erasableBlockSize);
#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 */
/* Arg check (out of media) */
if( blockNo + blocksToErase > NFDC21thisVars->noOfBlocks * flash->noOfChips)
return( flWriteFault );
/* First erase higher floors units */
if( blockNo + blocksToErase > nextFloorBlockNo )
{ /* erase on higher floors */
status = doc2Erase(flash, nextFloorBlockNo,(word)(blocksToErase -
(nextFloorBlockNo - blockNo)));
if(status != flOK)
return status;
blocksToErase = nextFloorBlockNo - blockNo;
}
/* Selet Floor */
selectFloor(flash,startAddress);
pageNo = ((dword)(blockNo % (4096 >> flash->interleaving)) * NFDC21thisVars->pagesPerBlock);
for (i = 0; (word)i < blocksToErase ; i++, pageNo+=NFDC21thisVars->pagesPerBlock)
{
/* Make sure Asic is in normal mode */
status = chkASICmode(flash);
if(status != flOK)
return status;
/* Select chip and remove write protection */
selectChip(flash,MPLUS_SEL_CE);
command (flash,RESET_FLASH); /* reset flashes */
if (waitForReady(flash)==FALSE) /* wait for ready signal */
return flTimedOut;
/* enable EDGE or LEVEL MDOC+ interrupt before the erase command */
#ifdef ENABLE_EDGE_INTERRUPT
/* enable interrupt: EDGE, clear previous interrupt, FREADY source */
flWrite8bitRegPlus(flash,NinterruptControl ,
(INTR_EDGE_MASK | INTR_IRQ_P_MASK | INTR_IRQ_F_MASK | 0x1));
#else
#ifdef ENABLE_LEVEL_INTERRUPT
/* enable interrupt: LEVEL, clear previous interrupt, FREADY source */
flWrite8bitRegPlus(flash,NinterruptControl ,
(INTR_IRQ_P_MASK | INTR_IRQ_F_MASK | 0x1));
#endif /* ENABLE_LEVEL_INTERRUPT */
#endif /* ENABLE_EDGE_INTERRUPT */
command (flash,SETUP_ERASE); /* send erase command */
/* Set address */
flWrite8bitRegPlus(flash,NflashAddress,(Reg8bitType)(pageNo));
flWrite8bitRegPlus(flash,NflashAddress,(Reg8bitType)(pageNo >> 8));
flWrite8bitRegPlus(flash,NwritePipeTerm,(Reg8bitType)0);
flWrite8bitRegPlus(flash,NwritePipeTerm,(Reg8bitType)0);
/* send the confirm erase command */
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 */
{
if (waitForReady(flash)==FALSE) /* wait for ready signal */
return flTimedOut;
}
if(isAccessError(flash))
{
/* Restore write proection to reduce power consumption */
selectChip(flash,MPLUS_SEL_WP);
return flHWProtection;
}
/* Validate erase command status */
if ( readStatus(flash) ) /* erase operation failed */
{
DEBUG_PRINT(("Debug: doc2Erase - erase failed.\r\n"));
/* reset flash device write protect them and abort */
command(flash, RESET_FLASH);
if (waitForReady(flash)==FALSE) /* wait for ready signal */
return flTimedOut;
selectChip(flash,MPLUS_SEL_WP);
return flWriteFault;
}
/* no failure reported */
#ifdef VERIFY_ERASE
if ( checkErase( flash, startAddress ) != flOK )
{
DEBUG_PRINT(("Debug: doc2Erase- erase failed in verification.\r\n"));
return flWriteFault ;
}
#else
/* Restore write proection */
selectChip(flash,MPLUS_SEL_WP);
#endif /* VERIFY_ERASE */
}
return flOK;
}
#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. */
/* */
/* Note - Size must not be greater then 512 bytes */
/* */
/* 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 : Ignored, irelevant for DiskOnChip Millennium Plus */
/* */
/* 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 */
/*----------------------------------------------------------------------*/
/* BBT format (in interleave-1) */
/* ---------- */
/* Offset 512 of the floor holds the BBT of the entire floor in the */
/* following format: */
/* (even district) (odd district) */
/* byte 0 bit 0,1 block 0 block 1024 */
/* bit 2,3 block 1 block 1025 */
/* bit 4,5 block 2 block 1026 */
/* bit 6,7 block 3 block 1027 */
/* byte 1 bit 0,1 block 4 block 1028 */
/* bit 2,3 block 5 block 1029 */
/* bit 4,5 block 6 block 1030 */
/* bit 6,7 block 7 block 1031 */
/* and so on. The data is protected by EDC. */
/*----------------------------------------------------------------------*/
static FLStatus readBBT(FLFlash * flash, dword unitNo, dword unitsToRead,
byte blockMultiplier, byte FAR1 * buffer,
FLBoolean reconstruct)
{
register Sword i;
FLStatus status;
byte tmp;
dword addr;
Sdword bufPtr = unitsToRead - 1; /* Point to last byte of user buffer */
word bytesPerFloor;
byte firstBlocks;
byte smallBBT[8];
dword start;
dword last;
word length;
byte FAR1* tmpBuffer;
CardAddress floorInc; /* floor address incrementor */
word actualRead;
dword alignAddr;
word curRead; /* Number of bytes to read from this floor BBT */
/* Interleave-2 has 2 block entries for each combined block. This variable */
/* is used to shift the bbt size. 0 for int-1 1 for int-2 */
dword shift = (flash->interleaving - 1);
/* Arg sanity check */
if ((((unitNo + unitsToRead) << blockMultiplier) <<
flash->erasableBlockSizeBits) > (flash->noOfChips * flash->chipSize))
return flBadParameter; /* Too many blocks */
if (unitsToRead == 0) /* No blocks at all */
return flOK;
if(unitsToRead < 8) /* Algorithm does not fit */
{
status = readBBT(flash,unitNo,8,blockMultiplier,smallBBT,FALSE);
tffscpy(buffer,smallBBT,unitsToRead);
return status;
}
#ifndef MTD_STANDALONE
/* Force remapping of internal catched sector */
flash->socket->remapped = TRUE;
#endif /* MTD_STANDALONE */
bytesPerFloor = (word)(NFDC21thisVars->floorSize >>
flash->erasableBlockSizeBits) >>
((flash->mediaType == MDOCP_TYPE) ? 1 : 2);
if(blockMultiplier == 0) /* 2 blocks per byte */
{
/* Calculate the first and last bytes of BBT to read. There area 4
interleave-1 blocks per byte, so interleave-2 has 4 blocks per 2
bytes */
start = ((unitNo >> 2)<<shift); /* in bytes */
last = (((unitNo+unitsToRead-1) >> 2)<<shift); /* in bytes */
length = (word)(last - start + flash->interleaving); /* in bytes */
tmpBuffer = buffer; /* bbt buffer pointer */
for (floorInc = (start / bytesPerFloor) * NFDC21thisVars->floorSize +
BBT_MEDIA_OFFSET, last = (dword) length,
start = start % bytesPerFloor; last > 0 ;
floorInc += NFDC21thisVars->floorSize)
{
curRead = (word)TFFSMIN(bytesPerFloor - start,last);
last -= curRead; /* bytes left to read */
alignAddr = (start >> SECTOR_SIZE_BITS)<<SECTOR_SIZE_BITS;
/* Not in Millennium plus but there might be 1024 BBT bytes
per floor */
for ( ;curRead > 0 ; alignAddr+=SECTOR_SIZE,start = 0)
{
if (doc2Read(flash,alignAddr + floorInc, NFDC21thisBuffer,
SECTOR_SIZE , EDC) != flOK)
{
DEBUG_PRINT(("Debug: Error reading DiskOnChip Millennium Plus BBT.\r\n"));
return flBadBBT;
}
actualRead = (word)TFFSMIN((word)(SECTOR_SIZE - start),curRead);
tffscpy(tmpBuffer,NFDC21thisBuffer + start, actualRead);
tmpBuffer = BYTE_ADD_FAR(tmpBuffer,actualRead); /* increament buffer */
curRead -= actualRead;
}
}
/* Convert last byte if only some of the blocks represented by it
are needed and if it is not the only byte read */
/* Save first the first byte - 1 for int-1 2 for int-2 */
if(shift)
{
firstBlocks = buffer[0] & buffer[1];
/* Convert last 2 bytes */
tmp = (*BYTE_ADD_FAR(buffer,length-1)) & /* lower lane */
(*BYTE_ADD_FAR(buffer,length-2)); /* higher lane */
}
else
{
firstBlocks = buffer[0];
/* Convert last bytes */
tmp = *BYTE_ADD_FAR(buffer,length-1);
}
switch ((unitNo+unitsToRead) & 3) /* Last block number byte offset */
{
case 3:
*BYTE_ADD_FAR(buffer,bufPtr) = tmp | 0xCF;
bufPtr--;
case 2:
*BYTE_ADD_FAR(buffer,bufPtr) = tmp | 0xF3;
bufPtr--;
case 1:
*BYTE_ADD_FAR(buffer,bufPtr) = tmp | 0xFC;
bufPtr--;
length -= 2; /* Point to last bbt byte */
default:
break;
}
/* Convert all aligned blocks */
while (bufPtr > flash->interleaving)
{
if(shift)
{
tmp = (*BYTE_ADD_FAR(buffer,length-1)) & /* lower lane */
(*BYTE_ADD_FAR(buffer,length-2)); /* higher lane */
}
else
{
tmp = *BYTE_ADD_FAR(buffer,length-1);
}
*BYTE_ADD_FAR(buffer,bufPtr ) = tmp | 0x3f;
*BYTE_ADD_FAR(buffer,bufPtr-1) = tmp | 0xcf;
*BYTE_ADD_FAR(buffer,bufPtr-2) = tmp | 0xf3;
*BYTE_ADD_FAR(buffer,bufPtr-3) = tmp | 0xfc;
bufPtr -= 4;
length -= flash->interleaving;
}
/* Convert first unaligned blocks (0,1,2) */
bufPtr=0;
switch(unitNo & 3)
{
case 1:
*BYTE_ADD_FAR(buffer,bufPtr) = firstBlocks | 0xF3;
bufPtr++;
case 2:
*BYTE_ADD_FAR(buffer,bufPtr) = firstBlocks | 0xCF;
bufPtr++;
case 3:
*BYTE_ADD_FAR(buffer,bufPtr) = firstBlocks | 0x3F;
default:
break;
}
/* Mark all bad blocks with 0 */
for (bufPtr=0;bufPtr<(Sdword)unitsToRead;bufPtr++)
{
if (*BYTE_ADD_FAR(buffer,bufPtr) != BBT_GOOD_UNIT)
{
*BYTE_ADD_FAR(buffer,bufPtr) = 0;
}
}
/* Add OTP and 2 DPS for all floors */
for (tmp=0,addr=0;tmp<flash->noOfFloors;tmp++,addr=tmp<<10)
{
for (i=0;i<((shift) ? 3 : 5);i++) /* reserved units */
if ((addr+i >= unitNo)&&(addr+i <= unitNo+unitsToRead))
*BYTE_ADD_FAR(buffer,addr+i-unitNo) = BBT_UNAVAIL_UNIT;
}
}
else /* several blocks per unit */
{
return flBadBBT;
}
return flOK;
}
#endif /* MTD_READ_BBT */
/*----------------------------------------------------------------------*/
/* c h a n g e I n t e r l e a v e */
/* */
/* Change to new interleave mode. */
/* */
/* Note : DiskOnChip Millennium Plus 16MB always reports flOK */
/* */
/* Parameters: */
/* flash : Pointer identifying drive. */
/* interNum : New interleave factor. */
/* */
/* Note - Devices that were HW configured to interleave 1 can not */
/* change to interleave - 2. */
/* Note - Global variables changed: */
/* flash->interleaving */
/* NFDC21thisVars->pageAreaSize */
/* flash->pageSize */
/* NFDC21thisVars->tailSize */
/* NFDC21thisVars->pageMask */
/* flash->erasableBlockSize */
/* NFDC21thisVars->noOfBlocks */
/* */
/* Returns: */
/* flOK on success, otherwise flInterlreavError. */
/*----------------------------------------------------------------------*/
FLStatus changeInterleave(FLFlash * flash, byte interNum)
{
Reg8bitType prevInterleaveReg;
if(setDOCPlusBusType(flash,flBusConfig[flSocketNoOf(flash->socket)],
interNum,NFDC21thisVars->if_cfg) == FALSE)
return flGeneralFailure;
if(flash->mediaType == MDOCP_TYPE) /* DiskOnChip Millennium Plus 32MB */
{
/* Save current configuration */
prevInterleaveReg = flRead8bitRegPlus(flash,NconfigInput);
/* check if we need to change interleave */
if ((prevInterleaveReg & CONFIG_INTLV_MASK) == ((interNum-1)<<2))
return flOK;
if(interNum == 1)
{
flWrite8bitRegPlus(flash,NconfigInput,(byte)(prevInterleaveReg & ~CONFIG_INTLV_MASK)); /* interleave 1 */
if((flRead8bitRegPlus(flash,NconfigInput) & CONFIG_INTLV_MASK) != 0)
return(flInterleaveError); /* could not change interleave */
}
else
{
flWrite8bitRegPlus(flash,NconfigInput,(byte)(prevInterleaveReg | CONFIG_INTLV_MASK)); /* interleave 2 */
if((flRead8bitRegPlus(flash,NconfigInput) & CONFIG_INTLV_MASK) != CONFIG_INTLV_MASK)
return(flInterleaveError); /* could not change interleave */
}
}
else
{
interNum = 1;
}
/* change structure elements values */
flash->interleaving = interNum-1 ;
NFDC21thisVars->pageAreaSize = 0x100 << flash->interleaving;
flash->pageSize = 0X200 << flash->interleaving;
NFDC21thisVars->tailSize = EXTRA_LEN << flash->interleaving; /* 8 in interleave-1, 16 in interleave-2 */
NFDC21thisVars->pageMask = (unsigned short)(flash->pageSize - 1);
flash->erasableBlockSize = NFDC21thisVars->pagesPerBlock * flash->pageSize;
NFDC21thisVars->noOfBlocks = (unsigned short)( flash->chipSize / flash->erasableBlockSize );
flash->interleaving++;
for(flash->erasableBlockSizeBits = 0 ;
(1UL << flash->erasableBlockSizeBits) < flash->erasableBlockSize;
flash->erasableBlockSizeBits++);
return(flOK);
}
#if (!defined(NO_IPL_CODE) && defined (HW_PROTECTION))
/*----------------------------------------------------------------------*/
/* r e a d I P L */
/* */
/* Find a good copy of the IPL and read it to user buffer. */
/* */
/* Parameters: */
/* vol : Pointer identifying drive. */
/* buffer : buffer to read to. */
/* length : number of bytes to read. */
/* */
/* Note - Length must be an integer number of 512 bytes. */
/* */
/* Returns: */
/* flOK on success, none zero otherwise. */
/*----------------------------------------------------------------------*/
static FLStatus readIPL(FLFlash * flash, void FAR1 * buffer, word length)
{
byte FAR1 * bufPtr = (byte FAR1 *)buffer;
const void FAR0* winPtr = (const void FAR1*)flash->win;
word tmpLength = 0;
int i;
volatile byte prevMaxId;
/* IPL must be read using full 512 bytes sector */
if ((length % SECTOR_SIZE != 0)&&(length > flash->noOfFloors*IPL_MAX_SIZE))
return flBadLength;
/* Force IPL to be loaded */
checkStatus(forceDownLoad(flash));
/* Force NORMAL mode */
checkStatus(chkASICmode(flash));
if(flash->win == NULL)
return flGeneralFailure;
/* Store max ID and open IPL of high floors */
prevMaxId = setIplSize(flash, flash->noOfFloors);
for(i = 0 ; length > 0 ; length -= tmpLength,i++)
{
tmpLength = TFFSMIN(length,IPL_MAX_SIZE);
tffscpy(bufPtr , (void FAR1*)winPtr , tmpLength);
bufPtr = BYTE_ADD_FAR(bufPtr,tmpLength);
switch(i)
{
case 1:
winPtr = BYTE_ADD_FAR(winPtr,5*IPL_MAX_SIZE);
break;
case 0:
case 2:
winPtr = BYTE_ADD_FAR(winPtr,IPL_MAX_SIZE);
default:
break;
}
}
/* Restore MAX id */
prevMaxId = setIplSize(flash, prevMaxId);
return flOK;
}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*/
/* w r i t e I P L */
/* */
/* Write new IPL. */
/* */
/* Note : When write operation starts from the middle of the IPL, it */
/* not erase the previous content. Therefore you should use the */
/* use offset != 0 only after an operation that did start from 0.*/
/* */
/* Note : Offset parameter is given in sector (512 bytes). */
/* */
/* Parameters: */
/* flash : Pointer identifying drive. */
/* buffer : buffer to write from. */
/* length : number of bytes to write. */
/* offset : sector number to start from. */
/* flags : Modes to write IPL : */
/* FL_IPL_MODE_NORMAL - Normal mode. */
/* 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)
{
FLBoolean restoreInterleave = FALSE;
FLStatus status;
FLStatus secondStatus;
int i;
byte FAR1 * tmpPtr = (byte FAR0 *)buffer;
byte dps[NO_OF_DPS][SIZE_OF_DPS];
CardAddress iplOffset[4];
byte floor;
byte downloadStatus;
dword floorInc;
word curWrite;
word redundantUnit; /* First unit to erase - might have bad data */
word goodUnit; /* Second unit to erase - has valid DPS */
dword goodDPS; /* Where to read DPS - in second unit */
dword redundantDPS; /* Where to write DPS - in first unit */
dword dps1Copy0; /* Offset to DPS1 copy 0 */
word dps1UnitNo; /* Offset to redundant DPS unit */
dword copyOffset; /* Offset to redundant units */
unsigned iplModeFlags; /* IPL Strong Arm and\or XScale mode flags. */
/* Check IPL requested size against the real IPL size */
if (length + (offset<<SECTOR_SIZE_BITS) > flash->noOfFloors*IPL_MAX_SIZE)
return flBadLength;
/* Check mode of ASIC and set to NORMAL.*/
status = chkASICmode(flash);
if(status != flOK)
return status;
/* Check IPL mode flags */
iplModeFlags = flags & (FL_IPL_MODE_SA|FL_IPL_MODE_XSCALE);
if(iplModeFlags) /* Write MODE mark */
{
if(iplModeFlags == (FL_IPL_MODE_SA|FL_IPL_MODE_XSCALE))
{
DEBUG_PRINT(("ERROR - Can write IPL with both Strong Arm and X-Scale modes\r\n"));
return flBadParameter;
}
if(flash->mediaType == MDOCP_TYPE) /* DiskOnChip Millennium Plus 32MB */
{
DEBUG_PRINT(("ERROR - DiskOnChip Millennium Plus 32MB does not support special IPL modes\r\n"));
return flFeatureNotSupported;
}
}
/* Send default key for unprotected partitions */
if (flash->protectionKeyInsert != NULL)
{
status = flash->protectionKeyInsert(flash,1, (byte *)DEFAULT_KEY);
if(status != flOK)
return status;
}
/* make sure to be in interleave 1 mode */
if (flash->interleaving==2) /* store previous */
{
restoreInterleave = TRUE;
status = changeInterleave(flash, 1); /* change to interleave 1. abort if failed */
if(status != flOK)
return status;
}
#ifndef MTD_STANDALONE
/* Force remapping of internal catched sector */
flash->socket->remapped = TRUE;
#endif /* MTD_STANDALONE */
if(flash->mediaType == MDOCP_TYPE) /* DiskOnChip Millennium Plus 32MB */
{
copyOffset = flash->chipSize>>1; /* The chips are consequtive */
dps1UnitNo = DPS1_UNIT_NO_32;
dps1Copy0 = DPS1_COPY0_32;
iplOffset[0] = IPL0_COPY0_32;
iplOffset[2] = IPL1_COPY0_32;
}
else /* DiskOnChip Millennium Plus 16MB */
{
/* DPS0 / DPS1 / DPS0 copy / DPS 1 copy */
copyOffset = flash->erasableBlockSize;
dps1UnitNo = DPS1_UNIT_NO_16;
dps1Copy0 = DPS1_COPY0_16;
iplOffset[0] = IPL0_COPY0_16;
iplOffset[2] = IPL1_COPY0_16;
}
iplOffset[1] = iplOffset[0]+SECTOR_SIZE;
iplOffset[3] = iplOffset[2]+SECTOR_SIZE;
floor = offset >> 1; /* Skip to proper floor (2 * 512 per floor) */
offset -= floor << 1; /* Update offset */
/* Reading IPL starting from 1k of floor 0 and up */
for (floorInc=floor * NFDC21thisVars->floorSize;
(floor<flash->noOfFloors)&&(length>0);
floor++,floorInc+=NFDC21thisVars->floorSize)
{
setFloor(flash,floor); /* Set the floor to use */
/* Prepare inernal write buffer */
/* Note - buffer and NFDC21thisBuffer might be the same buffer */
curWrite = (word)TFFSMIN(length,SECTOR_SIZE);
tffscpy(NFDC21thisBuffer,(void *)tmpPtr,curWrite);
tffsset(NFDC21thisBuffer+curWrite,0xff,SECTOR_SIZE-curWrite);
/* When starting from the second sector do not erase the units */
if (offset != 0)
{
status = doc2Write(flash,iplOffset[2]+floorInc,NFDC21thisBuffer,SECTOR_SIZE,EDC);
if(status!=flOK) goto END_WRITE_IPL;
status = doc2Write(flash,iplOffset[2]+SECTOR_SIZE+floorInc,NFDC21thisBuffer,SECTOR_SIZE,EDC);
if(status!=flOK) goto END_WRITE_IPL;
status = doc2Write(flash,iplOffset[2]+copyOffset+floorInc,NFDC21thisBuffer,SECTOR_SIZE,EDC);
if(status!=flOK) goto END_WRITE_IPL;
status = doc2Write(flash,iplOffset[2]+SECTOR_SIZE+copyOffset+floorInc,NFDC21thisBuffer,SECTOR_SIZE,EDC);
if(status!=flOK) goto END_WRITE_IPL;
offset = 0;
goto WRITE_IPL_NEXT_FLOOR;
}
/* Decide which copy to use acording to the previous download */
downloadStatus = flRead8bitRegPlus(flash,NdownloadStatus);
switch (downloadStatus & DWN_STAT_DPS1_ERR)
{
case DWN_STAT_DPS1_ERR: /* Both copies are invalid */
status = flBadDownload;
goto END_WRITE_IPL;
case DWN_STAT_DPS10_ERR: /* First copy is bad */
if(flash->mediaType == MDOCP_TYPE)
{
redundantUnit = (word)(dps1UnitNo + floor*(NFDC21thisVars->floorSize>>flash->erasableBlockSizeBits));
goodUnit = (word)(redundantUnit + (copyOffset>>flash->erasableBlockSizeBits));
redundantDPS = dps1Copy0 + floorInc;
goodDPS = redundantDPS + copyOffset;
}
else
{
redundantUnit = (word)(dps1UnitNo + floor*(NFDC21thisVars->floorSize>>flash->erasableBlockSizeBits));
goodUnit = (word)(redundantUnit + (copyOffset>>flash->erasableBlockSizeBits));
redundantDPS = dps1Copy0 + floorInc;
goodDPS = redundantDPS + copyOffset;
}
break;
default: /* Both copies are good */
goodUnit = (word)(dps1UnitNo + floor*(NFDC21thisVars->floorSize>>flash->erasableBlockSizeBits));
redundantUnit = (word)(goodUnit + (copyOffset>>flash->erasableBlockSizeBits));
goodDPS = dps1Copy0 + floorInc;
redundantDPS = goodDPS + copyOffset;
}
/* Read previous dps */
status = doc2Read(flash,goodDPS,&(dps[0][0]),SIZE_OF_DPS,0);
if(status!=flOK) goto END_WRITE_IPL;
status = doc2Read(flash,goodDPS + REDUNDANT_DPS_OFFSET,
&(dps[1][0]),SIZE_OF_DPS,0);
if(status!=flOK) goto END_WRITE_IPL;
/* Erase the other unit - not the one we downloaded from */
status = flash->erase(flash,redundantUnit,1);
if(status!=flOK) goto END_WRITE_IPL;
/* Write DPS */
status = doc2Write(flash,redundantDPS,&(dps[0][0]),SIZE_OF_DPS,0);
if(status!=flOK) goto END_WRITE_IPL;
status = doc2Write(flash,redundantDPS + REDUNDANT_DPS_OFFSET,
&(dps[1][0]),SIZE_OF_DPS,0);
if(status!=flOK) goto END_WRITE_IPL;
/* Erase the unit that we downloaded from */
status = flash->erase(flash,goodUnit,1);
if(status!=flOK) goto END_WRITE_IPL;
/* Write DPS */
status = doc2Write(flash,goodDPS, &(dps[0][0]),SIZE_OF_DPS,0);
if(status!=flOK) goto END_WRITE_IPL;
status = doc2Write(flash,goodDPS + REDUNDANT_DPS_OFFSET,
&(dps[1][0]),SIZE_OF_DPS,0);
/* Write IPL - 2 copies of first unit */
for(i=0;i<2;i++)
{
status = doc2Write(flash,iplOffset[i]+floorInc,NFDC21thisBuffer,SECTOR_SIZE,EDC);
if(status!=flOK) goto END_WRITE_IPL;
status = doc2Write(flash,iplOffset[i]+floorInc+copyOffset,NFDC21thisBuffer,SECTOR_SIZE,EDC);
if(status!=flOK) goto END_WRITE_IPL;
}
/* Write next 512 bytes of IPL if needed */
length -= curWrite;
if (length > 0)
{
/* Prepare next buffer */
tmpPtr = BYTE_ADD_FAR(tmpPtr,SECTOR_SIZE);
curWrite = (word)TFFSMIN(length,SECTOR_SIZE);
tffscpy(NFDC21thisBuffer,tmpPtr,curWrite);
tffsset(NFDC21thisBuffer+curWrite,0x0,SECTOR_SIZE-curWrite);
for(;i<4;i++)
{
status = doc2Write(flash,iplOffset[i]+floorInc,NFDC21thisBuffer,SECTOR_SIZE,EDC);
if(status!=flOK) goto END_WRITE_IPL;
status = doc2Write(flash,iplOffset[i]+floorInc+copyOffset,NFDC21thisBuffer,SECTOR_SIZE,EDC);
if(status!=flOK) goto END_WRITE_IPL;
}
}
WRITE_IPL_NEXT_FLOOR:
length -= curWrite;
if(length>0)
tmpPtr = BYTE_ADD_FAR(tmpPtr,SECTOR_SIZE);
if(iplModeFlags) /* Write MODE mark */
{
byte mark = IPL_SA_MODE_MARK; /* Strong arm is the default */
if(flags & FL_IPL_MODE_XSCALE) /* Unless X-Scale wase asked for */
mark = IPL_XSCALE_MODE_MARK;
status = doc2Write(flash,IPL_MODE_MARK_OFFSET+floorInc,&mark,1,EXTRA);
if(status!=flOK) goto END_WRITE_IPL;
}
} /* End for loop over floors */
END_WRITE_IPL:
if ( restoreInterleave == TRUE)
{
chkASICmode(flash); /* Release posible access error */
secondStatus = changeInterleave(flash, 2); /* change to interleave 2. */
if(secondStatus != flOK)
return secondStatus;
}
if(status == flOK)
{
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"));
}
return status;
}
#endif /* FL_READ_ONLY */
#endif /* not NO_IPL_CODE & HW_PROTECTION */
#ifdef HW_OTP
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*/
/* w r i t e O T P */
/* */
/* Write and lock the customer OTP. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive. */
/* buffer : buffer to write from. */
/* length : number of bytes to write. */
/* */
/* Note - customer OTP memory structure: (flash pages 6-31 */
/* byte 0 - Indicates the lock state (0 for locked). */
/* bytes 3-7 - OTP used size. */
/* page 7-19 - 6K of the unit - customer data. */
/* */
/* Returns: */
/* flOK on success, none zero otherwise. */
/*----------------------------------------------------------------------*/
static FLStatus writeOTP(FLFlash * flash , const void FAR1 * buffer, word length)
{
word lastSectorSize = (word)(length % SECTOR_SIZE);
OTPLockStruct lock;
FLStatus status;
int shift = flash->interleaving-1;
selectFloor(flash,0);
/* Check mode of ASIC and set to NORMAL.*/
status = chkASICmode(flash);
if(status != flOK)
return status;
if (length > CUSTOMER_OTP_SIZE)
return flBadLength;
/* write the data with EDC */
status = doc2Write(flash, (CUSTOMER_OTP_START<<shift)+flash->pageSize, buffer,
length-lastSectorSize, EDC);
if(status != flOK)
return status;
/* Write last partial sector */
if (lastSectorSize > 0)
{
/* Force remapping of internal catched sector */
#ifndef MTD_STANDALONE
flash->socket->remapped = TRUE;
#endif /* MTD_STANDALONE */
tffsset(NFDC21thisBuffer,0,sizeof(NFDC21thisBuffer));
tffscpy(NFDC21thisBuffer,BYTE_ADD_FAR(buffer,length-lastSectorSize),lastSectorSize);
status = doc2Write(flash, (CUSTOMER_OTP_START<<shift) + flash->pageSize +
length-lastSectorSize, NFDC21thisBuffer, SECTOR_SIZE, EDC);
if(status != flOK)
return status;
}
/* Lock area */
tffsset((void FAR1 *)&lock,0,sizeof(lock));
lock.lockByte[0] = OTP_LOCK_MARK;
toLE4(lock.usedSize,(dword)length); /* store size of data */
status = doc2Write(flash, (CUSTOMER_OTP_START<<shift), &lock, sizeof(lock), 0);
if(status == flOK)
status = forceDownLoad(flash);
return status;
}
#endif /* FL_READ_ONLY */
/*----------------------------------------------------------------------*/
/* o t p S i z e */
/* */
/* Returns the size and state of the OTP area. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive. */
/* sectionSize : Total OTP size. */
/* usedSize : Used OTP size. */
/* locked : Lock state (LOCKED_OTP for locked). */
/* */
/* Returns: */
/* flOK on success, none zero otherwise. */
/*----------------------------------------------------------------------*/
static FLStatus otpSize(FLFlash * flash, dword FAR2* sectionSize,
dword FAR2* usedSize, word FAR2* locked)
{
OTPLockStruct lock;
FLStatus status = flOK;
int shift = flash->interleaving-1;
selectFloor(flash,0);
if (flRead8bitRegPlus(flash,NprotectionStatus) & PROTECT_STAT_COTPL_MASK)
{
status = doc2Read(flash,(CUSTOMER_OTP_START<<shift) , &lock, sizeof(lock), 0);
*usedSize = LE4(lock.usedSize);
*locked = LOCKED_OTP;
}
else
{
*locked = 0;
*usedSize = 0;
}
/* return the maximum capacity available */
*sectionSize = CUSTOMER_OTP_SIZE;
return status;
}
/*----------------------------------------------------------------------*/
/* r e a d O T P */
/* */
/* Read data from the customer OTP. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive. */
/* offset : Offset from the beginning of OTP area to read from. */
/* buffer : buffer to read into. */
/* length : number of bytes to read. */
/* */
/* Returns: */
/* flOK on success, none zero otherwise. */
/*----------------------------------------------------------------------*/
static FLStatus readOTP(FLFlash * flash, word offset, void FAR1 * buffer, word length)
{
dword usedSize;
dword tmp;
word locked;
FLStatus status;
CardAddress otpStartAddr,startReadAddr,endReadAddr,remainder;
byte FAR1* bufPtr = (byte FAR1*) buffer;
int shift = flash->interleaving-1;
selectFloor(flash,0);
/* Check mode of ASIC and set to NORMAL.*/
status = chkASICmode(flash);
/* Check otp area written size */
if(status==flOK)
status = otpSize(flash,&tmp,&usedSize,&locked);
if(status != flOK)
return status;
if (locked != LOCKED_OTP)
return flNoSpaceInVolume; /* Area not locked */
if ((dword)(offset+length) > usedSize)
return flBadLength; /* Exceeds used space */
#ifndef MTD_STANDALONE
/* Force remapping of internal catched sector */
flash->socket->remapped = TRUE;
#endif /* MTD_STANDALONE */
/**************************/
/* read the data with EDC */
/**************************/
otpStartAddr = (CUSTOMER_OTP_START<<shift) + flash->pageSize;
/* tmp - OTP offset rounded down to sectors */
tmp = (dword)((offset >> SECTOR_SIZE_BITS) << SECTOR_SIZE_BITS);
/* startReadAddr - Physical address of first sector to read */
startReadAddr = otpStartAddr + tmp;
/* remainder - size of last partial sector to read */
remainder = (offset+length) % SECTOR_SIZE;
/* endReadAddr - Physical address of the last OTP sector to be read */
endReadAddr = otpStartAddr + offset + length - remainder;
if (tmp != offset) /* Start at unaligned address */
{
checkStatus(doc2Read(flash, startReadAddr, NFDC21thisBuffer, SECTOR_SIZE, EDC));
usedSize = TFFSMIN(SECTOR_SIZE + tmp - offset,length);
tffscpy(bufPtr,NFDC21thisBuffer + offset - tmp,(word)usedSize);
bufPtr = BYTE_ADD_FAR(bufPtr,usedSize);
startReadAddr += usedSize;
length -= (word)usedSize;
}
/* Start at aligned address */
if(length > 0)
{
checkStatus(doc2Read(flash, startReadAddr, bufPtr,
endReadAddr-startReadAddr , EDC));
/* Read last sector partial page */
if(remainder)
{
bufPtr = BYTE_ADD_FAR(bufPtr,endReadAddr-startReadAddr);
checkStatus(doc2Read(flash, endReadAddr, NFDC21thisBuffer, SECTOR_SIZE, EDC));
tffscpy(bufPtr,NFDC21thisBuffer,remainder);
}
}
return flOK;
}
/*----------------------------------------------------------------------*/
/* g e t U n i q u e I d */
/* */
/* Retreave the device 16 bytes unique ID. */
/* */
/* Parameters: */
/* flash : Pointer identifying drive. */
/* buffer : buffer to read into. */
/* */
/* Returns: */
/* flOK on success, none zero otherwise. */
/*----------------------------------------------------------------------*/
static FLStatus getUniqueId(FLFlash * flash,void FAR1 * buffer)
{
/* Make sure contorller is set to NORMAL. */
FLStatus status = chkASICmode(flash);
if(status != flOK)
return status;
#ifndef MTD_STANDALONE
/* Force remapping of internal catched sector */
flash->socket->remapped = TRUE;
#endif /* MTD_STANDALONE */
/* read unit 0 sector 0 with ecc */
checkStatus(doc2Read(flash, 0 , NFDC21thisBuffer, SECTOR_SIZE, EDC));
/* copy relevant unique ID from 512 bytes buffer to user buffer */
tffscpy(buffer ,
NFDC21thisBuffer+(UNIQUE_ID_OFFSET << (flash->interleaving - 1)) ,
UNIQUE_ID_SIZE);
return flOK;
}
#endif /* HW_OTP */
/*----------------------------------------------------------------------*/
/* d o c P l u s 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, otherwise failed. */
/*----------------------------------------------------------------------*/
FLStatus docPlusIdentify(FLFlash * flash)
{
FLStatus status;
int maxDevs, dev;
byte floor;
#ifdef NT5PORT
byte socketNo = (byte)flSocketNoOf(flash->socket);
#else
byte socketNo = flSocketNoOf(flash->socket);
#endif NT5PORT
DEBUG_PRINT(("Debug: entering NFDC MDOCP identification routine.\r\n"));
flash->mtdVars = &docMtdVars[socketNo];
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASE))
/* Get pointer to read back buffer */
NFDC21thisVars->readBackBuffer = flReadBackBufferOf(socketNo);
#endif /* VERIFY_WRITE || VERIFY_ERASE */
#ifndef MTD_STANDALONE
/* get pointer to buffer (we assume SINGLE_BUFFER is not defined) */
NFDC21thisVars->buffer = flBufferOf(socketNo);
flSetWindowBusWidth(flash->socket, 16);/* use 16-bits */
flSetWindowSpeed(flash->socket, 120); /* 120 nsec. */
#else
#if (defined (HW_PROTECTION) || defined (HW_OTP) || !defined (NO_IPL_CODE) || defined (MTD_READ_BBT))
NFDC21thisVars->buffer = &globalMTDBuffer;
#endif /* HW_PROTECTION || HW_OTP || !NO_IPL_CODE || MTD_READ_BBT */
#endif /* MTD_STANDALONE */
/* detect card - identify bit toggles on consequitive reads */
NFDC21thisWin = (NDOC2window)flMap(flash->socket, 0);
flash->win = NFDC21thisWin;
if (NFDC21thisWin == NULL)
return flUnknownMedia;
#ifndef FL_NO_USE_FUNC
/* Set default access routines */
if(setDOCPlusBusType(flash,flBusConfig[socketNo],1,
chooseDefaultIF_CFG(flBusConfig[socketNo])) == FALSE)
return flUnknownMedia;
#endif /* FL_NO_USE_FUNC */
/* Change controller to normal mode */
status = setASICmode (flash, DOC_CNTRL_MODE_NORMAL);
if(status != flOK)
return status;
#ifndef FL_NO_USE_FUNC
/* Set permenant access routines accoring to if_cfg and interleave */
if(setDOCPlusBusType(flash,flBusConfig[socketNo],
chkInterleave(flash),chkIF_CFG(flash)) == FALSE)
return flUnknownMedia;
#endif /* FL_NO_USE_FUNC */
dev = getControllerID(flash); /* Read chip ID */
switch (dev)
{
case CHIP_ID_MDOCP: /* Millennium Plus 32MB */
flash->chipSize = CHIP_TOTAL_SIZE<<1;
flash->mediaType = MDOCP_TYPE;
flash->changeableProtectedAreas = 1;
NFDC21thisVars->floorSizeBits = 25;
flash->firstUsableBlock = 3;
break;
case CHIP_ID_MDOCP16: /* Millennium Plus 16MB */
flash->chipSize = CHIP_TOTAL_SIZE;
flash->mediaType = MDOCP_16_TYPE;
flash->changeableProtectedAreas = 2;
NFDC21thisVars->floorSizeBits = 24;
flash->firstUsableBlock = 5;
break;
default:
DEBUG_PRINT(("Debug: failed to identify NFDC MDOCP.\r\n"));
return( flUnknownMedia );
}
NFDC21thisVars->win_io = NIPLpart2; /* NFDC21thisIO */
/* select flash device. change the address according floor!! */
setFloor (flash, 0); /* Map window to selected controler. */
selectChip (flash, MPLUS_SEL_CE|MPLUS_SEL_WP); /* Map window to selected flash device.*/
if (checkToggle(flash) == FALSE)
{
DEBUG_PRINT(("Debug: failed to identify NFDC MDOCP.\r\n"));
return( flUnknownMedia );
}
/* find the interleave value */
flash->interleaving = chkInterleave(flash);
/* reset all flash devices */
maxDevs = MAX_FLASH_DEVICES_MDOCP;
for ( floor = 0 ;floor < MAX_FLOORS ;floor++)
{
/* select floor */
setFloor(flash,floor);
/* select device */
for ( dev = 0 ; dev < maxDevs ; dev++ )
{
selectChip(flash, MPLUS_SEL_CE|MPLUS_SEL_WP );
command(flash, RESET_FLASH);
}
}
/* Set MDOCP flash parameters */
NFDC21thisVars->vendorID = 0x98; /* remember for next chips */
NFDC21thisVars->chipID = 0x75;
flash->type = TC58256_FLASH;
NFDC21thisVars->pagesPerBlock = MDOCP_PAGES_PER_BLOCK;
NFDC21thisVars->floorSize = flash->chipSize;
NFDC21thisVars->pageAreaSize = CHIP_PAGE_SIZE * flash->interleaving;
flash->pageSize = NFDC21thisVars->pageAreaSize << 1;
flash->erasableBlockSize = NFDC21thisVars->pagesPerBlock * flash->pageSize;
NFDC21thisVars->tailSize = EXTRA_LEN * flash->interleaving;/* 8 in interleave-1, 16 in interleave-2 */
NFDC21thisVars->pageMask = (word)(flash->pageSize - 1);
NFDC21thisVars->noOfBlocks = (word)(flash->chipSize / flash->erasableBlockSize);
/* Try changing to interleave 2 */
changeInterleave(flash, 2);
/* identify and count flash chips, figure out flash parameters */
flash->noOfChips = 0; /* One floor already found */
for( floor = 0; floor < MAX_FLOORS; floor++ )
{
setFloor(flash,floor);
/* check floor for MDOCP ID + check the toggle bit */
dev = getControllerID(flash); /* Read chip ID */
if(((dev != CHIP_ID_MDOCP ) &&
(dev != CHIP_ID_MDOCP16) ) ||
(checkToggle(flash) == FALSE) )
break;
/* check for DPS and OTP download errors */
if (chkASICDownload (flash,floor))
{
DEBUG_PRINT(("Debug: failed to download OTP/DPS.\r\n"));
return( flBadDownload );
}
selectChip (flash, MPLUS_SEL_WP); /* Map window to selected flash device.*/
}
/* update total floors in structure and ASIC configuration register */
flash->noOfChips = floor;
flash->noOfFloors = floor;
/* back to ground floor */
NFDC21thisVars->currentFloor = (byte)0;
setFloor(flash,NFDC21thisVars->currentFloor);
if (flash->noOfChips == 0) {
DEBUG_PRINT(("Debug: failed to identify NFDC MDOCP.\r\n"));
return( flUnknownMedia );
}
/*
* Open IPL of high floors
*
* dev = setIplSize(flash, flash->noOfFloors);
*/
/* Get host access type (8 bit or 16 bit data access if_cfg */
NFDC21thisVars->if_cfg = chkIF_CFG(flash);
/* Register our flash handlers and flash parameters */
#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;
#endif /* MTD_STANDALONE */
flash->enterDeepPowerDownMode = powerDown;
#if (defined(HW_PROTECTION) || !defined(NO_IPL_CODE) || defined (HW_OTP))
flash->download = forceDownLoad;
#endif /* HW_PROTECTION or !NO_IPL_CODE */
#ifdef MTD_READ_BBT
flash->readBBT = readBBT;
#endif /* MTD_READ_BBT */
#if (!defined(NO_IPL_CODE) && defined (HW_PROTECTION))
#ifndef FL_READ_ONLY
flash->writeIPL = writeIPL;
#endif /* FL_READ_ONLY */
flash->readIPL = readIPL;
#endif /* not NO_IPL_CODE & HW_PROTECTION */
#ifdef HW_OTP
flash->otpSize = otpSize;
flash->readOTP = readOTP;
#ifndef FL_READ_ONLY
flash->writeOTP = writeOTP;
#endif /* FL_READ_ONLY */
flash->getUniqueId = getUniqueId;
#endif /* HW_OTP */
#ifdef HW_PROTECTION
flash->protectionBoundries = protectionBoundries;
flash->protectionKeyInsert = protectionKeyInsert;
flash->protectionKeyRemove = protectionKeyRemove;
flash->protectionType = protectionType;
#ifndef FL_READ_ONLY
flash->protectionSet = protectionSet;
#endif /* FL_READ_ONLY */
#endif /* HW_PROTECTION */
flash->totalProtectedAreas = 2;
flash->ppp = 5;
flash->flags = INFTL_ENABLED;
flash->maxEraseCycles = 1000000L;
NFDC21thisVars->floorSizeMask = NFDC21thisVars->floorSize-1;
/* checkStatus(forceDownLoad(flash)); *//* For testing purposes only @@*/
DEBUG_PRINT(("Debug: identified NFDC MDOCP.\r\n"));
return( flOK );
}
#ifndef MTD_STANDALONE
/*----------------------------------------------------------------------*/
/* f l R e g i s t e r D O C P L U S S O C */
/* */
/* Installs routines for DiskOnChip Plus family. */
/* */
/* Parameters: */
/* lowAddress, */
/* highAddress : host memory range to search for DiskOnChip */
/* PLUS memory window */
/* */
/* Returns: */
/* FLStatus : 0 on success, otherwise failure */
/*----------------------------------------------------------------------*/
#ifndef NT5PORT
FLStatus flRegisterDOCPLUSSOC(dword lowAddress, dword highAddress)
{
int serialNo;
if( noOfSockets >= SOCKETS )
return flTooManyComponents;
/* Try to register DiskOnChip using */
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 P l u s 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 Plus */
/* 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 docPlusSearchForWindow(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;
}
#ifndef MTD_FOR_EXB
/*----------------------------------------------------------------------*/
/* d o c P l u s 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 docPlusFreeWindow(FLSocket * socket)
{
freePointer(socket->base,DOC_WIN);
}
#endif /* MTD_FOR_EXB */
#endif /* MTD_STANDALONE */
#ifndef MTD_FOR_EXB
/*----------------------------------------------------------------------*/
/* f l R e g i s t e r D O C P L U S */
/* */
/* Registers this MTD for use */
/* */
/* Parameters: */
/* None */
/* */
/* Returns: */
/* FLStatus : 0 on success, otherwise failure */
/*----------------------------------------------------------------------*/
FLStatus flRegisterDOCPLUS(void)
{
if (noOfMTDs >= MTDS)
return( flTooManyComponents );
#ifdef MTD_STANDALONE
socketTable[noOfMTDs] = docPlusSearchForWindow;
freeTable[noOfMTDs] = docPlusFreeWindow;
#endif /* MTD_STANDALONE */
mtdTable[noOfMTDs++] = docPlusIdentify;
return( flOK );
}
#endif /* MTD_FOR_EXB */
Reference in a new issue View git blame Copy permalink