windows-xp/Source/XPSP1/NT/drivers/storage/tffsport/diskonc.c

/*
 * $Log:   V:/Flite/archives/TrueFFS5/Src/DISKONC.C_V  $
 *
 *    Rev 1.33   Apr 15 2002 07:35:04   oris
 * Changed usage and logic of checkToggle to be more intuitive.
 * Added support for new access layer (docsys). MTD now initializes the
 * access layer accessing the DiskOnChip registers.
 * Bug fix - doc2write did not report write faults in case runtime verify
 *                write was not required.
 * Bug fix - bad compilation ifdef in readBBT routine might cause a write
 *                 operation while FL_READ_ONLY is defined or to compile the
 *                 reconstruct BBT code even if MTD_RECONSTRUCT_BBT is
 *                 not defined.
 *
 *    Rev 1.32   Jan 29 2002 20:07:30   oris
 * Changed sanity check of write IPL modes.
 *
 *    Rev 1.31   Jan 28 2002 21:23:58   oris
 * Removed the use of back-slashes in macro definitions.
 * Added FL_IPL_DOWNLOAD flag to writeIPL routine in order to control whether the IPL will be reloaded after the update.
 * Bug fix - writeIPL routine did not support buffers smaller then 1024 bytes.
 * Bug fix - writeIPL routine did not write the second copy of the IPL correctly (for both 512 bytes).
 * Changed docwrite and docset calls to separate DiskOnChip base window pointer and IO registers offset (for address shifting).
 * Replaced FLFlash argument with DiskOnChip memory base pointer in calls to docwrite , docset and docread.
 * Removed win_io initialization (one of FLFlash record fields).
 * Improved check for flSuspend.
 *
 *    Rev 1.30   Jan 23 2002 23:31:04   oris
 * Added writeIPL routine (copied from blockdev.c).
 * Made writeIPL and download routines available even when MTD_STANDALONE  is defined.
 * Bug fix - checkErase routine was unreasonably slow.
 * Changed DFORMAT_PRINT syntax.
 *
 *    Rev 1.29   Jan 21 2002 20:43:50   oris
 * Compilation errors for MTD_STANDALONE with BDK_VERIFY_WRITE.
 * Bug fix - PARTIAL_EDC flag to doc2read was negated prior to readOneSector.
 *
 *    Rev 1.28   Jan 20 2002 20:57:00   oris
 * physicalToPointer was called with wrong size argument.
 *
 *    Rev 1.27   Jan 20 2002 20:28:06   oris
 * Changed doc2000FreeWindow return type to remove warnings.
 *
 *    Rev 1.26   Jan 17 2002 22:57:56   oris
 * Replaced vol with *flash.
 * Removed flPreInit memory access routines.
 * Added new memory access routine implementation.
 * Compilation problems fixed with VERIFY_ERASE
 * Added support for flSuspendMode environment variable.
 *
 *    Rev 1.25   Nov 21 2001 11:39:10   oris
 * Changed FL_WITH_VERIFY_WRITE and FL_WITHOUT_VERIFY_WRITE to FL_ON and  FL_OFF.
 *
 *    Rev 1.24   Nov 20 2001 20:24:58   oris
 * Removed warnings.
 *
 *    Rev 1.23   Nov 16 2001 00:19:38   oris
 * Compilation problem for FL_READ_ONLY.
 *
 *    Rev 1.22   Nov 08 2001 10:44:30   oris
 * Added run-time control over verify write mode.
 * Added support for more up to 64K units - erase / readbbt
 * Restricted BBT block search to BBT_MAX_DISTANCE and not the entire floor.
 * Bug fix - Replacing a DiskOnChip Millennium with DiskOnChip 2000 failed identifying DiskOnChip2000 (gang).
 *
 *    Rev 1.21   Sep 24 2001 18:23:08   oris
 * Removed warnings.
 *
 *    Rev 1.20   Sep 15 2001 23:44:42   oris
 * Placed YIELD_CPU definition under ifdef to prevent redeclaration.
 * Changed doc2erase to support up to 64K erase blocks.
 * Added reconstruct flag to readBBT routine - stating whether to reconstruct BBT if it is not available.
 * Added support for block multiplication in readBBT - several erase blocks in a single unit.
 * Added support for 128MB flashes.
 *
 *    Rev 1.19   Jul 29 2001 16:14:06   oris
 * Support  for number of units per floor not power of 2
 *
 *    Rev 1.18   Jul 16 2001 22:47:58   oris
 * Compilation error when using the FL_READ_ONLY compilation flag.
 *
 *    Rev 1.17   Jul 15 2001 20:44:48   oris
 * Removed warnings.
 * Bug fix - virgin card dformat print was repeated for DiskOnChip with several floors.
 *
 *    Rev 1.16   Jul 13 2001 00:59:42   oris
 * Added docsys.h include.
 * Improved VERIFY_WRITE support - added socket readBack buffer.
 * Added PARTIAL_EDC read flag to the read routine.
 * Revised checkErase routine to include extra area.
 * Revised readBBT routine not to use MTD buffer.
 * Added dformat debug print massages.
 * Changed firstUsable block to 0 for DOC2000 tsop.
 *
 *    Rev 1.15   Jun 17 2001 08:17:02   oris
 * Added brackets to remove warnnings.
 * Changed NO_READ_BBT_CODE  to MTD_NO_READ_BBT_CODE.
 *
 *    Rev 1.14   May 16 2001 21:16:32   oris
 * Removed warnings.
 * Changed code variable name to flCode (avoid name clashes).
 *
 *    Rev 1.13   May 09 2001 00:31:28   oris
 * Changed the DOC2000_TSOP_SUPPORT and READ_BBT_CODE compilation flags to NO_READ_BBT_CODE.
 *
 *    Rev 1.12   May 07 2001 10:00:04   oris
 * Compilation problems under MTD_STANDLAONE compilation flag.
 *
 *    Rev 1.11   May 06 2001 22:41:22   oris
 * Added the READ_BBT_CODE to allow reading the BBT even in the MTD_STANDALONE mode.
 * Removed warnings.
 *
 *    Rev 1.10   May 02 2001 06:44:38   oris
 * Bug fix - readBBT routine.
 * Removed the lastUsableBlock variable.
 *
 *    Rev 1.9   Apr 30 2001 17:58:18   oris
 * Added EDC check when reading the BBT.
 *
 *    Rev 1.8   Apr 24 2001 17:06:22   oris
 * Removed warrnings.
 * Added lastUsableBlock initialization field in the FLFlash record.
 *
 *    Rev 1.7   Apr 16 2001 13:04:20   oris
 * Removed warrnings.
 *
 *    Rev 1.6   Apr 12 2001 06:49:06   oris
 * Added forceDownload routine
 * Changed checkWinForDoc routine to be under ifndef MTD_STANDALONE.
 *
 *    Rev 1.5   Apr 10 2001 16:39:16   oris
 * Added multiple floor support for readbbt routine.
 * Added call for docSocketInit which initializes the socket routines.
 * Added validity check after flMap call in order to support pccard premoutn routine.
 *
 *    Rev 1.4   Apr 09 2001 14:58:40   oris
 * Removed debug buffer from readBBT routine.
 * Bug fix in doc2000Identify if ASIC id was not mdoc 8 is was assumed to be doc2000.
 * Added if_cfg field initialization in doc2000Identify.
 *
 *    Rev 1.3   Apr 01 2001 07:38:58   oris
 * Moved include diskonc.h from docsys.h.
 * Removed waitForReadyWithYieldCPU for MTD_STANDALONE configuration.
 * Removed NO_PPP compilation flag support.
 * Left alligned all # directives.
 * Moved pageSize,noOfFloors filed from the MTDs internal stucture to FLFlash record.
 * Changed  writeOneSector,doc2Write,readOneSector,doc2Read prototype.
 * Added readbbt routine for alon.
 * Removed pageAndTailSize from mtdVars record.
 *
 *    Rev 1.2   Mar 01 2001 14:15:56   vadimk
 * Add proper MDOC and DOC2300 support
 *
 *    Rev 1.1   Feb 07 2001 18:28:38   oris
 * Bug fix - restored antialise mechanizm to flDocWindowBaseAddress
 * Added seperetaed floors compilation flag
 * Changed mdoc \ alon distingishing algorithm
 * Removed checkWinForDoc routine under the mtd_standalone comilation flag
 * removed MAX_FLASH_DEVICES_MDOC define since alone DiskOnChips can support 16 chips just like doc2000
 *
 *    Rev 1.0   Feb 02 2001 15:35:38   oris
 * Initial revision.
 *
 */

/************************************************************************/
/*                                                                      */
/*              FAT-FTL Lite Software Development Kit                   */
/*              Copyright (C) M-Systems Ltd. 1995-2001                  */
/*                                                                      */
/************************************************************************/

#include "reedsol.h"
#include "diskonc.h"

extern NFDC21Vars docMtdVars[SOCKETS];

/* When the MTD is used as a standalone package some of the routine     */
/* are replaced with the following macroes                              */

#ifdef MTD_STANDALONE

#define flReadBackBufferOf(a) &(globalReadBack[a][0])

#define flSocketNoOf(volume) 0 /* currently we support only a single device */

#define flMap(socket,address) addToFarPointer(socket->base,address & (socket->size - 1));

#endif /* MTD_STANDALONE */

/* Yield CPU time in msecs */
#ifndef YIELD_CPU
#define YIELD_CPU 10
#endif /* YIELD_CPU */

/* maximum waiting time in msecs */
#define MAX_WAIT  30

#ifndef NO_EDC_MODE

      /*���������������������������.*/
      /*            EDC control     */
      /*���������������������������.*/

/*----------------------------------------------------------------------*/
/*                        e c c O N r e a d                             */
/*                                                                      */
/* Enable ECC in read mode and reset it.                                */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void eccONread (FLFlash * flash)
{
  flWrite8bitReg(flash,NECCconfig,ECC_RESET);
  flWrite8bitReg(flash,NECCconfig,ECC_EN);
}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*/
/*                        e c c O n w r i t e                           */
/*                                                                      */
/* Enable ECC in write mode and reset it.                               */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*                                                                      */
/*----------------------------------------------------------------------*/
static void eccONwrite (FLFlash * flash)
{
  flWrite8bitReg(flash,NECCconfig,ECC_RESET);
  flWrite8bitReg(flash,NECCconfig,(ECC_RW | ECC_EN));
}
#endif /* FL_READ_ONLY */
#endif
/*----------------------------------------------------------------------*/
/*                        e c c O F F                                   */
/*                                                                      */
/* Disable ECC.                                                         */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void eccOFF (FLFlash * flash)
{
  flWrite8bitReg(flash,NECCconfig,ECC_RESERVED);
}

#ifndef NO_EDC_MODE
/*----------------------------------------------------------------------*/
/*                        e c c E r r o r                               */
/*                                                                      */
/* Check for EDC error.                                                 */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*                                                                      */
/*----------------------------------------------------------------------*/
static FLBoolean  eccError (FLFlash * flash)
{
  register int i;
  volatile Reg8bitType junk = 0;
  Reg8bitType ret;

  if( NFDC21thisVars->flags & MDOC_ASIC ) {
    for(i=0;( i < 2 ); i++)
      junk += flRead8bitReg(flash,NECCconfig);
    ret = flRead8bitReg(flash,NECCconfig);
  }
  else {
    for(i=0;( i < 2 ); i++)
      junk += flRead8bitReg(flash,NECCstatus);
    ret = flRead8bitReg(flash,NECCstatus);
  }
  ret &= ECC_ERROR;
  return ((FLBoolean)ret);

}

#endif

      /*���������������������������.*/
      /*   Miscellaneous routines   */
      /*���������������������������.*/

