|
|
/*
* $Log: V:/Flite/archives/TrueFFS5/Src/FLFLASH.H_V $ * * Rev 1.17 Apr 15 2002 07:36:44 oris * Removed the use of NDOC2window in access routine interface. * FL_NO_USE_FUNC now removes all of the access routines pointers. * * Rev 1.16 Feb 19 2002 20:59:44 oris * Bug fix changed definition of FL_IPL_MODE_XSCALE from 3 to 4. * * Rev 1.15 Jan 29 2002 20:08:26 oris * Changed FLAccessStruct definition to prevent compilation errors. * Added FL_IPL_MODE_XSCALE definition and change FL_IPL_XXX values. * * Rev 1.14 Jan 28 2002 21:24:48 oris * Added FL_IPL_DOWNLOAD flag to writeIPL routine in order to control whether the IPL will be reloaded after the update. * Added FLAccessStruct definition - used to get and set DiskOnChip memory access routines. * Removed win_io field from FLFlash record. * * Rev 1.13 Jan 23 2002 23:31:34 oris * Missing declaration of globalReadBack buffer, when MTD_RECONSTRUCT is defined. * * Rev 1.12 Jan 21 2002 20:44:32 oris * Bug fix - PARTIAL_EDC flag was support to incorporate EDC flag. * * Rev 1.11 Jan 20 2002 09:44:00 oris * Bug fix - changed include directive of flBuffer.h to flbuffer.h * * Rev 1.10 Jan 17 2002 23:01:28 oris * Added flFlashOf() prototype. * New memory access routines mechanism : * - Added memory access routines pointers in FLFlash. * - Added win_io and win fields to FLFlash record pointing to DiskOnChip IO registers and window base. * - Added busAccessType. * Moved CardAddress typedef and NDOC2window typedefs from flbase.h * Added DiskOnChip Millennium Plus 16MB type MDOCP_16_TYPE. * Added the following definitions FL_IPL_MODE_NORMAL / FL_IPL_MODE_SA / MAX_PROTECTED_PARTITIONS /MAX_SECTORS_PER_BLOCK * Added Another flag to writeIPL for Strong Arm mode. * * Rev 1.9 Sep 15 2001 23:46:08 oris * Changed erase routine to support up to 64K erase blocks. * Added reconstruct flag to readBBT routine - stating whether to reconstruct BBT if it is not available. * * Rev 1.8 Jul 13 2001 01:04:48 oris * Added include directive to flBuffer and readBack buffer forward definition under the MTD_STANDALONE compilation flag. * Added volNo field to the socket record under the MTD_STANDALONE compilation flag. * Added definition for PARTIAL_EDC flash read mode. * Added protection default key. * Added bad block marking in the BBT (BBT_BAD_UNIT). * Moved syndrome length definition to reedsol files. * Added new field in FLFlash record - Max Erase Cycles of the flash. * Changed interleave field in FLFlash record to signed. * * Rev 1.7 May 16 2001 21:18:30 oris * Moved SYNDROM_BYTES definition from diskonc.h and mdocplus.h. * Added forward definition for saveSyndromForDumping global EDC\ECC syndrome buffer. * Changed DATA definition to FL_DATA. * * Rev 1.6 May 02 2001 06:40:58 oris * Removed the lastUsableBlock variable. * Added the BBT_UNAVAIL_UNIT defintion. * * Rev 1.5 Apr 24 2001 17:08:12 oris * Added lastUsableBlock field and changed firstUsableBlock type to dword. * * Rev 1.4 Apr 16 2001 13:40:48 oris * Added firstUsableBlock. * Removed warrnings by changing some of the fields types. * * Rev 1.3 Apr 12 2001 06:51:12 oris * Changed protectionBounries and protectionSet routine to be floor specific. * Changed powerdown prototype. * Added download prototype. * * Rev 1.2 Apr 01 2001 07:54:24 oris * copywrite notice. * Moved protection attributes definition from mdocplus.h * Changed prototype of routine pointers in flflash struct :read,write routines to dword length. * Other routine pointer prototypes have been changed as well. * Removed interface b routine pointers from flflash struct (experimental MTD interface for mdocp). * Changed prototype of :read,write routine to enabled dword length. * Changed unsigned char to byte. * Changed unsigned long to dword. * Changed long int to Sdword. * Spelling mistake "changable". * * Rev 1.1 Feb 13 2001 01:37:38 oris * Changed ENTER_DEEP_POWER_DOWN_MODE to DEEP_POWER_DOWN * Changed LOCKED to LOCKED_OTP * * Rev 1.0 Feb 04 2001 11:30:44 oris * Initial revision. * */
/***********************************************************************************//* M-Systems Confidential *//* Copyright (C) M-Systems Flash Disk Pioneers Ltd. 1995-2001 *//* All Rights Reserved *//***********************************************************************************//* NOTICE OF M-SYSTEMS OEM *//* SOFTWARE LICENSE AGREEMENT *//* *//* THE USE OF THIS SOFTWARE IS GOVERNED BY A SEPARATE LICENSE *//* AGREEMENT BETWEEN THE OEM AND M-SYSTEMS. REFER TO THAT AGREEMENT *//* FOR THE SPECIFIC TERMS AND CONDITIONS OF USE, *//* OR CONTACT M-SYSTEMS FOR LICENSE ASSISTANCE: *//* E-MAIL = [email protected] *//***********************************************************************************/
#ifndef FLFLASH_H
#define FLFLASH_H
#include "flbase.h"
#ifndef MTD_STANDALONE
#include "flsocket.h"
#else
#include "flbuffer.h" /* defintion for READ_BACK_BUFFER_SIZE */
typedef struct tSocket FLSocket; struct tSocket { unsigned volNo; /* Volume no. of socket */ void FAR0 * base; /* Pointer to window base */ Sdword size; /* Window size (must by power of 2) */ };
#if (defined (VERIFY_WRITE) || defined(VERIFY_ERASE) || defined(MTD_RECONSTRUCT_BBT))
extern byte globalReadBack[SOCKETS][READ_BACK_BUFFER_SIZE];#endif /* VERIFY_WRITE */
extern FLSocket *flSocketOf(unsigned volNo);extern FLBuffer globalMTDBuffer;extern int noOfMTDs;
/* Replacement for various TrueFFS typedefs */
typedef unsigned long CardAddress; /* Physical offset on card */
#endif /* MTD_STANDALONE */
/* Some useful types for mapped Flash locations */
typedef volatile byte FAR0 * FlashPTR;typedef volatile unsigned short int FAR0 * FlashWPTR;typedef volatile dword FAR0 * FlashDPTR;typedef unsigned short FlashType; /* JEDEC id */typedef volatile unsigned char FAR0* NDOC2window;
/* DiskOnChip memory access routines type defintions */
/* Doc memory read routine */typedef void (FLMemRead)(volatile byte FAR1* win,word regOffset,byte FAR1* dest,word count);/* Doc memory write routine */typedef void (FLMemWrite)(volatile byte FAR1* win,word regOffset,byte FAR1* src,word count);/* Doc memory set routine */typedef void (FLMemSet)(volatile byte FAR1* win,word regOffset,word count, byte val);/* Doc memory 8 bit read routine */typedef byte (FLMemRead8bit)(volatile byte FAR1* win,word offset);/* Doc memory 8 bit write routine */typedef void (FLMemWrite8bit)(volatile byte FAR1* win,word offset,byte Data);/* Doc memory 16 bit read routine */typedef word (FLMemRead16bit)(volatile byte FAR1* win,word offset);/* Doc memory 16 bit write routine */typedef void (FLMemWrite16bit)(volatile byte FAR1* win,word offset,word Data);/* Doc memory window size */typedef dword (FLMemWindowSize)(void);
typedef struct { /* DiskOnChip memory access routines */ dword access; /* Output only */ FLMemRead FAR1* memRead; FLMemWrite FAR1* memWrite; FLMemSet FAR1* memSet; FLMemRead8bit FAR1* memRead8bit; FLMemWrite8bit FAR1* memWrite8bit; FLMemRead16bit FAR1* memRead16bit; FLMemWrite16bit FAR1* memWrite16bit; FLMemWindowSize FAR1* memWindowSize;}FLAccessStruct;
#define NOT_FLASH 0
/* Media types */#define NOT_DOC_TYPE 0
#define DOC_TYPE 1
#define MDOC_TYPE 2
#define DOC2000TSOP_TYPE 3
#define MDOCP_TYPE 4
#define MDOCP_16_TYPE 5
/* page characteristics flags */#define BIG_PAGE 0x0100 /* page size > 100H*/
#define FULL_PAGE 0x0200 /* no partial page programming*/
#define BIG_ADDR 0x0400 /* 4 byte address cycle */
/* MTD write routine mode flags */#define FL_DATA 0 /* Read/Write data area */
#define OVERWRITE 1 /* Overwriting non-erased area */
#define EDC 2 /* Activate ECC/EDC */
#define EXTRA 4 /* Read/write spare area */
#define PARTIAL_EDC 10 /* Read with EDC even for partial page */
#define NO_SECOND_TRY 0x8000 /* do not read again on EDC error */
/* Protection attributes */
#define PROTECTABLE 1 /* partition can recieve protection */
#define READ_PROTECTED 2 /* partition is read protected */
#define WRITE_PROTECTED 4 /* partition is write protected */
#define LOCK_ENABLED 8 /* HW lock signal is enabled */
#define LOCK_ASSERTED 16 /* HW lock signal is asserted */
#define KEY_INSERTED 32 /* key is inserted (not currently */
#define CHANGEABLE_PROTECTION 64 /* changeable protection area type */
/* protection specific defintions */#define DO_NOT_COMMIT_PROTECTION 0 /* The new values will take affect only after reset */
#define COMMIT_PROTECTION 1 /* The new values will take affect imidiatly */
#define PROTECTION_KEY_LENGTH 8 /* Size of protection key in bytes */
#define MAX_PROTECTED_PARTITIONS 2 /* Max Number of protected partitiosn */
#define DEFAULT_KEY "00000000"
/* IPL modes */#define FL_IPL_MODE_NORMAL 0 /* IPL - Written as usual */
#define FL_IPL_DOWNLOAD 1 /* IPL - Force download of new IPL */
#define FL_IPL_MODE_SA 2 /* IPL - Written with Strong Arm mode enabled */
#define FL_IPL_MODE_XSCALE 4 /* IPL - Written with X-Scale mode enabled */
/* OTP specific defintions */#define CUSTOMER_ID_LEN 4
#define UNIQUE_ID_LEN 16
/* BBT block types */#define BBT_GOOD_UNIT 0xff
#define BBT_UNAVAIL_UNIT 0x1
#define BBT_BAD_UNIT 0x0
/* General purpose */#define MAX_SECTORS_PER_BLOCK 64
/*----------------------------------------------------------------------*//* Flash array identification structure *//* *//* This structure contains a description of the Flash array and *//* routine pointers for the map, read, write & erase functions. *//* *//* The structure is initialized by the MTD that identifies the Flash *//* array. *//* On entry to an MTD, the Flash structure contains default routines *//* for all operations. This routines are sufficient forread-only access *//* to NOR Flash on a memory-mapped socket. The MTD should override the *//* default routines with MTD specific ones when appropriate. *//*----------------------------------------------------------------------*/
/* Flash array identification structure */
typedef struct tFlash FLFlash; /* Forward definition */
struct tFlash { FlashType type; /* Flash device type (JEDEC id) */ byte mediaType; /* see media types obove */ byte ppp; /* number of allowed PPP */ dword busAccessType; /* saves bus access type */ dword maxEraseCycles; /* erase cycles limit per erase block */ dword changeableProtectedAreas; /* areas capable of changing protection */ /* attribute with no danger of loosing */ /* the entire chip */ byte totalProtectedAreas; /* total number of protection arweas */ dword erasableBlockSize; /* Smallest physically erasable size */ /* (with interleaving taken into account) */ byte erasableBlockSizeBits;/* Bits representing the erasable block */ dword chipSize; /* chip size */ byte noOfFloors; /* no of controllers in array */ word pageSize; /* size of flash page in bytes */ word noOfChips; /* no of chips in array */ dword firstUsableBlock; /* Some devices may not use all of the media */ /* blocks. For example mdocplus can not use */ /* the first 3 blocks. */ Sword interleaving; /* chip interleaving (The interleaving is */ /* defined as the address difference between */ /* two consecutive bytes on a chip) */ word flags; /* Special capabilities & options Bits 0-7 */ /* may be used by FLite. Bits 8-15 are not */ /* used bt FLite and may beused by MTD's for */ /* MTD-specific purposes. */ /* Flag bit values */
#define SUSPEND_FOR_WRITE 1 /* MTD provides suspend for write */
#define NFTL_ENABLED 2 /* Flash can run NFTL */
#define INFTL_ENABLED 4 /* Flash can run INFTL */
#define EXTERNAL_EPROM 8 /* Can support external eprom */
void * mtdVars; /* Points to MTD private area for this socket.*/ /* This field, if used by the MTD, is */ /* initialized bythe MTD identification */ /* routine. */ FLSocket * socket; /* Socket of this drive. Note that 2 diffrent */ /* records are used. One for OSAK and the */ /* other forstandalone applications. */ NDOC2window win; /* DiskOnChip memory windows */
#ifdef NT5PORT
ULONG readBufferSize; VOID * readBuffer;#endif /*NT5PORT*/
/*----------------------------------------------------------------------*//* f l a s h . m a p *//* *//* MTD specific map routine *//* *//* The default routine maps by socket mapping, and is suitable for all *//* NOR Flash. *//* NAND or other type Flash should use map-through-copy emulation: Read *//* a block of Flash to an internal buffer and return a pointer to that *//* buffer. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : Card address to map *//* length : Length to map *//* *//* Returns: *//* Pointer to required card address *//*----------------------------------------------------------------------*/ void FAR0 * (*map)(FLFlash *, CardAddress, int);
/*----------------------------------------------------------------------*//* f l a s h . r e a d *//* *//* MTD specific Flash read routine *//* *//* The default routine reads by copying from a mapped window, and is *//* suitable for all NOR Flash. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : Card address to read *//* buffer : Area to read into *//* length : Length to read *//* modes : See write mode flags definition above *//* *//*----------------------------------------------------------------------*/ FLStatus (*read)(FLFlash *, CardAddress, void FAR1 *, dword, word);
/*----------------------------------------------------------------------*//* f l a s h . w r i t e *//* *//* MTD specific Flash write routine *//* *//* The default routine returns a write-protect error. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* address : Card address to write to *//* buffer : Address of data to write *//* length : Number of bytes to write *//* modes : See write mode flags definition above *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/ FLStatus (*write)(FLFlash *, CardAddress, const void FAR1 *, dword, word);
/*----------------------------------------------------------------------*//* f l a s h . e r a s e *//* *//* Erase one or more contiguous Flash erasable blocks *//* *//* The default routine returns a write-protect error. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* firstErasableBlock : Number of first block to erase *//* numOfErasableBlocks : Number of blocks to erase *//* *//* Returns: *//* FLStatus : 0 on success, failed otherwise *//*----------------------------------------------------------------------*/ FLStatus (*erase)(FLFlash *, word, word);
/*----------------------------------------------------------------------*//* f l a s h . s e t P o w e r O n C a l l b a c k *//* *//* Register power on callback routine. Default: no routine is *//* registered. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//*----------------------------------------------------------------------*/ void (*setPowerOnCallback)(FLFlash *);
/*----------------------------------------------------------------------*//* f l a s h . r e a d B B T *//* *//* MTD specific Flash routine returning the media units status *//* Note that a unit can contain more then 1 erase block *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* unitNo : Number of the first unit to check *//* unitsToRead : Number of units to check *//* blockMultiplier : Number of blocks per erase unit *//* buffer : Buffer to return the units status *//* reconstruct : TRUE for reconstruct BBT from virgin card *//* *//*----------------------------------------------------------------------*/ FLStatus (*readBBT)(FLFlash *, dword unitNo, dword unitsToRead, byte blockMultiplier,byte FAR1 * buffer, FLBoolean reconstruct);
/*----------------------------------------------------------------------*//* f l a s h . w r i t e I P L *//* *//* MTD specific Flash write IPL area routine *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* buffer : Buffer containing the data to write *//* length : Length to write *//* flags : Flags of write IPL operation (see obove) *//* *//*----------------------------------------------------------------------*/ FLStatus (*writeIPL)(FLFlash *, const void FAR1 * buffer, word length, byte offset , unsigned flags);/*----------------------------------------------------------------------*//* f l a s h . r e a d I P L *//* *//* MTD specific Flash read area IPL routine *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* buffer : Area to read into *//* length : Length to read *//* *//*----------------------------------------------------------------------*/ FLStatus (*readIPL)(FLFlash *, void FAR1 * buffer, word length);
#ifdef HW_OTP
/*----------------------------------------------------------------------*//* f l a s h . w r i t e O T P *//* *//* MTD specific Flash write and lock OTP area routine *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* buffer : buffer containing the data to write *//* length : Length to write *//* *//*----------------------------------------------------------------------*/ FLStatus (*writeOTP)(FLFlash *, const void FAR1 * buffer,word length);
/*----------------------------------------------------------------------*//* f l a s h . r e a d O T P *//* *//* MTD specific Flash read OTP area routine *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* offset : Offset from the begining of the OTP arae *//* buffer : Area to read into *//* length : Length to read *//* *//*----------------------------------------------------------------------*/ FLStatus (*readOTP)(FLFlash *, word offset, void FAR1 * buffer, word length);
/*----------------------------------------------------------------------*//* f l a s h . otpSize *//* *//* MTD specific Flash get OTP area size and state *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectionSize : total size of the OTP area *//* usedSize : Used (and locked) size of the OTP area *//* locked : LOCKED_OTP flag stating the locked state *//* *//*----------------------------------------------------------------------*/ FLStatus (*otpSize)(FLFlash *, dword FAR2* sectionSize, dword FAR2* usedSize, word FAR2* locked);#define LOCKED_OTP 1
#endif /* HW_OTP */
/*----------------------------------------------------------------------*//* f l a s h . g e t U n i q u e I d *//* *//* MTD specific Flash get the chip unique ID *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* buffer : byte buffer to read unique ID into *//* *//*----------------------------------------------------------------------*/ FLStatus (*getUniqueId)(FLFlash *, void FAR1 * buffer);#ifdef HW_PROTECTION
/*----------------------------------------------------------------------*//* f l a s h . p r o t e c t i o n B o u n d r i e s *//* *//* MTD specific Flash get protection boundries routine *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* areaNo : Protection area number to work on *//* addressLow : Low boundary Address of protected area *//* addressHigh : High boundary Address of protected area *//* floorNo : The floor to work on. *//* *//*----------------------------------------------------------------------*/ FLStatus (*protectionBoundries)(FLFlash *, byte areaNo, CardAddress* addressLow ,CardAddress* addressHigh, byte floorNo);
/*----------------------------------------------------------------------*//* f l a s h . p r o t e c t i o n K e y I n s e r t *//* *//* MTD specific Flash insert the protection key routine *//* *//* No default routine is implemented for this routine. *//* *//* Note the key is inserted only to protected areas and to all floors *//* *//* Parameters: *//* vol : Pointer identifying drive *//* areaNo : Protection area number to work on *//* key : protection key buffer *//* *//*----------------------------------------------------------------------*/ FLStatus (*protectionKeyInsert)(FLFlash *, byte areaNo, byte FAR1* key);
/*----------------------------------------------------------------------*//* f l a s h . p r o t e c t i o n K e y R e m o v e *//* *//* MTD specific Flash remove the protection key routine *//* *//* No default routine is implemented for this routine. *//* *//* Note the key is removed from all floors. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* areaNo : Protection area number to work on *//* *//*----------------------------------------------------------------------*/ FLStatus (*protectionKeyRemove)(FLFlash *,byte areaNo);
/*----------------------------------------------------------------------*//* f l a s h . p r o t e c t i o n T y p e *//* *//* MTD specific Flash get protection type routine *//* *//* No default routine is implemented for this routine. *//* *//* Note the type is the combined attributes of all the floors. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* areaNo : Protection area number to work on *//* areaType : returnining the protection type *//* *//*----------------------------------------------------------------------*/ FLStatus (*protectionType)(FLFlash *,byte areaNo, word* areaType);
/*----------------------------------------------------------------------*//* f l a s h . p r o t e c t i o n S e t *//* *//* MTD specific Flash get protection type routine *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* areaNo : Protection area number to work on *//* areaType : Protection area type *//* addressLow : Low boundary Address of protected area *//* addressHigh : High boundary Address of protected area *//* key : protection key buffer *//* modes : Either COMMIT_PROTECTION will cause the new *//* values to take affect immidiatly or *//* DO_NOT_COMMIT_PROTECTION for delaying the new *//* values to take affect only after the next reset.*//* floorNo : The floor to work on. *//* *//*----------------------------------------------------------------------*/ FLStatus (*protectionSet )( FLFlash *,byte areaNo, word areaType , CardAddress addressLow, CardAddress addressHigh, byte FAR1* key , byte modes , byte floorNo);
#endif /* HW_PROTECTION */
/*----------------------------------------------------------------------*//* f l a s h . e n t e r D e e p P o w e r D o w n M o d e *//* *//* MTD specific Flash enter deep power down mode routine *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* state : DEEP_POWER_DOWN *//* *//*----------------------------------------------------------------------*/ FLStatus (*enterDeepPowerDownMode)(FLFlash *,word state);
#define DEEP_POWER_DOWN 1 /* must be the same as in blockdev.h */
/*----------------------------------------------------------------------*//* f l a s h . d o w n l o a d *//* *//* MTD specific - Reset download mechanizm to download IPL and *//* protection attributes. *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//*----------------------------------------------------------------------*/ FLStatus (*download)(FLFlash *);
/*----------------------------------------------------------------------*//* DiskOnChip memory access routines type defintions *//*----------------------------------------------------------------------*/
FLMemWindowSize FAR1* memWindowSize; /* Doc memory window size */#ifndef FL_NO_USE_FUNC
FLMemRead FAR1* memRead; /* Doc memory read routine */ FLMemWrite FAR1* memWrite; /* Doc memory write routine */ FLMemSet FAR1* memSet; /* Doc memory set routine */ FLMemRead8bit FAR1* memRead8bit; /* Doc memory 8 bit read routine */ FLMemWrite8bit FAR1* memWrite8bit; /* Doc memory 8 bit write routine */ FLMemRead16bit FAR1* memRead16bit; /* Doc memory 16 bit read routine */ FLMemWrite16bit FAR1* memWrite16bit; /* Doc memory 16 bit write routine */#endif /* FL_NO_USE_FUNC */
};
/* MTD registration information */
extern int noOfMTDs; /* No. of MTDs actually registered */
typedef FLStatus (*MTDidentifyRoutine) (FLFlash *);
extern MTDidentifyRoutine mtdTable[MTDS];
/* Returns specific flash structure of the socket */
extern FLFlash * flFlashOf(unsigned volNo);
#ifdef MTD_STANDALONE
typedef FLStatus (*SOCKETidentifyRoutine) (FLSocket * , dword lowAddress, dword highAddress);typedef void (*FREEmtd) (FLSocket vol);
extern SOCKETidentifyRoutine socketTable[MTDS];extern FREEmtd freeTable[MTDS];
#else
/* The address of this, if returned from map, denotes a data error */
extern FLStatus dataErrorObject;
#define dataErrorToken ((void FAR0 *) &dataErrorObject)
/* See interface documentation of functions in flflash.c */
extern void flIntelIdentify(FLFlash *, void (*)(FLFlash *, CardAddress, byte, FlashPTR), CardAddress);
extern FLStatus flIntelSize(FLFlash *, void (*)(FLFlash *, CardAddress, byte, FlashPTR), CardAddress);
extern FLStatus flIdentifyFlash(FLSocket *socket, FLFlash *flash);
#ifdef NT5PORT
extern VOID * mapThroughBuffer(FLFlash *flash, CardAddress address, LONG length);#endif /*NT5PORT*/
#endif /* MTD_STANDALONE */
#endif
/*----------------------------------------------------------------------*//* f l a s h . r e s e t I n t e r r u p t *//* *//* MTD specific Flash reset the interrupt signal routine *//* *//* No default routine is implemented for this routine. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//*----------------------------------------------------------------------*//*void (*resetInterrupt)(FLFlash vol); */
|