/*----------------------------------------------------------------------*/
/*                        m a k e C o m m a n d                         */
/*                                                                      */
/* Set Page Pointer to Area A, B or C in page.                          */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*      cmd     : receives command relevant to area                     */
/*      addr    : receives the address to the right area.               */
/*      modes   : mode of operation (EXTRA ...)                         */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void  makeCommand ( FLFlash * flash, PointerOp *cmd,
                           CardAddress *addr, int modes )
{
  dword offset;

#ifdef BIG_PAGE_ENABLED
  if ( !(flash->flags & BIG_PAGE) )
  {           /* 2 Mb components */
    if( modes & EXTRA )
    {
      offset = (*addr) & (SECTOR_SIZE - 1);
      *cmd = AREA_C;
      if( offset < EXTRA_LEN )         /* First half of extra area  */
    *addr += 0x100;                /* ... assigned to 2nd page  */
      else                             /* Second half of extra area */
    *addr -= EXTRA_LEN;            /* ... assigned to 1st page  */
    }
    else
      *cmd = AREA_A;
  }
  else
#endif /* BIG_PAGE_ENABLED */
  {                                           /* 4 Mb components */
    offset = (word)(*addr) & NFDC21thisVars->pageMask; /* offset within device Page */
    *addr -= offset;                             /* align at device Page */

    if(modes & EXTRA)
      offset += SECTOR_SIZE;

    if( offset < NFDC21thisVars->pageAreaSize )  /* starting in area A */
      *cmd = AREA_A;
    else if( offset < flash->pageSize ) /* starting in area B */
      *cmd = AREA_B;
    else                                   /* got into area C    */
      *cmd = AREA_C;

    offset &= (NFDC21thisVars->pageAreaSize - 1); /* offset within area of device Page */
    *addr += offset;
  }
}

/*----------------------------------------------------------------------*/
/*                        b u s y                                       */
/*                                                                      */
/* Check if the selected flash device is ready.                         */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*                                                                      */
/* Returns:                                                             */
/*      Zero is ready.                                                  */
/*                                                                      */
/*----------------------------------------------------------------------*/
static FLBoolean busy (FLFlash * flash)
{
  register int i;
  Reg8bitType stat;
  volatile Reg8bitType junk = 0;
  Reg8bitType ret;
    /* before polling for BUSY status perform 4 read operations from
       CDSN_control_reg */

  for(i=0;( i < 4 ); i++ )
    junk += flRead8bitReg(flash,NNOPreg);

    /* read BUSY status */

  stat = flRead8bitReg(flash,Nsignals);

    /* after BUSY status is obtained perform 2 read operations from
       CDSN_control_reg */

  for(i=0;( i < 2 ); i++ )
    junk += flRead8bitReg(flash,NNOPreg);
  ret = (!(stat & (Reg8bitType)RB));
  return ((FLBoolean)ret);
}

/*----------------------------------------------------------------------*/
/*                        w a i t F o r R e a d y                       */
/*                                                                      */
/* Wait until flash device is ready or timeout.                         */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/* Returns:                                                             */
/*      FALSE if timeout error, otherwise TRUE.                         */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLBoolean  waitForReady (FLFlash * flash)
{
  int i;
  for(i=0;( i < BUSY_DELAY ); i++)
  {
    if( busy(flash) )
    {
      continue;
    }

    return( TRUE );                     /* ready at last.. */
  }

  DEBUG_PRINT(("Debug: timeout error in NFDC 2148.\r\n"));
  return( FALSE );
}

#ifndef MTD_STANDALONE
#ifndef DO_NOT_YIELD_CPU
/*----------------------------------------------------------------------*/
/*              w a i t F o r R e a d y W i t h Y i e l d C P U         */
/*                                                                      */
/* Wait until flash device is ready or timeout.                         */
/* The function yields CPU while it waits till flash is ready           */
/*                                                                      */
/* Parameters:                                                          */
/*  flash   : Pointer identifying drive                                 */
/* Returns:                                                             */
/*  FALSE if timeout error, otherwise TRUE.                             */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLBoolean  waitForReadyWithYieldCPU (FLFlash * flash,
                                            int millisecToSleep)
{
   int i;

   for (i=0;  i < (millisecToSleep / YIELD_CPU); i++) {
    #ifndef NT5PORT
       flsleep(YIELD_CPU);
    #endif /*NT5PORT*/
       if( busy(flash) )
         continue;
       return( TRUE );                     /* ready at last.. */
   }

   return( FALSE );
}
#endif /* DO_NOT_YIELD_CPU */
#endif /* MTD_STANDALONE */
/*----------------------------------------------------------------------*/
/*                        w r i t e S i g n a l s                       */
/*                                                                      */
/* Write to CDSN_control_reg.                                           */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      val     : Value to write to register                            */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void  writeSignals (FLFlash * flash, Reg8bitType val)
{
  register int i;
  volatile Reg8bitType junk = 0;

  flWrite8bitReg(flash,Nsignals,val);

  /* after writing to CDSN_control perform 2 reads from there */

  for(i = 0;( i < 2 ); i++ )
    junk += flRead8bitReg(flash,NNOPreg);
}

/*----------------------------------------------------------------------*/
/*                        s e l e c t C h i p                           */
/*                                                                      */
/* Write to deviceSelector register.                                    */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      dev     : Chip to select.                                       */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void  selectChip (FLFlash * flash, Reg8bitType dev)
{
  flWrite8bitReg(flash,NdeviceSelector,dev);
}

/*----------------------------------------------------------------------*/
/*                        c h k A S I C m o d e                         */
/*                                                                      */
/* Check mode of ASIC and if RESET set to NORMAL.                       */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void chkASICmode (FLFlash * flash)
{
  if( flRead8bitReg(flash,NDOCstatus) == ASIC_CHECK_RESET ) {
    flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
    flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
#ifndef SEPARATED_CASCADED
    NFDC21thisVars->currentFloor = 0;
#endif /* SEPARATED_CASCADED */
  }
}

/*----------------------------------------------------------------------*/
/*                        s e t A S I C m o d e                         */
/*                                                                      */
/* Set mode of ASIC.                                                    */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      mode    : mode to set.                                          */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void setASICmode (FLFlash * flash, Reg8bitType mode)
{
  NDOC2window p = (NDOC2window)flMap(flash->socket, 0);
  if (p!=NULL)
  {
     flWrite8bitReg(flash,NDOCcontrol,mode);
     flWrite8bitReg(flash,NDOCcontrol,mode);
#ifdef SEPARATED_CASCADED
     flWrite8bitReg(flash,NASICselect,NFDC21thisVars->currentFloor);
#endif /* SEPARATED_CASCADED */
  }
}

/*----------------------------------------------------------------------*/
/*                        c h e c k T o g g l e                         */
/*                                                                      */
/* Check DiskOnChip toggle bit. Verify this is not simple RAM.          */
/*                                                                      */
/* Note : This routine assumes that the memory access routines have     */
/* already been initialized by the called routine.                      */
/*                                                                      */
/* Parameters:                                                          */
/*      FLFlash      : Pointer to flash structure.                      */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus: TRUE if the bit toggles verifing that this is indeed  */
/*                a DiskOnChip device, otherwise FALSE.                 */
/*----------------------------------------------------------------------*/

static FLBoolean checkToggle(FLFlash * flash)
{
  volatile Reg8bitType toggle1;
  volatile Reg8bitType toggle2;

  if(flRead8bitReg(flash,NchipId) == CHIP_ID_MDOC ) {
    toggle1 = flRead8bitReg(flash,NECCconfig);
    toggle2 = toggle1 ^ flRead8bitReg(flash,NECCconfig);
  }
  else {
    toggle1 = flRead8bitReg(flash,NECCstatus);
    toggle2 = toggle1 ^ flRead8bitReg(flash,NECCstatus);
  }
  if( (toggle2 & TOGGLE) == 0 )
    return FALSE;
  return TRUE;
}

#ifndef MTD_STANDALONE

/*----------------------------------------------------------------------*/
/*                        c h e c k W i n F o r D O C                   */
/*                                                                      */
/* Check for a DiskOnChip on a specific socket and memory windows       */
/*                                                                      */
/* Parameters:                                                          */
/*      socketNo     : Number of socket to check.                       */
/*      memWinPtr    : Pointer to DiskOnChip memory window.             */
/*                                                                      */
/* Returns: TRUE if this is an MDOCP, otherwise FALSE.                  */
/*----------------------------------------------------------------------*/

FLBoolean checkWinForDOC(unsigned socketNo, NDOC2window memWinPtr)
{
  FLFlash * flash = flFlashOf(socketNo);

  /* Initialize socket memory access routine */
  flash->win = memWinPtr;

#ifndef FL_NO_USE_FUNC
  if(setBusTypeOfFlash(flash, flBusConfig[socketNo] |
                       FL_8BIT_DOC_ACCESS | FL_8BIT_FLASH_ACCESS))
    return FALSE;
#endif /* FL_NO_USE_FUNC */

  /* set ASIC to RESET MODE */
  flWrite8bitReg(flash,NDOCcontrol,ASIC_RESET_MODE);
  flWrite8bitReg(flash,NDOCcontrol,ASIC_RESET_MODE);

  flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
  flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);

  if( (flRead8bitReg(flash,NchipId) != CHIP_ID_DOC ) &&
      (flRead8bitReg(flash,NchipId) != CHIP_ID_MDOC))
    return FALSE;

  return checkToggle(flash);
}

#endif /* MTD_STANDALONE */

#ifndef NO_IPL_CODE

/*----------------------------------------------------------------------*/
/*                       f o r c e D o w n l o a d                      */
/*                                                                      */
/* Force download of IPL code.                                          */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 on success                                  */
/*----------------------------------------------------------------------*/

static FLStatus forceDownLoad(FLFlash * flash)
{
   flWrite8bitReg(flash, NfoudaryTest, 0x36);
   flWrite8bitReg(flash, NfoudaryTest, 0x63);
   flDelayMsecs(1000);
   return flOK;
}

#ifndef FL_READ_ONLY

/*----------------------------------------------------------------------*/
/*                        w r i t e I P L                               */
/*                                                                      */
/* Write new IPL.                                                       */
/*                                                                      */
/* Note : Can not start write operation from middle of IPL , unless     */
/*        previous operation started from offset 0.                     */
/*                                                                      */
/* Parameters:                                                          */
/*      flash   : Pointer identifying drive.                            */
/*      buffer  : buffer to write from.                                 */
/*      length  : number of bytes to write - must use full 512 bytes.   */
/*      offset  : sector number to start from.                          */
/*      flags   : Modes to write IPL :                                  */
/*                FL_IPL_MODE_NORMAL - Normal mode (none Strong Arm).   */
/*                FL_IPL_DOWNLOAD    - Download new IPL when done       */
/*                FL_IPL_MODE_SA     - Strong Arm IPL mode              */
/*                FL_IPL_MODE_XSCALE - X-Scale IPL mode                 */
/*                                                                      */
/* Returns:                                                             */
/*      flOK on success, none zero otherwise.                           */
/*----------------------------------------------------------------------*/

static FLStatus writeIPL(FLFlash * flash, const void FAR1 * buffer,
                         word length,byte offset, unsigned flags)
{
   dword  curWrite;
   dword  addrOffset = (dword)offset << SECTOR_SIZE_BITS;

   if((flags & (FL_IPL_MODE_SA | FL_IPL_MODE_XSCALE)) != 0)
   {
      DFORMAT_PRINT(("ERROR - DiskOnChip does not support this IPL mode.\r\n"));
      return flFeatureNotSupported;
   }

   if ((flash->erase != NULL)||(flash->write != NULL))
   {
      if ((length + addrOffset > 1024) ||  /* required length to long    */
          (offset>1)                     ) /* only single sector or none */
      {
         DFORMAT_PRINT(("ERROR - IPL size or offset are too big for this DiskOnChip.\r\n"));
         return flBadLength;
      }
      if((length % SECTOR_SIZE) != 0)
      {
         DFORMAT_PRINT(("ERROR - IPL size must be a multiplication of 512 bytes.\r\n"));
         return flBadLength;
      }

      if(offset==0) /* Erase only if offset is 0 */
         checkStatus(flash->erase(flash,0,1));

      for (addrOffset = addrOffset << 1 ; length > 0 ;
           addrOffset += (SECTOR_SIZE<<1))
      {
         curWrite = TFFSMIN(length,SECTOR_SIZE);
         checkStatus(flash->write(flash,addrOffset,buffer,curWrite,PARTIAL_EDC));
         checkStatus(flash->write(flash,addrOffset+SECTOR_SIZE,buffer,curWrite,PARTIAL_EDC));
         buffer   = (byte FAR1 *)BYTE_ADD_FAR(buffer,SECTOR_SIZE);
         length  -= (word)curWrite;
      }
      if((flags & FL_IPL_DOWNLOAD) == 0)
        return flOK;

      if(flash->download != NULL)
         return flash->download(flash);
      DFORMAT_PRINT(("ERROR - IPL was not downloaded since MTD does not support the feature\r\n"));
   }
   DFORMAT_PRINT(("ERROR - IPL was not written since MTD is in read only mode\r\n"));
   return flFeatureNotSupported;
}

#endif /* FL_READ_ONLY */
#endif /* NO_IPL_CODE */


/*----------------------------------------------------------------------*/
/*                f l D o c W i n d o w B a s e A d d r e s s           */
/*                                                                      */
/* Return the host base address of the window.                          */
/* If the window base address is programmable, this routine selects     */
/* where the base address will be programmed to.                        */
/*                                                                      */
/* Parameters:                                                          */
/*      socketNo        FLite socket No (0..SOCKETS-1)                  */
/*      lowAddress,                                                     */
/*      highAddress :   host memory range to search for DiskOnChip 2000 */
/*                      memory window                                   */
/*                                                                      */
/* Returns:                                                             */
/*      Host physical address of window divided by 4 KB                 */
/*      nextAddress :   The address of the next DiskOnChip.             */
/*----------------------------------------------------------------------*/
static unsigned flDocWindowBaseAddress(byte socketNo, dword lowAddress,
                                dword highAddress, dword *nextAddress)
{
#ifndef NT5PORT
  FLBoolean     stopSearch = FALSE;
  volatile byte deviceSearch;
  dword         winSize;
  FLFlash      *flash;


#ifdef SEPARATED_CASCADED
  /* This flag is used to seperate the cascaded devices into SEPARATED volumes  */
  /* Only the first floor responds therfore once it is found all the others are */
  /* reported without searching                                                 */

  static byte noOfFloors    = 0; /* floor counter of the cascaded device  */
  static socketOfFirstFloor = 0; /* Number of sockets already found       */
  static dword savedNextAddress; /* Next search address (skipping aliases */

  switch ( noOfFloors )
  {
     case 0 :                         /* First access to a device */
        socketOfFirstFloor = noOfSockets;
        break;

     case 1 :                  /* Last floor of a cascaded device */
        *nextAddress = savedNextAddress;

     default :                 /* One of a cascaded device floors */
        docMtdVars[noOfSockets].currentFloor = noOfSockets - socketOfFirstFloor;
        noOfFloors--;
        return((unsigned)(lowAddress >> 12));
  }
#endif /* SEPARATED_CASCADED */

  /* if memory range to search for DiskOnChip 2000 window is not specified */
  /* assume the standard x86 PC architecture where DiskOnChip 2000 appears */
  /* in a memory range reserved for BIOS expansions                        */
  if (lowAddress == 0x0L) {
    lowAddress  = START_ADR;
    highAddress = STOP_ADR;
  }

  flash = flFlashOf(socketNo);

#ifndef FL_NO_USE_FUNC
  /* Initialize socket memory access routine */
  if(setBusTypeOfFlash(flash, flBusConfig[socketNo] |
                       FL_8BIT_DOC_ACCESS | FL_8BIT_FLASH_ACCESS))
     return ( 0 );
#endif /* FL_NO_USE_FUNC */

  winSize = DOC_WIN;

  /* set all possible controllers to RESET MODE */

  for(*nextAddress = lowAddress ; *nextAddress <= highAddress ;
      *nextAddress += winSize)
  {
     flash->win = (NDOC2window )physicalToPointer(*nextAddress,winSize,socketNo);
     flWrite8bitReg(flash,NDOCcontrol,ASIC_RESET_MODE);
     flWrite8bitReg(flash,NDOCcontrol,ASIC_RESET_MODE);
  }

  /* set controller (ASIC) to NORMAL MODE and try and detect it */
  *nextAddress = lowAddress;       /* current address initialization */
  for( ; *nextAddress <= highAddress; *nextAddress += winSize)
  {
    flash->win = (NDOC2window)physicalToPointer(*nextAddress,winSize,socketNo);
    /* set controller (ASIC) to NORMAL MODE */
    flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);
    flWrite8bitReg(flash,NDOCcontrol,ASIC_NORMAL_MODE);

    if( (flRead8bitReg(flash,NchipId) != CHIP_ID_DOC &&
         flRead8bitReg(flash,NchipId) != CHIP_ID_MDOC))
    {
      if( stopSearch == TRUE )  /* DiskOnChip was found */
        break;
      else continue;
    }
    if( stopSearch == FALSE ) {
      /* detect card - identify bit toggles on consequitive reads */
      if(checkToggle(flash) == FALSE)
        continue;
      /* DiskOnChip found */
      if( flRead8bitReg(flash,NchipId)) {
          flWrite8bitReg(flash,NaliasResolution,ALIAS_RESOLUTION);
      }
      else {
        flWrite8bitReg(flash,NdeviceSelector,ALIAS_RESOLUTION);
      }
      stopSearch = TRUE;
      lowAddress = *nextAddress;   /* save DiskOnChip address */
    }
    else { /* DiskOnChip found, continue to skip aliases */
        if( (flRead8bitReg(flash,NchipId) != CHIP_ID_DOC) &&
          (flRead8bitReg(flash,NchipId) != CHIP_ID_MDOC) )
        break;
      /* detect card - identify bit toggles on consequitive reads */
      if(checkToggle(flash) == FALSE)
        break;
      /* check for Alias */
      deviceSearch = (byte)((flRead8bitReg(flash,NchipId) == CHIP_ID_MDOC) ?
                             flRead8bitReg(flash,NaliasResolution) :
                             flRead8bitReg(flash,NdeviceSelector));
      if( deviceSearch != ALIAS_RESOLUTION )
        break;
    }
  }
  if( stopSearch == FALSE )  /* DiskOnChip 2000 memory window not found */
    return( 0 );

#ifdef SEPARATED_CASCADED
    /* count the number of floors cascaded to this address */

    flash->win = (NDOC2window)physicalToPointer(lowAddress,winSize,socketNo);
    for ( noOfFloors=1; noOfFloors < MAX_FLASH_DEVICES_DOC ;noOfFloors++)
    {
       flWrite8bitReg(flash,NASICselect,noOfFloors);
       if(checkToggle(flash) == FALSE)
          break;
    }
    /* If there are more then 1 floor on this address save the next device address and report
       that the next device is actualy on the same address as the current */

    if ( noOfFloors > 1)
    {
       flWrite8bitReg(flash,NASICselect,0);
       savedNextAddress = *nextAddress;
       *nextAddress     = lowAddress;
    }
    noOfFloors--;
#endif /* SEPARATED_CASCADED */
  return((unsigned)(lowAddress >> 12));
#else  /*NT5PORT*/
        DEBUG_PRINT(("Tffsport mdocplus.c :flDocWindowBaseAddress(): Before returning baseAddress()\n"));
        return (unsigned)(((ULONG_PTR)pdriveInfo[socketNo].winBase)>> 12);
#endif /*NT5PORT*/

}
/*----------------------------------------------------------------------*/
/*                        s e t A d d r e s s                           */
/*                                                                      */
/* Latch address to selected flash device.                              */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : address to set.                                       */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void setAddress (FLFlash * flash, CardAddress address)
{
  address &= (flash->chipSize * flash->interleaving - 1);  /* address within flash device */

#ifdef BIG_PAGE_ENABLED
  if ( flash->flags & BIG_PAGE )
#endif /* BIG_PAGE_ENABLED */
  {
    /*
       bits  0..7     stays as are
       bit      8     is thrown away from address
       bits 31..9 ->  bits 30..8
    */
    address = ((address >> 9) << 8)  |  ((byte)address);
  }

  writeSignals (flash, FLASH_IO | ALE | CE);

#ifdef SLOW_IO_FLAG
  flWrite8bitReg(flash,NslowIO,(Reg8bitType)address);
  flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)address);
  flWrite8bitReg(flash,NslowIO,(Reg8bitType)(address >> 8));
  flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 8));
  flWrite8bitReg(flash,NslowIO,(Reg8bitType)(address >> 16));
  flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 16));
  if( flash->flags & BIG_ADDR ) {
    flWrite8bitReg(flash,NslowIO,(Reg8bitType)(address >> 24));
    flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 24));
  }
#else
  flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)address);
  flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 8));
  flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 16));
  if( flash->flags & BIG_ADDR )
    flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(address >> 24));
#endif
  if( NFDC21thisVars->flags & MDOC_ASIC )
    flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);

  writeSignals (flash, ECC_IO | FLASH_IO | CE);
}

/*----------------------------------------------------------------------*/
/*                        c o m m a n d                                 */
/*                                                                      */
/* Latch command byte to selected flash device.                         */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      code    : Command to set.                                       */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void command(FLFlash * flash, Reg8bitType flCode)
{
  writeSignals (flash, FLASH_IO | CLE | CE);

#ifdef SLOW_IO_FLAG
  flWrite8bitReg(flash,NslowIO,flCode);
#endif

  flWrite8bitReg(flash,NFDC21thisIO,flCode);
  if( NFDC21thisVars->flags & MDOC_ASIC )
    flWrite8bitReg(flash,NwritePipeTerm,flCode);
}

/*----------------------------------------------------------------------*/
/*                        s e l e c t F l o o r                         */
/*                                                                      */
/* Select floor (0 .. totalFloors-1).                                   */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : Select floor for this address.                        */
/*                                                                      */
/*----------------------------------------------------------------------*/

#ifndef SEPARATED_CASCADED

static void selectFloor (FLFlash * flash, CardAddress *address)
{
  if( flash->noOfFloors > 1 )
  {
    byte floorToUse = (byte)((*address) / NFDC21thisVars->floorSize);

    NFDC21thisVars->currentFloor = floorToUse;
    flWrite8bitReg(flash,NASICselect,floorToUse);
    *address -= (floorToUse * NFDC21thisVars->floorSize);
  }
}

#endif /* SEPARATED_CASCADED */

/*----------------------------------------------------------------------*/
/*                        m a p W i n                                   */
/*                                                                      */
/* Map window to selected flash device.                                 */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : Map window to this address.                           */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void mapWin (FLFlash * flash, CardAddress *address)
{
  /* NOTE: normally both ways to obtain DOC 2000 window segment should
         return the same value. */
  NFDC21thisWin = (NDOC2window)flMap(flash->socket, 0);
#ifndef SEPARATED_CASCADED
  selectFloor (flash, address);
#else
  flWrite8bitReg(flash,NASICselect,NFDC21thisVars->currentFloor);
#endif /* SEPARATED_CASCADED */
  /* select chip within floor */
  selectChip (flash, (Reg8bitType)((*address) / (flash->chipSize * flash->interleaving))) ;
}

/*----------------------------------------------------------------------*/
/*                        r d B u f                                     */
/*                                                                      */
/* Auxiliary routine for Read(), read from page.                        */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      buf     : Buffer to read into.                                  */
/*      howmany : Number of bytes to read.                              */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void rdBuf (FLFlash * flash, byte FAR1 *buf, word howmany)
{
  volatile Reg8bitType junk = 0;
  register word i;
#ifdef SLOW_IO_FLAG
  /* slow flash requires first read to be done from CDSN_Slow_IO
     and only second one from CDSN_IO - this extends read access */

  for( i = 0 ;( i < howmany ); i++ ) {
    junk = flRead8bitReg(flash,NslowIO);
    buf[i] = (byte)flRead8bitReg(flash,NFDC21thisIO+(i & 0x01));
  }
#else
  if( NFDC21thisVars->flags & MDOC_ASIC ) {
    junk += flRead8bitReg(flash,NreadPipeInit);
    howmany--;
    i = TFFSMIN( howmany, MDOC_ALIAS_RANGE );
    docread(flash->win,NFDC21thisIO,buf,i);
  }
  else i = 0;
  if( howmany > i )
    docread(flash->win,NFDC21thisIO,buf+i,(word)(howmany-i));

  if( NFDC21thisVars->flags & MDOC_ASIC )
    buf[howmany] = flRead8bitReg(flash,NreadLastData);
#endif
}
#ifndef FL_READ_ONLY

/*----------------------------------------------------------------------*/
/*                        w r B u f                                     */
/*                                                                      */
/* Auxiliary routine for Write(), write to page from buffer.            */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      buf     : Buffer to write from.                                 */
/*      howmany : Number of bytes to write.                             */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void  wrBuf (FLFlash * flash, const byte FAR1 *buf, word howmany )
{
#ifdef SLOW_IO_FLAG
  register int i;
  /* slow flash requires first write go to CDSN_Slow_IO and
     only second one to CDSN_IO - this extends write access */

  for ( i = 0 ;( i < howmany ); i++ ) {
    flWrite8bitReg(flash,NslowIO,(Reg8bitType)buf[i]);
    flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)buf[i]);
  }
#else
  docwrite(flash->win,NFDC21thisIO,(byte FAR1 *)buf,howmany);
  if( NFDC21thisVars->flags & MDOC_ASIC )
    flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
#endif
}

/*----------------------------------------------------------------------*/
/*                        w r S e t                                     */
/*                                                                      */
/* Auxiliary routine for Write(), set page data.                        */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      ch      : Set page to this byte                                 */
/*      howmany : Number of bytes to set.                               */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void  wrSet (FLFlash * flash, const Reg8bitType ch, word howmany )
{
#ifdef SLOW_IO_FLAG
    register int i;
    /* slow flash requires first write go to CDSN_Slow_IO and
       only second one to CDSN_IO - this extends write access */

    for (i = 0 ;( i < howmany ); i++ ) {
      flWrite8bitReg(flash,NslowIO,(Reg8bitType)ch);
      flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)ch);
    }
#else
    docset(flash->win,NFDC21thisIO,howmany,ch);
    if( NFDC21thisVars->flags & MDOC_ASIC )
      flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
#endif
}

/*----------------------------------------------------------------------*/
/*                        r e a d S t a t u s                           */
/*                                                                      */
/* Read status of selected flash device.                                */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*                                                                      */
/* Returns:                                                             */
/*      Chip status.                                                    */
/*                                                                      */
/*----------------------------------------------------------------------*/

static Reg8bitType readStatus (FLFlash * flash)
{
  Reg8bitType chipStatus;
  volatile Reg8bitType junk = 0;

  flWrite8bitReg(flash,NFDC21thisIO,READ_STATUS);
  if( NFDC21thisVars->flags & MDOC_ASIC )
    flWrite8bitReg(flash,NwritePipeTerm,READ_STATUS);
  writeSignals (flash, FLASH_IO | CE | WP);

  if( NFDC21thisVars->flags & MDOC_ASIC ) {
    junk += flRead8bitReg(flash,NreadPipeInit); /* load first data into pipeline */
    chipStatus = flRead8bitReg(flash,NreadLastData); /* read flash status */
  }
  else {
    junk += flRead8bitReg(flash,NslowIO);
    chipStatus = flRead8bitReg(flash,NFDC21thisIO);
  }
  return chipStatus;
}
#endif /* FL_READ_ONLY */

/*----------------------------------------------------------------------*/
/*                        r e a d C o m m a n d                         */
/*                                                                      */
/* Issue read command.                                                  */
/*                                                                      */
/* Parametes:                                                           */
/*      flash     : Pointer identifying drive                           */
/*      cmd     : Command to issue (according to area).                 */
/*      addr    : address to read from.                                 */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void readCommand (FLFlash * flash, PointerOp  cmd, CardAddress addr)
{
  command (flash, (Reg8bitType)cmd);  /* move flash pointer to respective area of the page */
  setAddress (flash, addr);
  waitForReady(flash);
}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*/
/*                        w r i t e C o m m a n d                       */
/*                                                                      */
/* Issue write command.                                                 */
/*                                                                      */
/* Parametes:                                                           */
/*      flash     : Pointer identifying drive                           */
/*      cmd     : Command to issue (according to area).                 */
/*      addr    : address to write to.                                  */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void writeCommand (FLFlash * flash, PointerOp  cmd, CardAddress addr)
{
  if( flash->flags & FULL_PAGE ) {
    command (flash, RESET_FLASH);
    waitForReady(flash);
    if( cmd != AREA_A ) {
#ifdef SLOW_IO_FLAG
      flWrite8bitReg(flash,NslowIO,(byte)cmd);
#endif
      flWrite8bitReg(flash,NFDC21thisIO,(byte)cmd);
      if( NFDC21thisVars->flags & MDOC_ASIC )
         flWrite8bitReg(flash,NwritePipeTerm,(byte)cmd);
    }
  }
  else
    command (flash, (Reg8bitType)cmd); /* move flash pointer to respective area of the page */

#ifdef SLOW_IO_FLAG
  flWrite8bitReg(flash,NslowIO,SERIAL_DATA_INPUT);
#endif

  flWrite8bitReg(flash,NFDC21thisIO,SERIAL_DATA_INPUT);
  if( NFDC21thisVars->flags & MDOC_ASIC )
    flWrite8bitReg(flash,NwritePipeTerm,SERIAL_DATA_INPUT);

  setAddress (flash, addr);

  waitForReady(flash);
}

/*----------------------------------------------------------------------*/
/*                        w r i t e E x e c u t e                       */
/*                                                                      */
/* Execute write.                                                       */
/*                                                                      */
/* Parametes:                                                           */
/*      flash     : Pointer identifying drive                           */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 on success, otherwise failed.               */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLStatus writeExecute (FLFlash * flash)
{
  command (flash, SETUP_WRITE);             /* execute page program */
  waitForReady(flash);

  if( readStatus(flash) & (byte)(FAIL) ) {
    DEBUG_PRINT(("Debug: NFDC 2148 write failed.\r\n"));
    return( flWriteFault );
  }

  return( flOK );
}

/*----------------------------------------------------------------------*/
/*                        w r i t e O n e S e c t o r                   */
/*                                                                      */
/* Write data in one 512-byte block to flash.                           */
/* Assuming that EDC mode never requested on partial block writes.      */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : Address of sector to write to.                        */
/*      buffer  : buffer to write from.                                 */
/*      length  : number of bytes to write (up to sector size).         */
/*      modes   : OVERWRITE, EDC flags etc.                             */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 on success, otherwise failed.               */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLStatus writeOneSector(FLFlash * flash,
                   CardAddress address,
                   const void FAR1 *buffer,
                   word length,
                   word modes)
{
  byte FAR1 *pbuffer = (byte FAR1 *)buffer; /* to write from */
  FLStatus  status;
#ifndef NO_EDC_MODE
  byte syndrom[SYNDROM_BYTES];
  static byte anandMark[2] = { 0x55, 0x55 };
#endif
  PointerOp cmd = AREA_A ;
  word prePad;
#ifdef BIG_PAGE_ENABLED
  word toFirstPage = 0, toSecondPage = 0;
#endif /* BIG_PAGE_ENABLED */

#ifndef MTD_STANDALONE
  if (flWriteProtected(flash->socket))
    return( flWriteProtect );
#endif

  mapWin(flash, &address);                  /* select flash device */

  /* move flash pointer to areas A,B or C of page */
  makeCommand(flash, &cmd, &address, modes);

  if( (flash->flags & FULL_PAGE)  &&  (cmd == AREA_B) ) {
    prePad = (word)(2 + ((word) address & NFDC21thisVars->pageMask));
    writeCommand(flash, AREA_A, address + NFDC21thisVars->pageAreaSize - prePad);
    wrSet(flash, 0xFF, prePad);
  }
  else
    writeCommand(flash, cmd, address);

#ifndef NO_EDC_MODE
  if( modes & EDC )
    eccONwrite(flash);                /* ECC ON for write */
#endif

#ifdef BIG_PAGE_ENABLED
  if( !(flash->flags & BIG_PAGE) )             /* 2M on INLV=1 */
  {
            /* write up to two pages separately */
    if( modes & EXTRA )
      toFirstPage = EXTRA_LEN - ((word)address & (EXTRA_LEN-1));
    else
      toFirstPage = CHIP_PAGE_SIZE - ((word)address & (CHIP_PAGE_SIZE-1));

    if(toFirstPage > length)
      toFirstPage = length;
    toSecondPage = length - toFirstPage;

    wrBuf(flash, pbuffer, toFirstPage);                  /* starting page .. */

    if ( toSecondPage > 0 )
    {
      if (toFirstPage > 0)                       /* started on 1st page */
         checkStatus( writeExecute(flash) );       /* done with 1st page */
      if( modes & EXTRA )
        address -= (CHIP_PAGE_SIZE + ((word)address & (EXTRA_LEN-1)));
      writeCommand(flash, cmd, address + toFirstPage);
      wrBuf (flash, pbuffer + toFirstPage, toSecondPage);  /* user data */
    }
  }
  else                                     /* 4M or 8M */
#endif /* BIG_PAGE_ENABLED */

    wrBuf (flash, pbuffer, length);               /* user data */

#ifndef NO_EDC_MODE
  if(modes & EDC)
  {
    register int i;

    writeSignals (flash, ECC_IO | CE );             /* disable flash access */
     /* 3 dummy zero-writes to clock the data through pipeline */
    if( NFDC21thisVars->flags & MDOC_ASIC ) {
      for( i = 0;( i < 3 ); i++ ) {
         flWrite8bitReg(flash,NNOPreg,(Reg8bitType)0);
      }
    }
    else {
      wrSet (flash, 0x00, 3 );
    }
    writeSignals (flash, ECC_IO | FLASH_IO | CE );  /* enable flash access */

    docread(flash->win,Nsyndrom,syndrom,SYNDROM_BYTES);
#ifdef D2TST
    tffscpy(saveSyndromForDumping,syndrom,SYNDROM_BYTES);
#endif
    eccOFF(flash);                           /* ECC OFF  */

    wrBuf (flash, (const byte FAR1 *)syndrom, SYNDROM_BYTES);

    wrBuf (flash, (const byte FAR1 *)anandMark, sizeof(anandMark) );
  }
#endif /* NO_EDC_MODE */

  status = writeExecute(flash);             /* abort if write failure */
  if(status != flOK)
    return status;

  writeSignals(flash, FLASH_IO | WP);

#ifdef VERIFY_WRITE

#ifndef MTD_STANDALONE
  if (flash->socket->verifyWrite==FL_OFF)
      return status;
#endif /* MTD_STANDALONE */

  /* Read back after write and verify */

  if( modes & OVERWRITE )
    pbuffer = (byte FAR1 *) buffer;     /* back to original data */

  readCommand (flash, cmd, address); /* move flash pointer to areas A,B or C of page */

#ifdef BIG_PAGE_ENABLED

  if( !(flash->flags & BIG_PAGE) )
  {
    rdBuf (flash, NFDC21thisVars->readBackBuffer, toFirstPage);

    if(tffscmp (pbuffer, NFDC21thisVars->readBackBuffer, toFirstPage) ) {
      DEBUG_PRINT(("Debug: NFDC 2148 write failed in verification.\r\n"));
      return( flWriteFault );
    }

    if ( toSecondPage > 0 )
    {
      readCommand (flash, AREA_A, address + toFirstPage);

      rdBuf (flash, NFDC21thisVars->readBackBuffer + toFirstPage, toSecondPage);

      if( tffscmp (pbuffer + toFirstPage, NFDC21thisVars->readBackBuffer + toFirstPage, toSecondPage)) {
    DEBUG_PRINT(("Debug: NFDC 2148 write failed in verification.\r\n"));
    return( flWriteFault );
      }
    }
  }
  else
#endif /* BIG_PAGE_ENABLED */
  {
    rdBuf (flash, NFDC21thisVars->readBackBuffer, length);

    if( tffscmp (pbuffer, NFDC21thisVars->readBackBuffer, length) ) {
      DEBUG_PRINT(("Debug: NFDC 2148 write failed in verification.\r\n"));
      return( flWriteFault );
    }
  }
         /* then ECC and special ANAND mark */

#ifndef NO_EDC_MODE
  if( modes & EDC )
  {
    rdBuf (flash, NFDC21thisVars->readBackBuffer, SYNDROM_BYTES);
    if( tffscmp (syndrom, NFDC21thisVars->readBackBuffer, SYNDROM_BYTES) )
      return( flWriteFault );

    rdBuf (flash, NFDC21thisVars->readBackBuffer, sizeof(anandMark));
    if( tffscmp (anandMark, NFDC21thisVars->readBackBuffer, sizeof(anandMark)) )
      return( flWriteFault );
  }
#endif /* NO_EDC_MODE */

  writeSignals (flash, FLASH_IO | WP);
  waitForReady(flash);                            /* Serial Read Cycle Entry */
#endif /* VERIFY_WRITE */

  return( flOK );
}

/*----------------------------------------------------------------------*/
/*                        d o c 2 W r i t e                             */
/*                                                                      */
/* Write some data to the flash. This routine will be registered as the */
/* write routine for this MTD.                                          */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : Address of sector to write to.                        */
/*      buffer  : buffer to write from.                                 */
/*      length  : number of bytes to write (up to sector size).         */
/*      modes   : OVERWRITE, EDC flags etc.                             */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 on success, otherwise failed.               */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLStatus doc2Write(FLFlash * flash,
              CardAddress address,
              const void FAR1 *buffer,
              dword length,
              word modes)
{
  char FAR1 *temp = (char FAR1 *)buffer;
  FLStatus status;
#ifdef BIG_PAGE_ENABLED
  word block = (word)((modes & EXTRA) ? EXTRA_LEN : SECTOR_SIZE);
#else
  word block = (word)((modes & EXTRA) ? SECTOR_EXTRA_LEN : SECTOR_SIZE);
#endif /* BIG_PAGE_ENABLED */
  word writeNow = block - ((word)address & (block - 1));

#ifdef ENVIRONMENT_VARS
  if(flSuspendMode & FL_SUSPEND_WRITE)
     return flIOCommandBlocked;
#endif /* ENVIRONMENT_VARS */

  /* write in BLOCKs; first and last might be partial */
  chkASICmode(flash);

  while( length > 0 )
  {
     if(writeNow > length)
       writeNow = (word)length;
          /* turn off EDC on partial block write */

    status = writeOneSector(flash, address, temp, writeNow,
             (word)((writeNow != SECTOR_SIZE) ? (modes &= ~EDC) : modes) );
    if(status!=flOK)
      return status;

    length -= writeNow;
    address += writeNow;
    temp += writeNow;
    writeNow = block;          /* align at BLOCK */
  }
  return( flOK );
}
#endif /* FL_READ_ONLY */

/*----------------------------------------------------------------------*/
/*                        r e a d O n e S e c t o r                     */
/*                                                                      */
/* Read up to one 512-byte block from flash.                            */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : Address to read from.                                 */
/*      buffer  : buffer to read to.                                    */
/*      length  : number of bytes to read (up to sector size).          */
/*      modes   : EDC flag etc.                                         */
/*                                                                      */
/* Notes: big_page_enabled does not support PARTIAL_EDC FLAG            */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 on success, otherwise failed.               */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLStatus readOneSector (FLFlash * flash,
                   CardAddress address,
                   void FAR1 *buffer,
                   word length,
                   word modes)
{
#ifndef NO_EDC_MODE
  byte        extraBytes[SYNDROM_BYTES];
#ifdef MTD_STANDALONE
  int         index;
#endif
#endif
  FLStatus    stat = flOK;
  PointerOp   cmd   = AREA_A;            /* default for .... */
  CardAddress addr  = address;           /* .... KM29N16000  */
#ifdef BIG_PAGE_ENABLED
  int  toFirstPage, toSecondPage;
#endif /* BIG_PAGE_ENABLED */

  mapWin(flash, &addr);

  makeCommand(flash, &cmd, &addr, modes);  /* move flash pointer to areas A,B or C of page */

  readCommand(flash, cmd, addr);

#ifndef NO_EDC_MODE
  if( modes & EDC )
    eccONread(flash);
#endif
#ifdef BIG_PAGE_ENABLED
  if( !(flash->flags & BIG_PAGE) )
  {
    /* read up to two pages separately */
    if( modes & EXTRA )
      toFirstPage = EXTRA_LEN - ((word)addr & (EXTRA_LEN-1));
    else
      toFirstPage = CHIP_PAGE_SIZE - ((word)addr & (CHIP_PAGE_SIZE-1));

    if(toFirstPage > length)
      toFirstPage = length;
    toSecondPage = length - toFirstPage;

    rdBuf (flash, (byte FAR1 *)buffer, toFirstPage ); /* starting page */

    if ( toSecondPage > 0 )                  /* next page */
    {
      if( modes & EXTRA )
         addr -= (CHIP_PAGE_SIZE + ((word)addr & (EXTRA_LEN-1)));
      readCommand (flash, cmd, addr + toFirstPage);
      rdBuf(flash, (byte FAR1 *)buffer + toFirstPage, toSecondPage );
    }
  }
  else
#endif /* BIG_PAGE_ENABLED */
  {
    rdBuf(flash, (byte FAR1 *)buffer, length );

#ifndef NO_EDC_MODE
    if((modes & PARTIAL_EDC) &&
       (((word)address & NFDC21thisVars->pageMask) == 0))
    {
       /* Partial page read with EDC must let rest of page through
          the HW edc mechanism */

       word unreadBytes;

       for (unreadBytes = SECTOR_SIZE - length;unreadBytes > 0;unreadBytes--)
       {
          cmd = (PointerOp)flRead8bitReg(flash, NFDC21thisIO);
       }
    }
#endif /* NO_EDC_MODE */
  }

#ifndef NO_EDC_MODE
  if( modes & EDC )
  {       /* read syndrom to let it through the ECC unit */

    rdBuf(flash, extraBytes, SYNDROM_BYTES );

    if( eccError(flash) )  /* An EDC error was found */
    {
#ifdef MTD_STANDALONE
    /* Check if all of the EDC bytes are FF's. If so ignore the EDC     */
    /* assuming that it has'nt been used due to programing of less then */
    /* 512 bytes                                                        */

      for(index=0;index<SYNDROM_BYTES;index++)
      {
        if (extraBytes[index]!=0xFF)
        break;
      }

      if (index!=SYNDROM_BYTES) /* not all of the EDC bytes are FF's */
#endif /* MTD_STANDALONE */

      {
              /* try to fix ECC error */
     if ( modes & NO_SECOND_TRY )             /* 2nd try */
     {
        byte syndrom[SYNDROM_BYTES];
        byte tmp;

        docread(flash->win,Nsyndrom,syndrom,SYNDROM_BYTES);
        tmp = syndrom[0];                     /* Swap 1 and 3 words */
        syndrom[0] = syndrom[4];
        syndrom[4] = tmp;
        tmp = syndrom[1];
        syndrom[1] = syndrom[5];
        syndrom[5] = tmp;

        if( flCheckAndFixEDC( (char FAR1 *)buffer, (char*)syndrom, 1) != NO_EDC_ERROR)
        {
           DEBUG_PRINT(("Debug: EDC error for NFDC 2148.\r\n"));
           stat = flDataError;
        }
     }
     else                                 /* 1st try - try once more */
       return( readOneSector( flash, address, buffer, length,
                  (word)(modes | NO_SECOND_TRY) ) );
      }
    }
    eccOFF(flash);
  }
#endif /* NO_EDC_MODE */

  writeSignals (flash, FLASH_IO | WP);
  if( (modes & EXTRA) &&                    /* Serial Read Cycle Entry */
      ((length + (((word)addr) & (NFDC21thisVars->tailSize - 1)))
    == NFDC21thisVars->tailSize) )
    waitForReady(flash);

  return( stat );
}

/*----------------------------------------------------------------------*/
/*                        d o c 2 R e a d                               */
/*                                                                      */
/* Read some data from the flash. This routine will be registered as    */
/* the read routine for this MTD.                                       */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : Address to read from.                                 */
/*      buffer  : buffer to read to.                                    */
/*      length  : number of bytes to read (up to sector size).          */
/*      modes   : EDC flag etc.                                         */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 on success, otherwise failed.               */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLStatus doc2Read(FLFlash * flash,
             CardAddress address,
             void FAR1 *buffer,
             dword length,
             word modes)
{
  char FAR1 *temp = (char FAR1 *)buffer;
  FLStatus   status;
  word       readNow;

#ifdef BIG_PAGE_ENABLED
  word block = (word)(( modes & EXTRA ) ? EXTRA_LEN : SECTOR_SIZE );
#else
  word block = (word)(( modes & EXTRA ) ? SECTOR_EXTRA_LEN : SECTOR_SIZE );
#endif /* BIG_PAGE_ENABLED */

#ifdef ENVIRONMENT_VARS
  if((flSuspendMode & FL_SUSPEND_IO) == FL_SUSPEND_IO)
     return flIOCommandBlocked;
#endif /* ENVIRONMENT_VARS */

  chkASICmode(flash);
          /* read in BLOCKs; first and last might be partial */

  readNow = block - ((word)address & (block - 1));

  while( length > 0 ) {
    if( readNow > length )
      readNow = (word)length;
          /* turn off EDC on partial block read */
    status = readOneSector(flash, address, temp, readNow, (word)(
             ((readNow != SECTOR_SIZE) && (modes != PARTIAL_EDC)) ?
             modes &=~PARTIAL_EDC : modes));
    if(status != flOK)
      return status;

    length -= readNow;
    address += readNow;
    temp += readNow;
    readNow = block;       /* align at BLOCK */
  }
  return( flOK );
}

#ifndef FL_READ_ONLY

#if (defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT))

/*----------------------------------------------------------------------*/
/*                        c h e c k E r a s e                           */
/*                                                                      */
/* Check if media is truly erased (main areas of page only).            */
/*                                                                      */
/* Note to save on memory consumption the 1k read back buffer is used   */
/* Only when the VERIFY_ERASE compilation flag is set.                  */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : Address of page to check.                             */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 if page is erased, otherwise writeFault.    */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLStatus checkErase( FLFlash * flash, CardAddress address )
{
  register int i, j;
  word inc = READ_BACK_BUFFER_SIZE;
  dword * bufPtr = (dword *)NFDC21thisVars->readBackBuffer;
  CardAddress curAddress = address;
  word block = (word)(flash->erasableBlockSize / inc);
  dword * endBufPtr = bufPtr+(inc / sizeof(dword));
  dword * curBufPtr;

  /* Check main area */
  for ( i = 0 ; i < block ; i++, curAddress += inc )
  {
    if ( doc2Read(flash,curAddress,(void FAR1 *)bufPtr,(dword)inc,0) != flOK )
      return( flWriteFault );

    for ( curBufPtr = bufPtr ;
          curBufPtr < endBufPtr ; curBufPtr++)
      if ( *bufPtr != 0xFFFFFFFFL )
        return( flWriteFault );
  }

  /* Check extra area */
  for ( i = 0 ; i < NFDC21thisVars->pagesPerBlock ; i++,address+=SECTOR_SIZE)
  {
    if ( doc2Read(flash,address,(void FAR1 *)bufPtr,
                  NFDC21thisVars->tailSize, EXTRA) !=  flOK )
      return( flWriteFault );

    for (j=0;j<(NFDC21thisVars->tailSize>>2);j++)
    {
       if (bufPtr[j] != 0xFFFFFFFFL)
         return( flWriteFault );
    }
  }
  return( flOK );
}

#endif /* VERIFY_ERASE or MTD_RECONSTRUCT_BBT */

/*----------------------------------------------------------------------*/
/*                        d o c 2 E r a s e                             */
/*                                                                      */
/* Erase number of blocks. This routine will be registered as the       */
/* erase routine for this MTD.                                          */
/*                                                                      */
/* Note - can not erase all units of 1GB DiskOnChip.                    */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*      blockNo         : First block to erase.                         */
/*      blocksToErase   : Number of blocks to erase.                    */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus                : 0 on success, otherwise failed.       */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLStatus doc2Erase(FLFlash * flash,
              word blockNo,
              word blocksToErase)
{
  FLStatus status = flOK;
  word  floorToUse;
  word  nextFloorBlockNo, i;
  CardAddress startAddress = (CardAddress)blockNo * flash->erasableBlockSize;
  CardAddress address      = startAddress;

#ifdef ENVIRONMENT_VARS
  if(flSuspendMode & FL_SUSPEND_WRITE)
     return flIOCommandBlocked;
#endif /* ENVIRONMENT_VARS */

#ifndef MTD_STANDALONE
  if (flWriteProtected(flash->socket))
    return( flWriteProtect );
#endif /* MTD_STANDALONE */

  if( (dword)((dword)blockNo + (dword)blocksToErase) >
      (dword)((dword)NFDC21thisVars->noOfBlocks * (dword)flash->noOfChips))
    return( flWriteFault );                             /* out of media */

  chkASICmode(flash);
          /* handle erase accross floors */
#ifndef SEPARATED_CASCADED
  floorToUse = (word)(startAddress / NFDC21thisVars->floorSize) + 1;

  if (floorToUse != flash->noOfFloors)
  {
     nextFloorBlockNo = (word)(floorToUse * (NFDC21thisVars->floorSize /
                        flash->erasableBlockSize));

     if( blockNo + blocksToErase > nextFloorBlockNo )
     {           /* erase on higher floors */
        status = ( doc2Erase( flash, nextFloorBlockNo,
        (word)(blocksToErase - (nextFloorBlockNo - blockNo))) );
        blocksToErase = nextFloorBlockNo - blockNo;
        if(status!=flOK)
          return status;
     }
  }
#endif /* SEPARATED_CASCADED */

  /* erase on this floor */

  mapWin (flash, &address);

  for (i = 0; i < blocksToErase ; i++, blockNo++ ) {
    dword pageNo = ((dword)blockNo * NFDC21thisVars->pagesPerBlock);

    command(flash, RESET_FLASH);
    writeSignals (flash, FLASH_IO | CE);
    waitForReady(flash);

    command(flash, SETUP_ERASE);

    writeSignals (flash, FLASH_IO | ALE | CE);
#ifdef SLOW_IO_FLAG
    flWrite8bitReg(flash,NslowIO,(Reg8bitType)pageNo);
    flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)pageNo);
    flWrite8bitReg(flash,NslowIO,(Reg8bitType)(pageNo >> 8));
    flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(pageNo >> 8));
    if( flash->flags & BIG_ADDR ) {
      flWrite8bitReg(flash,NslowIO,(Reg8bitType)(pageNo >> 16));
      flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(pageNo >> 16));
    }
#else
    flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)pageNo);
    flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(pageNo >> 8));
    if( flash->flags & BIG_ADDR )
      flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)(pageNo >> 16));
    if( NFDC21thisVars->flags & MDOC_ASIC )
      flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
#endif /* SLOW_IO_FLAG */
    writeSignals(flash, FLASH_IO | CE);

    /* if only one block may be erase at a time then do it */
    /* otherwise leave it for later                        */

    command(flash, CONFIRM_ERASE);

#ifndef MTD_STANDALONE
#ifndef DO_NOT_YIELD_CPU
    if(waitForReadyWithYieldCPU(flash,MAX_WAIT)==FALSE)
#endif /* DO_NOT_YIELD_CPU */
#endif /* MTD_STANDALONE */
    {
       waitForReady(flash);
    }
    if ( readStatus(flash) & (byte)(FAIL) ) {         /* erase operation failed */
      DEBUG_PRINT(("Debug: NFDC 2148 erase failed.\r\n"));
      status = flWriteFault;

        /* reset flash device and abort */

      command(flash, RESET_FLASH);
      waitForReady(flash);

      break;
    }
    else {                                    /* no failure reported */
#ifdef VERIFY_ERASE

      if ( checkErase( flash, startAddress + i * flash->erasableBlockSize) != flOK ) {
         DEBUG_PRINT(("Debug: NFDC 2148 erase failed in verification.\r\n"));
         return flWriteFault ;
      }

#endif  /* VERIFY_ERASE */
    }
  }       /* block loop */

#ifdef MULTI_ERASE
    /* do multiple block erase as was promised */

  command(flash, CONFIRM_ERASE);
#ifndef MTD_STANDALONE
#ifndef DO_NOT_YIELD_CPU
  waitForReadyWithYieldCPU(flash,MAX_WAIT);
#endif /* DO_NOT_YIELD_CPU */
#endif /* MTD_STANDALONE */
  if ( readStatus(flash) & (byte)(FAIL) ) {        /* erase operation failed */
    DEBUG_PRINT(("Debug: NFDC 2148 erase failed.\r\n"));
    status = flWriteFault;

        /* reset flash device and abort */

    command(flash, RESET_FLASH);
    waitForReady(flash);
  }
#endif   /* MULTI_ERASE */

  writeSignals (flash, FLASH_IO | WP);
  return( status );
}
#endif /* FL_READ_ONLY */

#ifndef MTD_STANDALONE

/*----------------------------------------------------------------------*/
/*                        d o c 2 M a p                                 */
/*                                                                      */
/* Map through buffer. This routine will be registered as the map       */
/* routine for this MTD.                                                */
/*                                                                      */
/* Parameters:                                                          */
/*      flash     : Pointer identifying drive                           */
/*      address : Flash address to be mapped.                           */
/*      length  : number of bytes to map.                               */
/*                                                                      */
/* Returns:                                                             */
/*      Pointer to the buffer data was mapped to.                       */
/*                                                                      */
/*----------------------------------------------------------------------*/

static void FAR0 *doc2Map ( FLFlash * flash, CardAddress address, int length )
{
  doc2Read(flash,address,NFDC21thisBuffer,length, 0);
  /* Force remapping of internal catched sector */
  flash->socket->remapped = TRUE;
  return( (void FAR0 *)NFDC21thisBuffer );
}
#endif /* MTD_STANDALONE */

#ifdef MTD_READ_BBT

/*----------------------------------------------------------------------*/
/*                           R e a d B B T                              */
/*                                                                      */
/*  Read the media Bad Blocks Table to a user buffer.                   */
/*                                                                      */
/*  Parameters:                                                         */
/*  flash         : Pointer identifying drive                           */
/*  unitNo      : indicated which unit number to start checking from.   */
/*  unitToRead  : indicating how many units to check                    */
/*  buffer      : buffer to read into.                                  */
/*  reconstruct : TRUE for reconstruct BBT from virgin card             */
/*                                                                      */
/*  Note: blocks is a minimal flash erasable area.                      */
/*  Note: unit can contain several blocks.                              */
/*  Note: There is no current implementation of a unit that contains    */
/*        more then a single block.                                     */
/*  Note: The format of the BBT is byte per unit 0 for bad any other    */
/*        value for good.                                               */
/*  Note: global variables changed at doc2Read:                         */
/*      global variable NFDC21thisVars->currentFloor is updated         */
/*      flash->socket.window.currentPage = pageToMap;                   */
/*      flash->socket.remapped = TRUE;                                  */
/*  Note: At least 4 bytes must be read                                 */
/*                                                                      */
/*  RETURNS:                                                            */
/*     flOK on success                                                  */
/*     flBadLength if one of the units is out of the units range        */
/*     flBadBBT on read fault                                           */
/*----------------------------------------------------------------------*/
static FLStatus readBBT(FLFlash * flash, dword unitNo, dword unitsToRead,
                        byte blockMultiplier, byte FAR1 * buffer,
                        FLBoolean reconstruct)
{
   CardAddress bbtAddr,floorEndAddr;
   CardAddress addr,floorStartAddr,alignAddr;
   dword       unitsPerFloor = NFDC21thisVars->floorSize >> flash->erasableBlockSizeBits;
   word        curRead,actualRead;
   CardAddress mediaSize = (CardAddress)flash->chipSize*flash->noOfChips;
   FLStatus    status = flOK;
   dword       unitOffset;
   dword       sizeOfBBT;
   word        counter;

   byte FAR1*  bufPtr = buffer;
#if (defined (MTD_RECONSTRUCT_BBT) && !defined(FL_READ_ONLY))
   CardAddress bbtCurAddr;
   dword       i;
   byte        reconstructBBT = 0;
#endif  /* MTD_RECONSTRUCT_BBT && not FL_READ_ONLY */

   /* Arg sanity check */
   if (((dword)(unitNo+unitsToRead) <<
        (blockMultiplier+flash->erasableBlockSizeBits)) > mediaSize)
     return flBadParameter;

   /* Calculate size of BBT blocks */
   for(sizeOfBBT = flash->erasableBlockSize;
       sizeOfBBT < unitsPerFloor ;sizeOfBBT = sizeOfBBT<<1);
#ifndef MTD_STANDALONE
   /* Force remapping of internal catched sector */
   flash->socket->remapped = TRUE;
#endif /* MTD_STANDALONE */
   /* Adjust no' of blocks per floor according to blocks multiplier */
   unitsPerFloor = unitsPerFloor >> blockMultiplier;
   /* Mark all user buffer as good units */
   tffsset(buffer,BBT_GOOD_UNIT,unitsToRead);

   /* Loop over all of the floors */
   for (floorStartAddr  = 0 ; (floorStartAddr < mediaSize) && (unitsToRead > 0);
        floorStartAddr += NFDC21thisVars->floorSize)
   {
      floorEndAddr = TFFSMIN(floorStartAddr+NFDC21thisVars->floorSize,mediaSize);
      /* Look for bbt signature in extra area start looking from last unit */
      for(bbtAddr = floorEndAddr - sizeOfBBT,
          counter = BBT_MAX_DISTANCE;
          (bbtAddr > floorStartAddr) && (counter > 0);
          bbtAddr -= flash->erasableBlockSize , counter--)
      {
         status = doc2Read(flash,bbtAddr+8,NFDC21thisBuffer,BBT_SIGN_SIZE,EXTRA);
         if (status != flOK)
            return flBadBBT;
         if(tffscmp(NFDC21thisBuffer,BBT_SIGN,BBT_SIGN_SIZE)==0)
            break;
      }

      /* No BBT was found virgin card */

      if((bbtAddr==floorStartAddr) || (counter == 0))
      {
#if (defined (MTD_RECONSTRUCT_BBT) && !defined(FL_READ_ONLY))
        if (reconstruct == TRUE)
        {
           reconstructBBT++;
           if (reconstructBBT == 1)
              DFORMAT_PRINT(("\rVirgin card rebuilding unit map.\r\n\n"));

           /* Find good unit for BBT */

           for(bbtAddr = floorEndAddr - sizeOfBBT ;
               bbtAddr > floorStartAddr ;
               bbtAddr -= flash->erasableBlockSize , status = flOK)
           {
              /* Find enough consequtive units for the BBT */
              for(i=0;(status == flOK)&&(i<sizeOfBBT);i+=flash->erasableBlockSize)
              {
                 status = checkErase(flash, bbtAddr+i);
              }
              if(status == flOK)
                 break;
           }
           if (bbtAddr == floorStartAddr) /* Could not find place for BBT */
           {
              DFORMAT_PRINT(("Debug: no good block found.\r\n"));
              return flBadBBT;
           }

           /* Search and mark the entire floor BBT (512 at a time) */

           bbtCurAddr = bbtAddr;
           for (addr=floorStartAddr;
                addr<floorEndAddr; bbtCurAddr+=SECTOR_SIZE)
           {
              /* Mark all blocks as good */
              tffsset(NFDC21thisBuffer,BBT_GOOD_UNIT,SECTOR_SIZE);
              /* Mark IPL as unused */
              for (i=0;i<SECTOR_SIZE;i++,addr+=flash->erasableBlockSize)
              {
            #ifndef NT5PORT
                 DFORMAT_PRINT(("Checking block %u\r",(word)(addr>>flash->erasableBlockSizeBits)));
            #endif// NT5PORT
                 /* Bad block table is marked as unavailable */
                 if ((addr>=bbtAddr) && (addr<bbtAddr+sizeOfBBT))
                 {
                    NFDC21thisBuffer[i] = BBT_UNAVAIL_UNIT;
                 }
                 else /* The unerased blocks are marked as bad */
                 {
                    if(checkErase(flash, addr) != flOK)
                    {
                       NFDC21thisBuffer[i] = BBT_BAD_UNIT;
                    }
                 }
              }
              if(addr == (flash->erasableBlockSize<<SECTOR_SIZE_BITS))
              {
                 /* If IPL unit is good mark it as unavailable */
                 if(NFDC21thisBuffer[0] != BBT_BAD_UNIT)
                   NFDC21thisBuffer[0] = BBT_UNAVAIL_UNIT;
              }
              status = doc2Write(flash,bbtCurAddr,NFDC21thisBuffer,SECTOR_SIZE,EDC);
              if (status != flOK)
              {
                 DFORMAT_PRINT(("ERROR - Failed writting bad block table.\r\n"));
                 return flBadBBT;
              }
           }
           /* Mark bad blocks table with special mark */
           status = doc2Write(flash,bbtAddr+8,BBT_SIGN, BBT_SIGN_SIZE,EXTRA);
        }
        else
#endif  /* MTD_RECONSTRUCT_BBT && not FL_READ_ONLY */
        {
            return flBadBBT;
        }
      }

      /* Return only blocks that are in this floor */
      addr = floorStartAddr >> (flash->erasableBlockSizeBits + blockMultiplier);

      if ((unitNo >= addr) && (unitNo < addr + unitsPerFloor))
      {
         unitOffset   = (unitNo % unitsPerFloor);
         curRead      = ((word)TFFSMIN(unitsToRead,unitsPerFloor - unitOffset));
         unitsToRead -= curRead;

         /* Convert to real number of bytes to read and address */
         unitOffset <<= blockMultiplier;
         curRead    <<= blockMultiplier;
         alignAddr    = ((bbtAddr + unitOffset) >> SECTOR_SIZE_BITS)<<SECTOR_SIZE_BITS;

         do /* Read and copy into buffer 512 blocks at a time */
         {
           if (doc2Read(flash,alignAddr, NFDC21thisBuffer,SECTOR_SIZE,EDC) != flOK)
              return flBadBBT;

           unitOffset = unitOffset % SECTOR_SIZE;
           actualRead = (word)TFFSMIN(SECTOR_SIZE - unitOffset,curRead);
           curRead   -= actualRead;
           /* Copy relevant blocks into user buffer */
           for (actualRead += (word)unitOffset ;
                unitOffset < actualRead ;
                bufPtr = BYTE_ADD_FAR(bufPtr,1)) /* increment buffer */
           {
             for (counter = 1 << blockMultiplier ; counter > 0 ;
                  counter-- , unitOffset++)
             {
                if (NFDC21thisBuffer[unitOffset] != BBT_GOOD_UNIT)
                {
                  *bufPtr = NFDC21thisBuffer[unitOffset];
                }
             }
           }
           alignAddr+=SECTOR_SIZE;
         }while(curRead > 0);

         if (unitsToRead > 0)
            unitNo = addr + unitsPerFloor;
      }
   }

#if (defined (MTD_RECONSTRUCT_BBT) && !defined(FL_READ_ONLY))
   if (reconstructBBT > 0)
      DFORMAT_PRINT(("\rMedia has been scanned.       \r\n"));
#endif  /* MTD_RECONSTRUCT_BBT && not FL_READ_ONLY */

   return flOK;
}
#endif /* MTD_READ_BBT */

/*----------------------------------------------------------------------*/
/*                        i s K n o w n M e d i a                       */
/*                                                                      */
/* Check if this flash media is supported. Initialize relevant fields   */
/* in data structures.                                                  */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*      vendorId_P      : vendor ID read from chip.                     */
/*      chipId_p        : chip ID read from chip.                       */
/*      dev             : dev chips were accessed before this one.      */
/*                                                                      */
/* Returns:                                                             */
/*      TRUE if this media is supported, FALSE otherwise.               */
/*                                                                      */
/*----------------------------------------------------------------------*/

static FLBoolean isKnownMedia( FLFlash * flash, Reg8bitType vendorId_p, Reg8bitType chipId_p, int dev )
{
  if((dev == 0)
#ifndef SEPARATED_CASCADED
     && (NFDC21thisVars->currentFloor == 0)
#endif /* SEPARATED_CASCADED */
    ) {  /* First Identification */
    NFDC21thisVars->vendorID = (word)vendorId_p;  /* remember for next chips */
    NFDC21thisVars->chipID = (word)chipId_p;
    NFDC21thisVars->pagesPerBlock = PAGES_PER_BLOCK;
    flash->maxEraseCycles = 1000000L;
    flash->flags       |= BIG_PAGE;
    flash->pageSize = 0x200;
    switch( (byte)vendorId_p ) {
      case 0xEC :                  /* Samsung */
     switch( (byte)chipId_p ) {
#ifdef BIG_PAGE_ENABLED
       case 0x64 :             /* 2 Mb */
       case 0xEA :
          flash->type    = KM29N16000_FLASH;
          flash->pageSize = 0x100;
          flash->chipSize     = 0x200000L;
          flash->flags       &= ~BIG_PAGE;
          break;
#endif /* BIG_PAGE_ENABLED */
       case 0xE3 :             /* 4 Mb */
       case 0xE5 :
          flash->type    = KM29N32000_FLASH;
          flash->chipSize     = 0x400000L;
          break;

       case 0xE6 :             /* 8 Mb */
          flash->type    = KM29V64000_FLASH;
          flash->chipSize     = 0x800000L;
          break;

       case 0x73 :             /* 16 Mb  */
          flash->type    = KM29V128000_FLASH;
          flash->chipSize     = 0x1000000L;
          NFDC21thisVars->pagesPerBlock *= 2;
          break;

       case 0x75 :             /* 32 Mb */
          flash->type    = KM29V256000_FLASH;
          flash->chipSize     = 0x2000000L;
          NFDC21thisVars->pagesPerBlock *= 2;
          break;

       case 0x76 :             /* 64 Mb */
          flash->type    = KM29V512000_FLASH;
          flash->chipSize     = 0x4000000L;
          flash->flags       |= BIG_ADDR;
          NFDC21thisVars->pagesPerBlock *= 2;
          break;

       default :                    /* Undefined Flash */
          return(FALSE);
     }
     break;

      case 0x98 :                  /* Toshiba */
     switch( chipId_p ) {
#ifdef BIG_PAGE_ENABLED
       case 0x64 :             /* 2 Mb */
       case 0xEA :
          flash->type    = TC5816_FLASH;
          flash->pageSize = 0x100;
          flash->chipSize     = 0x200000L;
          flash->flags       &= ~BIG_PAGE;
          break;
#endif /* BIG_PAGE_ENABLED */
       case 0x6B :             /* 4 Mb */
       case 0xE5 :
          flash->type    = TC5832_FLASH;
          flash->chipSize     = 0x400000L;
          break;

       case 0xE6 :             /* 8 Mb */
          flash->type    = TC5864_FLASH;
          flash->chipSize     = 0x800000L;
          break;

       case 0x73 :             /* 16 Mb */
          flash->type    = TC58128_FLASH;
          flash->chipSize     = 0x1000000L;
          NFDC21thisVars->pagesPerBlock *= 2;
          break;

       case 0x75 :             /* 32 Mb */
          flash->type    = TC58256_FLASH;
          flash->chipSize     = 0x2000000L;
          NFDC21thisVars->pagesPerBlock *= 2;
          break;

       case 0x76 :             /* 64 Mb */
          flash->type    = TC58512_FLASH;
          flash->chipSize     = 0x4000000L;
          flash->flags       |= BIG_ADDR;
          NFDC21thisVars->pagesPerBlock *= 2;
          break;

       case 0x79:             /* 128 Mb */
          flash->type    = TC581024_FLASH;
          flash->chipSize     = 0x8000000L;
          flash->flags       |= BIG_ADDR;
          NFDC21thisVars->pagesPerBlock *= 2;
          break;

       default :                    /* Undefined Flash */
          return( FALSE );
     }
     flash->flags |= FULL_PAGE;    /* no partial page programming */
     break;

      default :                         /* Undefined Flash */
     return( FALSE );
    }
    return( TRUE );
  }
  else                                  /* dev != 0 */
    if( (vendorId_p == NFDC21thisVars->vendorID) && (chipId_p == NFDC21thisVars->chipID) )
      return( TRUE );

  return( FALSE );
}

/*----------------------------------------------------------------------*/
/*                        r e a d F l a s h I D                         */
/*                                                                      */
/* Read vendor and chip IDs, count flash devices. Initialize relevant   */
/* fields in data structures.                                           */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*      dev             : dev chips were accessed before this one.      */
/*                                                                      */
/* Returns:                                                             */
/*      TRUE if this media is supported, FALSE otherwise.               */
/*                                                                      */
/*----------------------------------------------------------------------*/

static int  readFlashID ( FLFlash * flash, int dev )
{
  byte vendorId_p, chipId_p;
  register int i;
  volatile Reg8bitType junk = 0;

  command (flash, READ_ID);

  writeSignals (flash, FLASH_IO | ALE | CE | WP);
#ifdef SLOW_IO_FLAG
  flWrite8bitReg(flash,NslowIO,(Reg8bitType)0);
#endif
  flWrite8bitReg(flash,NFDC21thisIO,(Reg8bitType)0);
  if( NFDC21thisVars->flags & MDOC_ASIC )
    flWrite8bitReg(flash,NwritePipeTerm,(Reg8bitType)0);
  writeSignals (flash, FLASH_IO | CE | WP);

        /* read vendor ID */

  flDelayMsecs( 10 );                         /* 10 microsec delay */
  for( i = 0;( i < 2 ); i++ )   /* perform 2 reads from NOP reg for delay */
    junk += flRead8bitReg(flash,NNOPreg);
  if( NFDC21thisVars->flags & MDOC_ASIC ) {
    junk += flRead8bitReg(flash,NreadPipeInit); /* load first data into pipeline */
    vendorId_p = flRead8bitReg(flash,NreadLastData); /* finally read vendor ID */
  }
  else {
    junk += flRead8bitReg(flash,NslowIO); /* read CDSN_slow_IO ignoring the data */
    vendorId_p = flRead8bitReg(flash,NFDC21thisIO); /* finally read vendor ID */
  }

        /* read chip ID */

  flDelayMsecs( 10 );                         /* 10 microsec delay */
  for( i = 0;( i < 2 ); i++ )   /* perform 2 reads from NOP reg for delay */
    junk += flRead8bitReg(flash,NNOPreg);
  if( NFDC21thisVars->flags & MDOC_ASIC ) {
    junk += flRead8bitReg(flash,NreadPipeInit); /* load first data into pipeline */
    chipId_p = flRead8bitReg(flash,NreadLastData); /* finally read chip ID */
  }
  else {
    junk += flRead8bitReg(flash,NslowIO); /* read CDSN_slow_IO ignoring the data */
    chipId_p = flRead8bitReg(flash,NFDC21thisIO); /* finally read chip ID */
  }

  if ( isKnownMedia(flash, vendorId_p, chipId_p, dev) != TRUE )    /* no chip or diff. */
    return( FALSE );                                              /* type of flash    */

  flash->noOfChips++;

  writeSignals (flash, FLASH_IO);

        /* set flash parameters */
   if((dev == 0)
#ifndef SEPARATED_CASCADED
    && (NFDC21thisVars->currentFloor == 0)
#endif /* SEPARATED_CASCADED */
     )
  {
    NFDC21thisVars->pageAreaSize   = 0x100;

#ifdef BIG_PAGE_ENABLED
    if ( !(flash->flags & BIG_PAGE) )
      NFDC21thisVars->tailSize = EXTRA_LEN;      /* = 8 */
    else
#endif /* BIG_PAGE_ENABLED */
      NFDC21thisVars->tailSize = SECTOR_EXTRA_LEN;  /* = 16 */

    NFDC21thisVars->pageMask   = (word)(flash->pageSize  - 1);
    flash->erasableBlockSize   = NFDC21thisVars->pagesPerBlock * flash->pageSize;
    NFDC21thisVars->noOfBlocks = (word)( flash->chipSize / flash->erasableBlockSize );
    NFDC21thisVars->if_cfg     = 8;
  }

  return( TRUE );
}

/*----------------------------------------------------------------------*/
/*                        d o c 2 I d e n t i f y                       */
/*                                                                      */
/* Identify flash. This routine will be registered as the               */
/* identification routine for this MTD.                                 */
/*                                                                      */
/* Parameters:                                                          */
/*      flash             : Pointer identifying drive                   */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 on success, flUnknownMedia failed.          */
/*                                                                      */
/*----------------------------------------------------------------------*/
#ifndef MTD_STANDALONE
static
#endif
FLStatus doc2000Identify(FLFlash * flash)
{
  dword  address = 0L;
  int maxDevs, dev;
  volatile Reg8bitType toggle1;
  volatile Reg8bitType toggle2;
  byte     floorCnt = 0;
  byte     floor = 0;

#ifdef NT5PORT
  byte     socketNo = (byte)flSocketNoOf(flash->socket);
#else
  byte     socketNo = flSocketNoOf(flash->socket);
#endif NT5PORT


  DEBUG_PRINT(("Debug: entering NFDC 2148 identification routine.\r\n"));

  flash->mtdVars = &docMtdVars[socketNo];

#ifndef FL_NO_USE_FUNC
  /* Initialize socket memory access routine */
  if(setBusTypeOfFlash(flash, flBusConfig[socketNo] |
                       FL_8BIT_DOC_ACCESS | FL_8BIT_FLASH_ACCESS))
     return flUnknownMedia;
#endif /* FL_NO_USE_FUNC */


#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT))
  /* Get pointer to read back buffer */
  NFDC21thisVars->readBackBuffer = flReadBackBufferOf(socketNo);
#endif /* VERIFY_WRITE || VERIFY_ERASE || MTD_RECONSTRUCT_BBT */

#ifndef MTD_STANDALONE
  /* get pointer to buffer (we assume SINGLE_BUFFER is not defined) */
  NFDC21thisVars->buffer = flBufferOf(socketNo);

  flSetWindowBusWidth(flash->socket, 16);/* use 8-bits */
  flSetWindowSpeed(flash->socket, 250);  /* 250 nsec. */
#else
#ifdef MTD_READ_BBT
  NFDC21thisVars->buffer = &globalMTDBuffer;
#endif /* MTD_READ_BBT */
#endif /* MTD_STANDALONE */

  /* assume flash parameters for KM29N16000 */

  NFDC21thisVars->floorSize = 1L;
#ifdef SEPARATED_CASCADED
/*  NFDC21thisVars->currentFloor = flSocketNoOf(flash->socket);*/
#else
  flash->noOfFloors = MAX_FLOORS;
  NFDC21thisVars->currentFloor = MAX_FLOORS;
#endif /* SEPARATED_CASCADED */
  flash->noOfChips = 0;
  flash->chipSize = 0x200000L;     /* Assume something ... */
  flash->interleaving = 1;       /* unimportant for now  */

  /* detect card - identify bit toggles on consequitive reads */

  NFDC21thisWin = (NDOC2window)flMap(flash->socket, 0);
  flash->win    = NFDC21thisWin;
  if (NFDC21thisWin == NULL)
     return flUnknownMedia;

  setASICmode (flash, ASIC_RESET_MODE);
  setASICmode (flash, ASIC_NORMAL_MODE);

  switch (flRead8bitReg(flash,NchipId))
  {
     case CHIP_ID_MDOC:
        /* Mdoc and alon asics have the same ID only on
           the forth read distigushes them */
        for(dev=0;dev<3;dev++)
          toggle1 = flRead8bitReg(flash,NchipId);
        if (toggle1 != CHIP_ID_MDOC)
        {
           flash->mediaType = DOC2000TSOP_TYPE;
        }
        else
        {
           flash->mediaType = MDOC_TYPE;
        }
        NFDC21thisVars->flags |= MDOC_ASIC;
        NFDC21thisVars->win_io = NIPLpart2;
        break;

     case CHIP_ID_DOC: /* Doc2000 */
        NFDC21thisVars->flags &= ~MDOC_ASIC;
        NFDC21thisVars->win_io = Nio;
        flash->mediaType = DOC_TYPE;
        break;

    default:
       DEBUG_PRINT(("Debug: failed to identify NFDC 2148.\r\n"));
       return( flUnknownMedia );
  }
  mapWin (flash, &address);

  if( NFDC21thisVars->flags & MDOC_ASIC ) {
    toggle1 = flRead8bitReg(flash,NECCconfig);
    toggle2 = toggle1 ^ flRead8bitReg(flash,NECCconfig);
  }
  else {
    toggle1 = flRead8bitReg(flash,NECCstatus);
    toggle2 = toggle1 ^ flRead8bitReg(flash,NECCstatus);
  }
  if ( (toggle2 & TOGGLE) == 0 ) {
    DEBUG_PRINT(("Debug: failed to identify NFDC 2148.\r\n"));
    return( flUnknownMedia );
  }

       /* reset all flash devices */
  maxDevs = MAX_FLASH_DEVICES_DOC;

#ifndef SEPARATED_CASCADED
  for ( NFDC21thisVars->currentFloor = 0 ;
    NFDC21thisVars->currentFloor < MAX_FLOORS ;
    NFDC21thisVars->currentFloor++ )
  {
  /* select floor */
    flWrite8bitReg(flash,NASICselect,(Reg8bitType)NFDC21thisVars->currentFloor);
#endif /* SEPARATED_CASCADED  */
    for ( dev = 0 ; dev < maxDevs ; dev++ ) {
      selectChip(flash, (Reg8bitType)dev );
      command(flash, RESET_FLASH);
    }
#ifndef SEPARATED_CASCADED
  }

  NFDC21thisVars->currentFloor = (byte)0;
  /* back to ground floor */
  flWrite8bitReg(flash,NASICselect,(Reg8bitType)NFDC21thisVars->currentFloor);
#endif /* SEPARATED_CASCADED  */
  writeSignals (flash, FLASH_IO | WP);

       /* identify and count flash chips, figure out flash parameters */
#ifndef SEPARATED_CASCADED
  for( floor = 0; floor < MAX_FLOORS;  floor++ )
#endif /* SEPARATED_CASCADED  */
  for ( dev = 0; dev < maxDevs;  dev++ )
  {
     dword  addr = address;

     mapWin(flash, &addr);

     if ( readFlashID(flash, dev) == TRUE ) /* identified OK */
     {
        floorCnt = (byte)(floor + 1);
#ifndef SEPARATED_CASCADED
    if (floor == 0)
#endif /* SEPARATED_CASCADED  */
      NFDC21thisVars->floorSize += flash->chipSize * flash->interleaving;
      address += flash->chipSize * flash->interleaving;
     }
     else
     {
#ifndef SEPARATED_CASCADED
        if (floor != 0)
        {
       dev = maxDevs;
       floor = MAX_FLOORS;
    }
        else
#endif /* SEPARATED_CASCADED  */
        {
       maxDevs = dev;
       NFDC21thisVars->floorSize = maxDevs * flash->chipSize * flash->interleaving;
    }
     }
  }
#ifndef SEPARATED_CASCADED
  NFDC21thisVars->currentFloor = (byte)0;
#endif /* SEPARATED_CASCADED  */
  flWrite8bitReg(flash,NASICselect,(Reg8bitType)NFDC21thisVars->currentFloor); /* back to ground floor */

  if (flash->noOfChips == 0) {
    DEBUG_PRINT(("Debug: failed to identify NFDC 2148.\r\n"));
    return( flUnknownMedia );
  }

  address = 0L;
  mapWin (flash, &address);

  flash->noOfFloors = floorCnt;

  eccOFF(flash);

  /* Register our flash handlers */
#ifndef FL_READ_ONLY
  flash->write = doc2Write;
  flash->erase = doc2Erase;
#else
  flash->erase = NULL;
  flash->write = NULL;
#endif
  flash->read = doc2Read;
#ifndef MTD_STANDALONE
  flash->map = doc2Map;
#else
  flash->map = NULL;
#endif /* MTD_STANDALONE */

  /* doc2000 tsop uses INFTL instead of NFTL , does not use
   * the last block and has a readBBT routine
   */

  if (flash->mediaType == DOC2000TSOP_TYPE)
  {
#ifdef MTD_READ_BBT
     flash->readBBT         = readBBT;
#endif /* MTD_READ_BBT */
#ifndef NO_IPL_CODE
     flash->download        = forceDownLoad;
#ifndef FL_READ_ONLY
     flash->writeIPL        = writeIPL;
#endif /* FL_READ_ONLY */
#endif /* NO_IPL_CODE */
     flash->flags          |= INFTL_ENABLED;
  }
  else
  {
     flash->flags  |= NFTL_ENABLED;
  }
#ifndef SEPARATED_CASCADED
  if (flash->mediaType == MDOC_TYPE)
      flash->flags |= EXTERNAL_EPROM; /* Supports external eprom */
#endif /* SEPARATED_CASCADED */

  DEBUG_PRINT(("Debug: identified NFDC 2148.\r\n"));
  return( flOK );
}

#ifndef MTD_STANDALONE

/*----------------------------------------------------------------------*/
/*                  f l R e g i s t e r D O C S O C                     */
/*                                                                      */
/* Installs routines for DiskOnChip 2000 family.                        */
/*                                                                      */
/* Parameters:                                                          */
/*      lowAddress,                                                     */
/*      highAddress     : host memory range to search for DiskOnChip    */
/*                        2000 memory window                            */
/*                                                                      */
/* Returns:                                                             */
/*    FLStatus    : 0 on success, otherwise failure                     */
/*----------------------------------------------------------------------*/
#ifndef NT5PORT
FLStatus flRegisterDOCSOC(dword lowAddress, dword highAddress)
{
  int serialNo;

  if( noOfSockets >= SOCKETS )
    return flTooManyComponents;

  for(serialNo=0;( noOfSockets < SOCKETS );serialNo++,noOfSockets++)
  {
     FLSocket * socket = flSocketOf(noOfSockets);

     socket->volNo = noOfSockets;

     docSocketInit(socket);

     /* call DiskOnChip MTD's routine to search for memory window */

     flSetWindowSize(socket, 2);    /* 4 KBytes */

     socket->window.baseAddress = flDocWindowBaseAddress
          ((byte)socket->volNo, lowAddress, highAddress, &lowAddress);

     if (socket->window.baseAddress == 0)    /* DiskOnChip not detected */
       break;
  }
  if( serialNo == 0 )
    return flAdapterNotFound;

  return flOK;
}
#endif /*NT5PORT*/
#else /* MTD_STANDALONE */

/*----------------------------------------------------------------------*/
/*            d o c 2 0 0 0 S e a r c h F o r W i n d o w               */
/*                                                                      */
/* Search for the DiskOnChip ASIC in a given memory range and           */
/* initialize the given socket record.                                  */
/*                                                                      */
/* Parameters:                                                          */
/*      socket      :   Record used to store the sockets parameters     */
/*      lowAddress  :   host memory range to search for DiskOnChip 2000 */
/*      highAddress :   memory window                                   */
/*                                                                      */
/* Output:  initialize the following fields in the FLFlash record:      */
/*                                                                      */
/*      base  -  Pointer to DiskOnChip window                           */
/*      size  -  DiskOnChip window size usualy 8K                       */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus    : 0 on success, flDriveNotAvailable on failure.     */
/*                                                                      */
/* NOTE: This routine is not used by OSAK. It is used by standalone     */
/*       applications using the MTD (BDK for example) as a replacement  */
/*       for the OSAK DOCSOC.C file.                                    */
/*       The FLSocket record used by this function is not the one used  */
/*       by OSAK defined in flsocket.h but a replacement record defined */
/*       in flflash.h.                                                  */
/*                                                                      */
/*----------------------------------------------------------------------*/

FLStatus doc2000SearchForWindow(FLSocket * socket,
             dword lowAddress,
             dword highAddress)
{
    dword baseAddress;   /* Physical base as a 4K page */

    socket->size = 2 * 0x1000L;         /* 4 KBytes */
    baseAddress = (dword) flDocWindowBaseAddress(0, lowAddress, highAddress, &lowAddress);
    socket->base = physicalToPointer(baseAddress << 12, socket->size,0);
    if (baseAddress)    /* DiskOnChip detected */
      return flOK;
    else                        /* DiskOnChip not detected */
      return flDriveNotAvailable;
}

/*----------------------------------------------------------------------*/
/*                d o c 2 0 0 0 F r e e W i n d o w                     */
/*                                                                      */
/* Free any resources used for the DiskOnChip window                    */
/*                                                                      */
/* Parameters:                                                          */
/*      socket      :   Record used to store the sockets parameters     */
/*                                                                      */
/* Returns: None                                                        */
/*                                                                      */
/* NOTE: This routine is used only by virtual memory systems in order   */
/*       to unmap the DiskOnChip window.                                */
/*                                                                      */
/*----------------------------------------------------------------------*/

void doc2000FreeWindow(FLSocket * socket)
{
   freePointer(socket->base,DOC_WIN);
}
#endif /* MTD_STANDALONE */

/*----------------------------------------------------------------------*/
/*                      f l R e g i s t e r D O C 2 0 0 0               */
/*                                                                      */
/* Registers this MTD for use                                           */
/*                                                                      */
/* Parameters:                                                          */
/*      None                                                            */
/*                                                                      */
/* Returns:                                                             */
/*      FLStatus        : 0 on success, otherwise failure               */
/*----------------------------------------------------------------------*/

FLStatus flRegisterDOC2000(void)
{
  if (noOfMTDs >= MTDS)
    return( flTooManyComponents );

#ifdef MTD_STANDALONE
  socketTable[noOfMTDs] = doc2000SearchForWindow;
  freeTable[noOfMTDs]   = doc2000FreeWindow;
#endif /* MTD_STANDALONE */

  mtdTable[noOfMTDs++]  = doc2000Identify;

  return( flOK );
}