|
|
/*
* $Log: V:/Flite/archives/TrueFFS5/Src/BLOCKDEV.C_V $ * * Rev 1.43 Apr 15 2002 20:14:20 oris * Prevent any change to the flPolicy environment variable. It must be set to FL_DEFAULT_POLICY. * * Rev 1.42 Apr 15 2002 07:33:56 oris * Moved doc2exb functions declaration to blockdev.c * Moved bdkCall function declaration to docbdk.h * Bug fix - Bad arguments sanity check for FL_MTD_BUS_ACCESS_TYPE. * Bug fix - Missing initialization of global variables: * - bus access in flSetDocBusRoutine() and flGetDocBusRoutine() and when ENVIRONMENT_VARS compilation flag is not defined. * - verify write when ENVIRONMENT_VARS compilation flag is not defined. * - All global (for all sockets and volumes) environment variables where not reinitialized after flExit call. * - Renamed initEnvVarsDone to initGlobalVarsDone. * - Renamed flInitEnvVars() to flInitGlobalVars(). * Changed flBusConfig environment array to dword variables instead of single byte. * Added support for VERIFY_ERASED_SECTOR compilation flag. * Placed multi-doc environment variable under the MULTI_DOC compilation flag. * VolumeInfo routine - remove warning by placing eraseCyclesPerUnit variable under FL_LOW_LEVEL compilation flag. * * Rev 1.41 Feb 19 2002 20:58:08 oris * Moved include directives to blockdev.h file. * Bug fix - findFreeVolume routine did not initialize flfash records of the volume. It caused exception when formatting a DiskOnChip with more then 1 partition. * Compilation error missing ifdef EXIT. * Convert TL_LEAVE_BINARY_AREA to FL_LEAVE_BINARY_AREA before sending it to the TL. * Bug fix - volumeInfo routine might cause exception if osak version or driver version is larger the designated field. * use intermediate variable before sending irFlags to otpSize routine. * * Rev 1.40 Jan 29 2002 20:07:42 oris * Added NAMING_CONVENTION prefix and extern "C" for cpp files to all public routines: * flSetEnvVolume, flSetEnvSocket , flSetEnvAll , flSetDocBusRoutine , flGetDocBusRoutine, flBuildGeometry , bdCall and flExit * Changed LOW_LEVEL compilation flag with FL_LOW_LEVEL to prevent definition clashes. * Removed warnings. * Moved writeIPL sanity check to MTD level. * Removed download operation after writeIPL call (it is now one of the routines parameters). * Added sanity check (null pointer passed) to flSetEnvVolume, flSetDocBusRoutine and flGetDocBusRoutine. * * Rev 1.39 Jan 28 2002 21:23:32 oris * Bug fix - initialization of flPolicy variable caused a memory lick (set max unit chain to 0). * Changed FL_NFTL_CACHE_ENABLED to FL_TL_CACHE_ENABLED. * Changed flSetDocBusRoutine interface and added flGetDocBusRoutine. * Added FL_IPL_DOWNLOAD flag to writeIPL routine in order to control whether the IPL will be reloaded after the update. * * Rev 1.38 Jan 23 2002 23:30:46 oris * Added a call to flExit() in case flSuspend was restored to FL_OFF. * Moved Alon based DiskOnChip write IPL routine from blockdev, to diskonc. * Added sanity check to flCheckVolume() - Make sure irData is NULL and irLength is set to 0. * * Rev 1.37 Jan 21 2002 20:43:36 oris * Bug fix - Missing\bad support for FL_SECTORS_VERIFIED_PER_FOLDING and FL_VERIFY_WRITE_BDTL environment variables. * * Rev 1.36 Jan 20 2002 20:40:20 oris * Improved documentation of bdFormatPhisycalDrive - Added TL_NORMAL_FORMAT flag was added. * Removed ifdef NO_PHYSICAL_IO from flGetBPB routine. * * Rev 1.35 Jan 17 2002 22:56:22 oris * Placed docbdk.h under BDK_ACCESS ifdef * Added include directive to docsys.h * Removed function prototypes from header. * Changed FLFlash record in the volume structure into a pointer * Added flBusConfig variable and flSetDocBusRoutine() routine for runtime control over memory access routines - under the FL_NO_USE_FUNC definition. * Added flSectorsVerfiedPerFolding environment variable was added * Added flSuspendMode environment variable was added. * Changed flVerifyWrite environment variable : 4 for Disk partitions 3 for Binary and 1 for the rest. * Changed flPolicy to be partition specific. * Changed flSetEnv() routine was changed into 3 different routines: flSetEnvVolume / flSetEnvSocket / flSetEnvAll * Variables types for environment variables were changed to the minimal size needed. * Added flInitEnvVars() routine for setting default values to environment variables. * Use single FLFlash record for each volume - (change vol.flash to a pointer instead of the record itself). * Added \r to all DEBUG_PRINT routines. * Removed SINGLE_BUFFER ifdef. * Added volume verification after format for faster write performance with FL_OFF. * Removed FLFlash parameter to all TL calls (flMount / flFormat / flPreMount ) * Added support for firmware other then the 3 defaults (getExbInfo additional parameter) * Added support for M+ 16MB * Added partition parameter to setBusy - Stores current partition in the socket record for the use of lower TrueFFS layers . * Changed tffsmin to TFFSMIN * Added FL_VERIFY_VOLUME functionNo. * Made sure flInit() initializes all sockets and flashes volumes * Added flClearQuickMountInfo() routine (FL_CLEAR_QUICK_MOUNT_INFO) * readIPL routine now supports all DiskOnChip * * Rev 1.34 Nov 29 2001 20:53:44 oris * Bug fix - flInquireCapabilities() returned bad status for SUPPORT_WRITE_IPL_ROUTINE. * * Rev 1.33 Nov 21 2001 11:40:44 oris * Changed FL_MULTI_DOC_NOT_ACTIVE to FL_OFF, FL_VERIFY_WRITE_MODE to FL_MTD_VERIFY_WRITE , FL_WITHOUT_VERIFY_WRITE to FL_OFF , FL_MARK_DELETE to FL_ON. * * Rev 1.32 Nov 08 2001 10:44:04 oris * Added flVerifyWrite environment variable that controls the verify write mode at run-time. * Added support for large DiskOnChip in flBuildGeometry. * Remove s/w protection from binary partition. * Placed flAbsMount under ABS_READ_WRITE compilation flag. * * Rev 1.31 Sep 24 2001 18:23:04 oris * Removed warnings. * * Rev 1.30 Sep 15 2001 23:44:22 oris * Changed BIG_ENDIAN to FL_BIG_ENDIAN * * Rev 1.29 Aug 02 2001 20:04:04 oris * Added support for 1k IPL for DiskOnChip 2000 TSOP - writeIPL() * * Rev 1.28 Jul 29 2001 19:14:24 oris * Bug fix for TrueFFS internal mutex when using multi-doc and environment variables (when no multi-doc feature is disbaled) * * Rev 1.27 Jul 13 2001 00:59:28 oris * Changed flash lifetime calculation according to specific flash. * * Rev 1.26 Jun 17 2001 08:16:50 oris * Added NO_PHISICAL_IO compilation flag to reduce code size. * Added NO_READ_BBT_CODE compilation flag to reduce code size. * Changed placeExbByBuffer exbflags argument to word instead of byte to support /empty flag. * Deleted redundent #ifdef MULTI_DOC in flInit(). * * Rev 1.25 May 31 2001 18:11:52 oris * Removed readBBT routine from under the #ifndef FL_READ_ONLY. * * Rev 1.24 May 16 2001 21:16:08 oris * Changed the Binary state (0,1) of the environment variables to meaningful definitions. * Added flMtlDefragMode environment variable. * Added the FL_ prefix to the following defines: ON, OFF * Bug fix - One of the "ifndef" statement of NO_IPL_CODE was coded as "ifdef" * Change "data" named variables to flData to avoid name clashes. * * Rev 1.23 May 09 2001 00:31:00 oris * Added NO_PHYSICAL_IO , NO_IPL_CODE and NO_INQUIRE_CAPABILITY compilation flags to reduce code size. * * Rev 1.22 May 06 2001 22:41:04 oris * Bug fix - flInquireCapabilities routine did not return the correct value when capability was not supported. * Added SUPPORT_WRITE_IPL_ROUTIN capability. * Removed warnings. * * Rev 1.21 May 01 2001 17:05:10 oris * Bug fix - bad argument check in flSetEnv routine. * * Rev 1.20 Apr 30 2001 17:57:00 oris * Added new environment variable flMarkDeleteOnFlash. * * Rev 1.19 Apr 24 2001 17:05:38 oris * Bug fix flMoutVolume routine return the correct hidden sectors even if high level mount fails. * Bug fix Write IPL routine supports Doc2000 TSOP as well as Millennium Plus. * Support readBBT new interface. * * Rev 1.18 Apr 18 2001 20:43:00 oris * Added force download call after writing IPL. * * Rev 1.17 Apr 18 2001 19:14:24 oris * Bug fix - binary partition insert and remove key routine no longer stop the place exb proccess. * * Rev 1.16 Apr 18 2001 09:26:22 oris * noOfDrives variable was changed to unsigned. This is a bug fix for vxWorks boot code. * Make sure blockdev does not try to mount more volumes then the VOLUMES definition. * * Rev 1.15 Apr 16 2001 13:02:38 oris * Removed warrnings. * * Rev 1.14 Apr 12 2001 06:48:22 oris * Added call to download routine after physical format in order * to load new IPL and to initialize new protection information. * Removed warnings. * * Rev 1.13 Apr 03 2001 16:33:10 oris * Removed unused variables. * Added proper casting in otpSize call. * * Rev 1.12 Apr 03 2001 14:33:16 oris * Bug fix in absRead sectors when reading multiple sectors. * * Rev 1.11 Apr 01 2001 14:57:58 oris * Bug fix in read multiple sectors. * * Rev 1.10 Mar 28 2001 06:19:12 oris * Removed flChangeEnvVar prototype. * Left alligned all # directives. * Bug fix in flSetEnv ((value !=0)||(value!=1)) => ((value !=0)&&(value!=1)) + downcast for given argument + add return status code * Removed unused variables. * Remove casting warnnings. * Add arg check in bdFormatPhysicalDrive for BDTLPartitionInfo != NULL. * Bug fix for absWrite - multi-secotr write should be initialized with zeros to prevent sector found return code. * Replaced the numbers in writeProtect routine to defines (moved from ioctl.h to blockdev.h). * Add break for mdocp identification in getPhysicalInfo. * Added readIPL routine. * Added LOG_FILE compilation flag for EDC errors for mdocp. * Added initialization of tl table in flInit. * flExit mutex bug fix. * * Rev 1.9 Mar 05 2001 21:00:34 oris * Bug fix - initialize exbLen argument in bdFormatVolume. * Bug fix - initialize bdtlFp flags fiels in bdFormatVolume. * Restored the flExit pragma under __BORLANDC__ compilation flag * * Rev 1.8 Feb 22 2001 20:21:34 oris * Bug fix in flExit with multi-doc release uncreated mutxe. * * Rev 1.7 Feb 20 2001 15:44:58 oris * Bug fix for mutex initialization in flInit. * * Rev 1.6 Feb 18 2001 23:29:28 oris * Bug fix - Added findFreeVolume call in flFormatPhysicalDrive. * bug fix - Added partition sanity check in bdcall entrence. * bug fix - Increamented pVol before entering loop in flExit. * * Rev 1.5 Feb 18 2001 14:13:22 oris * Restored FL_BACKGROUND. * Place bdkCall extern prototype under BDK_ACCESS compilation flag. * Changed multiple volume mechanism - Replaced removeVolumeHandles and * flConvertDriveHandle routines with flInit + findFreeVolume and changed * dismountPhysicalDrive + flEacit to comply. * Changed bdcall volume validity check. * Added new volume flag VOLUME_ACCUPIED. * Moved all the new environment variable (flPolicy,flUseMultiDoc and flMaxUnitChain) * from flcustom.c in order to allow backwards competability. * Removed globalMutex (for now). * Allocate only 1 mutex when multi-doc is registered therfore setBusy takes only 1 mutex . * Bug fix - absRead and absWrite add bootSectors to the given sectors. * Bug fix - INVALID_VOLUME_HANDLE changed to INVALID_VOLUME_NUMBER. * Bug fix - Added (byte FAR1 *) casting in readBBT call. * Bug fix - Added (FLCapability FAR2 *) casting in inquire capability call. * * Rev 1.4 Feb 14 2001 01:51:32 oris * Completly revised flInquireCapabilities routine. * Added oldFormat flag to flBuildGeometry routine. * Remove FL_BACKGROUND compilation flag. * Added arg check for flSetEnv + new FL_SET_MAX_CHAIN. * Changed FL_COMPLETE_ASAP_POLICY to FL_SET_POLICY. * Moved argument check in flFormatPhysicalDrive to fltl.c. * Moved readBBT routine inside bdcall. * Placed volumeInfo C\H\S data under ABS_READ_WRITE. * * Rev 1.3 Feb 13 2001 02:10:48 oris * Changed flChangeEnvVar routine name to flSetEnv * * Rev 1.2 Feb 12 2001 11:51:12 oris * Added function prototype in begining of the file. * Change routine order in the file. * Added mutex support for TrueFFS 5.0 partitions while changing bdcall order. * flMountVolume returns the number of boot sectors. * Moved the writeBBT routine to FLTL.C. * Added static before changePassword. * Added static before writeProtect. * Added static before dismountLowLevel. * Added static before writeIPL. * Added static before inquireCapabilities. * window base is returned by getPhysicalInfo in irLength. * Added MULTI_DOC compliation flag. * * Rev 1.1 Feb 07 2001 17:55:06 oris * Buf fix for writeBBT of no bad blocks * Moved readBBT routine from under the fl_read_only define * Added casting in calls to readBBT and writeBBT * Added checkStatus check for flAbsWrite and flAbsRead routines * Added initialization of noOfMTDs and noOfSockets in flInit * * Rev 1.0 Feb 04 2001 18:53:04 oris * Initial revision. * */
/*************************************************************************//* M-Systems Confidential *//* Copyright (C) M-Systems Flash Disk Pioneers Ltd. 1995-2001 *//* All Rights Reserved *//*************************************************************************//* NOTICE OF M-SYSTEMS OEM *//* SOFTWARE LICENSE AGREEMENT *//* *//* THE USE OF THIS SOFTWARE IS GOVERNED BY A SEPARATE LICENSE *//* AGREEMENT BETWEEN THE OEM AND M-SYSTEMS. REFER TO THAT AGREEMENT *//* FOR THE SPECIFIC TERMS AND CONDITIONS OF USE, *//* OR CONTACT M-SYSTEMS FOR LICENSE ASSISTANCE: *//* E-MAIL = [email protected] *//*************************************************************************/
#include "bddefs.h"
#include "blockdev.h"
#ifdef FL_BACKGROUND
#include "backgrnd.h"
#endif
/********************* Extern Function Prototype Start *******************/#ifdef WRITE_EXB_IMAGE
extern FLStatus getExbInfo(Volume vol, void FAR1 * buf, dword bufLen, word exbFlags);extern FLStatus placeExbByBuffer(Volume vol, byte FAR1 * buf, dword bufLen, word windowBase,word exbFlags);#endif /* WRITE_EXB_IMAGE */
#if (defined(FORMAT_VOLUME) && defined(COMPRESSION))
extern FLStatus flFormatZIP(unsigned volNo, TL *baseTL , FLFlash * flash);#endif
#if defined(FILES) && FILES > 0
extern File fileTable[FILES]; /* the file table */extern FLStatus flushBuffer(Volume vol);extern FLStatus openFile(Volume vol, IOreq FAR2 *ioreq);extern FLStatus closeFile(File *file);extern FLStatus joinFile (File *file, IOreq FAR2 *ioreq);extern FLStatus splitFile (File *file, IOreq FAR2 *ioreq);extern FLStatus readFile(File *file,IOreq FAR2 *ioreq);extern FLStatus writeFile(File *file, IOreq FAR2 *ioreq);extern FLStatus seekFile(File *file, IOreq FAR2 *ioreq);extern FLStatus findFile(Volume vol, File *file, IOreq FAR2 *ioreq);extern FLStatus findFirstFile(Volume vol, IOreq FAR2 *ioreq);extern FLStatus findNextFile(File *file, IOreq FAR2 *ioreq);extern FLStatus getDiskInfo(Volume vol, IOreq FAR2 *ioreq);extern FLStatus deleteFile(Volume vol, IOreq FAR2 *ioreq, FLBoolean isDirectory);extern FLStatus renameFile(Volume vol, IOreq FAR2 *ioreq);extern FLStatus makeDir(Volume vol, IOreq FAR2 *ioreq);#endif /* FILES > 0 */
/********************* Extern Function Prototype End *******************/
/********************* Internal Function Prototype Start ***************/
void flInitGlobalVars(void);
/********************* Internal Function Prototype End *****************/
/********************* Global variables Start **************************/
Volume vols[VOLUMES];FLMutex flMutex[SOCKETS];byte handleConversionTable[SOCKETS][MAX_TL_PARTITIONS];FLBoolean initDone = FALSE; /* Initialization not done yet */FLBoolean initGlobalVarsDone = FALSE; /* Initialization of environment */ /* and access type variables not */ /* done yet. */unsigned noOfDrives;
dword flMsecCounter = 0;
/* bus configuration
* * DiskOnChip minimal bus width */#ifndef FL_NO_USE_FUNC
dword flBusConfig[SOCKETS];#endif /* FL_NO_USE_FUNC */
/* Verify write state
* * BDTL partitions : 0-(MAX_TL_PARTITIONS-1) * Binary partitions : MAX_TL_PARTITIONS - (2*MAX_TL_PARTITIONS-2) * Last : 2*MAX_TL_PARTITIONS-1 */#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
byte flVerifyWrite[SOCKETS][MAX_TL_PARTITIONS<<1];#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
#ifdef ENVIRONMENT_VARS
cpyBuffer tffscpy; /* Pointer to memory copy routine */cmpBuffer tffscmp; /* Pointer to memory compare routine */setBuffer tffsset; /* Pointer to memory set routine */
/********************************************//* default values for environment variables *//********************************************/
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
/* Max sectors verified per write operation (must be even number) */dword flSectorsVerifiedPerFolding = 64;#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
#ifdef MULTI_DOC
/* No multi-doc (MTL) */byte flUseMultiDoc;/* MTL defragmentaion mode (0 - standard) */byte flMTLdefragMode;#endif /* MULTI_DOC */
/* Set the TL operation policy */byte flPolicy[SOCKETS][MAX_TL_PARTITIONS];/* Maximum chain length */byte flMaxUnitChain;/* Mark the delete sector on the flash */byte flMarkDeleteOnFlash;/* Read Only mode */byte flSuspendMode;
/********************* Global variables End *****************************/
/*----------------------------------------------------------------------*//* f l S e t E n v V o l u m e *//* *//* Change one of TrueFFS environment variables for a specific partition *//* *//* Note : This routine is used by all other flSetEnv routines. *//* In order to effect variables that are common to several *//* sockets or volumes use INVALID_VOLUME_NUMBER *//* *//* Parameters: *//* variableType : variable type to cahnge *//* socket : Associated socket *//* volume : Associated volume (partition) *//* value : varaible value *//* *//* Note: Variables common to al sockets must be addressed using socket *//* 0 and volume 0. *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//* prevValue : The previous value of the variable *//*----------------------------------------------------------------------*/
FLStatus NAMING_CONVENTION flSetEnvVolume(FLEnvVars variableType , byte socket,byte volume , dword value, dword FAR2 *prevValue){ /* Arg sanity check */ if(prevValue == NULL) { DEBUG_PRINT(("ERROR - prevValue argument is NULL.\r\n")); return flBadParameter; } switch (variableType) /* Check value argument is a valid mode */ { case FL_SET_MAX_CHAIN: if ((value > 31) || (value < 1)) { DEBUG_PRINT(("Debug: Error - Chains length must between 0 and 32.\r\n")); return flBadParameter; } break;#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
case FL_SECTORS_VERIFIED_PER_FOLDING: if (value & 1) /* odd number */ { DEBUG_PRINT(("Debug: Error - sector verification numbr must be even.\r\n")); return flBadParameter; } break; case FL_VERIFY_WRITE_BDTL: if ((value != FL_UPS) && (value != FL_OFF) && (value != FL_ON)) { DEBUG_PRINT(("Debug: Error - verify write of BDTL can not accept this value.\r\n")); return flBadParameter; } break;#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
case FL_SUSPEND_MODE: if((value != FL_OFF) && (value != FL_SUSPEND_WRITE) && (value != FL_SUSPEND_IO) ) { DEBUG_PRINT(("Debug: Error - verify write of BDTL can not accept this value.\r\n")); return flBadParameter; } break;#ifndef FL_NO_USE_FUNC
case FL_MTD_BUS_ACCESS_TYPE: break;#endif /* FL_NO_USE_FUNC */
default: if ((value != FL_ON)&&(value!=FL_OFF)) { DEBUG_PRINT(("Debug: Error - Value must be either FL_ON (1) or FL_OFF(0).\r\n")); return flBadParameter; } }
switch (variableType) /* Check volume and socket sanity */ { /* Volume specfic variables */
case FL_SET_POLICY:#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
case FL_VERIFY_WRITE_BDTL:#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
#ifdef VERIFY_WRITE
case FL_VERIFY_WRITE_BINARY:#endif /* VERIFY_WRITE */
if (( volume >= MAX_TL_PARTITIONS ) || ((variableType == FL_VERIFY_WRITE_BINARY) && (volume == MAX_TL_PARTITIONS - 1 ) ) ) { DEBUG_PRINT(("Debug: Error - No such volume, therefore can not change environment variable.\r\n")); return flBadParameter; } if (socket>=SOCKETS) { DEBUG_PRINT(("Debug: Error - No such socket, therefore can not change environment variable.\r\n")); return flBadParameter; } break;
/* Socket specfic variables */
#ifdef VERIFY_WRITE
case FL_VERIFY_WRITE_OTHER:#endif /* VERIFY_WRITE */
case FL_MTD_BUS_ACCESS_TYPE: if (socket>=SOCKETS) { DEBUG_PRINT(("Debug: Error - No such socket, therefore can not change environment variable.\r\n")); return flBadParameter; } if (volume!=INVALID_VOLUME_NUMBER) { DEBUG_PRINT(("Debug: Error - This global variable is common to all volumes.\r\n")); return flBadParameter; } break;
/* Global variables for all sockets and volumes */#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
case FL_SECTORS_VERIFIED_PER_FOLDING:#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
case FL_IS_RAM_CHECK_ENABLED: case FL_TL_CACHE_ENABLED: case FL_DOC_8BIT_ACCESS: case FL_MULTI_DOC_ENABLED: case FL_SET_MAX_CHAIN: case FL_MARK_DELETE_ON_FLASH: case FL_SUSPEND_MODE: case FL_MTL_POLICY: if ((socket!=INVALID_VOLUME_NUMBER) || (volume!=INVALID_VOLUME_NUMBER)) { DEBUG_PRINT(("Debug: Error - This global variable is common to all sockets and volumes.\r\n")); return flBadParameter; } break;
default:
DEBUG_PRINT(("Debug: Unknown variable type.\r\n")); return flFeatureNotSupported; }
/* Make sure environement variables are */ /* initialized to their default values */ flInitGlobalVars();
/***************************************************/ /* Arguments have been checked now change variable */ /* and report the previous value. */ /***************************************************/
switch (variableType) { case FL_IS_RAM_CHECK_ENABLED: *prevValue = (dword)flUseisRAM; flUseisRAM = (byte)value; break; case FL_TL_CACHE_ENABLED: *prevValue = (dword)flUseNFTLCache; flUseNFTLCache = (byte)value; break; case FL_DOC_8BIT_ACCESS: *prevValue = (dword)flUse8Bit; flUse8Bit = (byte)value; break; case FL_SET_MAX_CHAIN: *prevValue = (dword)flMaxUnitChain; flMaxUnitChain = (byte)value; break; case FL_MARK_DELETE_ON_FLASH: *prevValue = (dword)flMarkDeleteOnFlash; flMarkDeleteOnFlash = (byte)value; break;#ifdef MULTI_DOC
case FL_MULTI_DOC_ENABLED: *prevValue = (dword)flUseMultiDoc; flUseMultiDoc = (byte)value; break; case FL_MTL_POLICY: *prevValue = (dword)flMTLdefragMode; flMTLdefragMode = (byte)value; break;#endif /* MULTI_DOC */
case FL_SUSPEND_MODE: if((value == FL_OFF) && (flSuspendMode != FL_OFF))#ifdef EXIT
flExit();#endif /* EXIT */
*prevValue = (dword)flSuspendMode; flSuspendMode = (byte)value; break; case FL_SET_POLICY: *prevValue = (dword)flPolicy[socket][volume];/* flPolicy[socket][volume] = (byte)value; */ break;#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
case FL_SECTORS_VERIFIED_PER_FOLDING: *prevValue = flSectorsVerifiedPerFolding; flSectorsVerifiedPerFolding = value; break; case FL_VERIFY_WRITE_BDTL: *prevValue = (dword)flVerifyWrite[socket][volume]; flVerifyWrite[socket][volume] = (byte)value; break;#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
#ifdef VERIFY_WRITE
case FL_VERIFY_WRITE_BINARY: *prevValue = (dword)flVerifyWrite[socket][volume+MAX_TL_PARTITIONS]; flVerifyWrite[socket][volume+MAX_TL_PARTITIONS] = (byte)value; break; case FL_VERIFY_WRITE_OTHER: *prevValue = (dword)flVerifyWrite[socket][(MAX_TL_PARTITIONS<<1)-1]; flVerifyWrite[socket][(MAX_TL_PARTITIONS<<1)-1] = (byte)value; break;#endif /* VERIFY_WRITE */
default: /* FL_MTD_BUS_ACCESS_TYPE */#ifndef FL_NO_USE_FUNC
*prevValue = flBusConfig[socket]; flBusConfig[socket] = (dword)value;#endif /* FL_NO_USE_FUNC */
break; } return flOK;}
/*----------------------------------------------------------------------*//* f l S e t E n v S o c k e t *//* *//* Change one of TrueFFS environment variables for a specific sockets. *//* *//* Parameters: *//* variableType : variable type to cahnge *//* socket : socket number *//* value : varaible value *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//* prevValue : The previous value of the variable *//* if there are more then 1 partition in that *//* socket , the first partition value is returned*//*----------------------------------------------------------------------*/
FLStatus NAMING_CONVENTION flSetEnvSocket(FLEnvVars variableType , byte socket , dword value, dword FAR2 *prevValue){ FLStatus status = flOK; byte volume = 0;
switch (variableType) /* Check volume and socket sanity */ { /* Volume specific variables */
case FL_SET_POLICY:#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
case FL_VERIFY_WRITE_BDTL:#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
status = flSetEnvVolume(variableType,socket,MAX_TL_PARTITIONS-1,value,prevValue);#ifdef VERIFY_WRITE
case FL_VERIFY_WRITE_BINARY:#endif /* VERIFY_WRITE */
for (;(volume<MAX_TL_PARTITIONS-1)&&(status == flOK);volume++) status = flSetEnvVolume(variableType,socket,volume,value,prevValue); break;
/* Socket specific variables */
#ifdef VERIFY_WRITE
case FL_VERIFY_WRITE_OTHER:#endif /* VERIFY_WRITE */
#ifndef FL_NO_USE_FUNC
case FL_MTD_BUS_ACCESS_TYPE:#endif /* FL_NO_USE_FUNC */
#if (defined(VERIFY_WRITE) || !defined(FL_NO_USE_FUNC))
status = flSetEnvVolume(variableType,socket,INVALID_VOLUME_NUMBER,value,prevValue); break; #endif /* not FL_NO_USE_FUNC || VERIFY_WRITE */
/* Either global variables , or unknown */
default: if(socket != INVALID_VOLUME_NUMBER) /* Was not called from flSetEnv */ { DEBUG_PRINT(("Debug: Variable type is either unknown or not socket related.\r\n")); return flBadParameter; } status = flSetEnvVolume(variableType,INVALID_VOLUME_NUMBER,INVALID_VOLUME_NUMBER,value,prevValue); break; } return status;}
/*----------------------------------------------------------------------*//* f l S e t E n v All *//* *//* Change one of TrueFFS environment variables for all systems, sockets *//* and partitions. *//* *//* Parameters: *//* variableType : variable type to cahnge *//* value : varaible value *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//* prevValue : The previous value of the variable *//*----------------------------------------------------------------------*/
FLStatus NAMING_CONVENTION flSetEnvAll(FLEnvVars variableType , dword value, dword FAR2 *prevValue){ FLStatus status = flOK; byte socket;
switch (variableType) /* Check volume and socket sanity */ { case FL_SET_POLICY: /* Per volume */ case FL_VERIFY_WRITE_BDTL: /* Per volume */ case FL_VERIFY_WRITE_BINARY: /* Per volume */ case FL_VERIFY_WRITE_OTHER: /* Per socket */ case FL_MTD_BUS_ACCESS_TYPE: /* Per socket */ for (socket=0;(socket<SOCKETS)&&(status == flOK);socket++) status = flSetEnvSocket(variableType,socket,value,prevValue); return status; default: return flSetEnvVolume(variableType,INVALID_VOLUME_NUMBER,INVALID_VOLUME_NUMBER,value,prevValue); }}
#endif /* ENVIRONMENT_VARS */
#ifndef FL_NO_USE_FUNC
/*----------------------------------------------------------------------*//* f l S e t D o c B u s R o u t i n e *//* *//* Set user defined memory acces routines for DiskOnChip. *//* *//* Parameters: *//* socket : Socket number to install routine for. *//* structPtr : Pointer to function structure. *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
FLStatus NAMING_CONVENTION flSetDocBusRoutine(byte socket, FLAccessStruct FAR1 * structPtr){ FLFlash* flash;
/* Arg sanity check */ if (socket >= SOCKETS) { DEBUG_PRINT(("Error : change SOCKETS definition in flcustom.h to support that many sockets.\r\n")); return flFeatureNotSupported; } if(structPtr == NULL) { DEBUG_PRINT(("ERROR - structPtr argument is NULL.\r\n")); return flBadParameter; }
/* Make sure global variables are initialized to their default values */ flInitGlobalVars();
flash = flFlashOf(socket);
flash->memWindowSize = structPtr->memWindowSize; flash->memRead = structPtr->memRead; flash->memWrite = structPtr->memWrite; flash->memSet = structPtr->memSet; flash->memRead8bit = structPtr->memRead8bit; flash->memRead16bit = structPtr->memRead16bit; flash->memWrite8bit = structPtr->memWrite8bit; flash->memWrite16bit = structPtr->memWrite16bit;
flBusConfig[socket] = FL_ACCESS_USER_DEFINED; return flOK;}
/*----------------------------------------------------------------------*//* f l G e t D o c B u s R o u t i n e *//* *//* Get currently installed memory access routines for DiskOnChip. *//* *//* Parameters: *//* socket : Socket number to install routine for. *//* structPtr : Pointer to function structure. *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
FLStatus NAMING_CONVENTION flGetDocBusRoutine(byte socket, FLAccessStruct FAR1 * structPtr){ FLFlash* flash;
/* Arg sanity check */ if (socket >= SOCKETS) { DEBUG_PRINT(("Error : change SOCKETS definition in flcustom.h to support that many sockets.\r\n")); return flFeatureNotSupported; } if(structPtr == NULL) { DEBUG_PRINT(("ERROR - structPtr argument is NULL.\r\n")); return flBadParameter; }
/* Make sure global variables are initialized to their default values */ flInitGlobalVars();
flash = flFlashOf(socket);
structPtr->memWindowSize = flash->memWindowSize; structPtr->memRead = flash->memRead; structPtr->memWrite = flash->memWrite; structPtr->memSet = flash->memSet; structPtr->memRead8bit = flash->memRead8bit; structPtr->memRead16bit = flash->memRead16bit; structPtr->memWrite8bit = flash->memWrite8bit; structPtr->memWrite16bit = flash->memWrite16bit; structPtr->access = flBusConfig[socket];
return flOK;}
#endif /* FL_NO_USE_FUNC */
/*----------------------------------------------------------------------*//* f l I n i t G l o b a l V a r s *//* *//* Initializes the FLite system, environment and access type variables. *//* *//* Parameters: *//* None *//* *//* Returns: *//* None *//*----------------------------------------------------------------------*/
void flInitGlobalVars(void){ int i;#ifdef ENVIRONMENT_VARS
int j;#endif /* ENVIRONMENT_VARS */
if(initGlobalVarsDone == TRUE) return;
/* Do not initialize variables on next call */ initGlobalVarsDone = TRUE;
/*
* Set default values to per socket/volume variables */
for(i=0;i<SOCKETS;i++) {#ifndef FL_NO_USE_FUNC
flBusConfig[i] = FL_NO_ADDR_SHIFT | FL_BUS_HAS_8BIT_ACCESS | FL_BUS_HAS_16BIT_ACCESS | FL_BUS_HAS_32BIT_ACCESS;#endif /* FL_NO_USE_FUNC */
#ifdef ENVIRONMENT_VARS
for (j=0;j<MAX_TL_PARTITIONS;j++) { flPolicy[i][j] = FL_DEFAULT_POLICY; /* FL_COMPLETE_ASAP */ }#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
for (j=0;j<MAX_TL_PARTITIONS<<1;j++) { flVerifyWrite[i][j] = FL_OFF; /* FL_ON , FL_UPS */ }#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
#endif /* ENVIRONMENT_VARS */
}
/*
* Set default values to per platform variables */
#ifdef ENVIRONMENT_VARS
#if (defined(VERIFY_WRITE) || defined(VERIFY_ERASED_SECTOR))
/* Max sectors verified per write operation (must be even number) */ flSectorsVerifiedPerFolding = 64;#endif /* VERIFY_WRITE || VERIFY_ERASED_SECTOR */
#ifdef MULTI_DOC
/* No multi-doc (MTL) */ flUseMultiDoc = FL_OFF;/* MTL defragmentaion mode (0 - standard) */ flMTLdefragMode = FL_MTL_DEFRAGMENT_ALL_DEVICES;#endif /* MULTI_DOC */
/* Maximum chain length */ flMaxUnitChain = 20;/* Mark the delete sector on the flash */ flMarkDeleteOnFlash = FL_ON;/* Read Only mode */ flSuspendMode = FL_OFF;#endif /* ENVIRONMENT_VARS */
}
/*----------------------------------------------------------------------*//* m o u n t L o w L e v e l *//* *//* Mount a volume for low level operations. If a low level routine is *//* called and the volume is not mounted for low level operations, this *//* routine is called atomatically. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus mountLowLevel(Volume vol){ checkStatus(flIdentifyFlash(vol.socket,vol.flash)); vol.flash->setPowerOnCallback(vol.flash); vol.flags |= VOLUME_LOW_LVL_MOUNTED;
return flOK;}
/*----------------------------------------------------------------------*//* d i s m o u n t L o w L e v e l *//* *//* Dismount the volume for low level operations. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//*----------------------------------------------------------------------*/
static void dismountLowLevel(Volume vol){ /* mark the volume as unmounted for low level operations.
And does not change any of the other flags */ vol.flags &= ~VOLUME_LOW_LVL_MOUNTED;}
#ifdef FORMAT_VOLUME
/*----------------------------------------------------------------------*//* f i n d F r e e V o l u m e *//* *//* Search the vols array for an empty cell to hold the new volume . *//* *//* Parameters: *//* socket : Socket number for the new volume. *//* partition : Partition number of the new volume. *//* *//* Returns: *//* FLStatus : 0 on success, flGeneralFailure if no more *//* volumes left. *//*----------------------------------------------------------------------*/
static FLStatus findFreeVolume(byte socket, byte partition){ byte volNo;
for (volNo = noOfSockets;volNo < VOLUMES;volNo++) { if ((vols[volNo].flags & VOLUME_ACCUPIED) == 0) break; } if (volNo == VOLUMES) return flGeneralFailure;
handleConversionTable[socket][partition] = volNo; vols[volNo].volExecInProgress = &flMutex[socket]; vols[volNo].socket = vols[socket].socket; vols[volNo].flash = vols[socket].flash; vols[volNo].tl.socketNo = socket; vols[volNo].tl.partitionNo = partition; vols[volNo].flags = VOLUME_ACCUPIED; return flOK;}
/*----------------------------------------------------------------------*//* d i s m o u n t P h y s i c a l D r i v e *//* *//* Dismounts all the volumes on a specfic socket, closing all files. *//* This call is not normally necessary, unless it is known the volume *//* will soon be removed. The routine also clears the volumes entries in *//* the volume convertion table, except for partition 0 *//* *//* Parameters: *//* socketNo : Socket number to dismount. *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus dismountPhysicalDrive(byte socketNo){ byte volNo; byte partition;
/* Dismount all physical drive volumes */
checkStatus(dismountVolume(&vols[socketNo])); for(partition = 1;partition < MAX_TL_PARTITIONS; partition++) { volNo = handleConversionTable[socketNo][partition]; if (volNo != INVALID_VOLUME_NUMBER) { checkStatus(dismountVolume(&vols[volNo])); handleConversionTable[socketNo][partition]=INVALID_VOLUME_NUMBER; vols[volNo].flags = 0; } } return flOK;}#endif /* FORMAT_VOLUME */
/*----------------------------------------------------------------------*//* d i s m o u n t V o l u m e *//* *//* Dismounts the volume, closing all files. *//* This call is not normally necessary, unless it is known the volume *//* will soon be removed. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
FLStatus dismountVolume(Volume vol){ if (vol.flags & VOLUME_ABS_MOUNTED) { FLStatus status = flOK;#ifndef FIXED_MEDIA
status = flMediaCheck(vol.socket);#endif
if (status != flOK) vol.flags = 0;#if FILES>0
status = dismountFS(&vol,status);#endif
vol.tl.dismount(vol.tl.rec); } vol.flags = VOLUME_ACCUPIED; /* mark volume unmounted */
return flOK;}
/*----------------------------------------------------------------------*//* s e t B u s y *//* *//* Notifies the start and end of a file-system operation. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* state : FL_ON (1) = operation entry *//* FL_OFF(0) = operation exit *//* partition : Partition number of the drive *//* *//*----------------------------------------------------------------------*/
FLStatus setBusy(Volume vol, FLBoolean state, byte partition){ FLStatus status = flOK;
if (state == FL_ON) {
if (!flTakeMutex(execInProgress)) return flDriveNotAvailable; /* Mark current partition for MTD verify write */ vol.socket->curPartition = partition; flSocketSetBusy(vol.socket,FL_ON); flNeedVcc(vol.socket); if (vol.flags & VOLUME_ABS_MOUNTED) status = vol.tl.tlSetBusy(vol.tl.rec,FL_ON); } else { if (vol.flags & VOLUME_ABS_MOUNTED) status = vol.tl.tlSetBusy(vol.tl.rec,FL_OFF);
flDontNeedVcc(vol.socket); flSocketSetBusy(vol.socket,FL_OFF); flFreeMutex(execInProgress); }
return status;}
/*----------------------------------------------------------------------*//* f i n d S e c t o r *//* *//* Locates a sector in the buffer or maps it *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : Sector no. to locate *//* *//*----------------------------------------------------------------------*/
const void FAR0 *findSector(Volume vol, SectorNo sectorNo){ return#if FILES > 0
(sectorNo == vol.volBuffer.sectorNo && &vol == vol.volBuffer.owner) ? vol.volBuffer.flData :#endif
vol.tl.mapSector(vol.tl.rec,sectorNo,NULL);}
/*----------------------------------------------------------------------*//* a b s M o u n t V o l u m e *//* *//* Mounts the Flash volume and assume that volume has no FAT *//* *//* In case the inserted volume has changed, or on the first access to *//* the file system, it should be mounted before file operations can be *//* done on it. *//* Mounting a volume has the effect of discarding all open files (the *//* files cannot be properly closed since the original volume is gone), *//* and turning off the media-change indication to allow file processing *//* calls. *//* *//* The volume automatically becomes unmounted if it is removed or *//* changed. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
FLStatus absMountVolume(Volume vol){ unsigned volNo = (unsigned)(&vol - vols);#ifdef WRITE_PROTECTION
PartitionTable FAR0 *partitionTable;#endif
checkStatus(dismountVolume(&vol));
/* Try to mount translation layer */
checkStatus(flMount(volNo,vol.tl.socketNo,&vol.tl,TRUE,vol.flash));
vol.bootSectorNo = 0; /* assume sector 0 is DOS boot block */#ifdef WRITE_PROTECTION
partitionTable = (PartitionTable FAR0 *) findSector(&vol,0); if((partitionTable == NULL)|| (partitionTable==dataErrorToken)|| (LE2(partitionTable->signature) != PARTITION_SIGNATURE)) vol.password[0] = vol.password[1] = 0; else { vol.password[0] = vol.password[1] = 0; if (UNAL4(partitionTable->passwordInfo[0]) == 0 && (UNAL4(partitionTable->passwordInfo[1]) != 0 || UNAL4(partitionTable->passwordInfo[2]) != 0)) { vol.password[0] = UNAL4(partitionTable->passwordInfo[1]); vol.password[1] = UNAL4(partitionTable->passwordInfo[2]); vol.flags |= VOLUME_WRITE_PROTECTED; } }#endif /* WRITE_PROTECTION */
/* Disable FAT monitoring */ vol.firstFATSectorNo = vol.secondFATSectorNo = 0; vol.flags |= VOLUME_ABS_MOUNTED; /* Enough to do abs operations */
return flOK;}
/*----------------------------------------------------------------------*//* m o u n t V o l u m e *//* *//* Mounts the Flash volume. *//* *//* In case the inserted volume has changed, or on the first access to *//* the file system, it should be mounted before file operations can be *//* done on it. *//* Mounting a volume has the effect of discarding all open files (the *//* files cannot be properly closed since the original volume is gone), *//* and turning off the media-change indication to allow file processing *//* calls. *//* *//* The volume automatically becomes unmounted if it is removed or *//* changed. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//* bootSectors : Returns the number of sectors, flMountVolume *//* skipps. *//*----------------------------------------------------------------------*/
static FLStatus mountVolume(Volume vol,unsigned FAR2* bootSectors){ SectorNo noOfSectors; PartitionTable FAR0 *partitionTable; Partition ptEntry; DOSBootSector FAR0 *bootSector; unsigned ptCount,extended_depth,ptSector; FLBoolean primaryPtFound = FALSE, extendedPtFound = TRUE;
*bootSectors=0; checkStatus(absMountVolume(&vol));
for(extended_depth = 0,ptSector = 0; (extended_depth<MAX_PARTITION_DEPTH) && (primaryPtFound==FALSE) && (extendedPtFound==TRUE); extended_depth++) {
extendedPtFound=FALSE; /* Read in paritition table */
partitionTable = (PartitionTable FAR0 *) findSector(&vol,ptSector);
if(partitionTable == NULL) { vol.tl.dismount(vol.tl.rec); return flSectorNotFound; } if(partitionTable==dataErrorToken) { vol.tl.dismount(vol.tl.rec); return flDataError; }
if (LE2(partitionTable->signature) != PARTITION_SIGNATURE) break; for(ptCount=0; (ptCount<4) && (primaryPtFound==FALSE) && (extendedPtFound==FALSE); ptCount++) {
ptEntry = partitionTable->ptEntry[ptCount];
switch (ptEntry.type) { case FAT12_PARTIT: case FAT16_PARTIT: case DOS4_PARTIT: primaryPtFound = TRUE; vol.bootSectorNo = (unsigned) UNAL4(ptEntry.startingSectorOfPartition); *bootSectors=vol.bootSectorNo; break; case EX_PARTIT: extendedPtFound = TRUE; ptSector = (unsigned)UNAL4(ptEntry.startingSectorOfPartition); break; default: break; } } }
bootSector = (DOSBootSector FAR0 *) findSector(&vol,vol.bootSectorNo); if(bootSector == NULL) return flSectorNotFound;
if(bootSector==dataErrorToken) return flDataError;
/* Do the customary sanity checks */ if (!(bootSector->bpb.jumpInstruction[0] == 0xe9 || (bootSector->bpb.jumpInstruction[0] == 0xeb && bootSector->bpb.jumpInstruction[2] == 0x90))) { DEBUG_PRINT(("Debug: did not recognize format.\r\n")); return flNonFATformat; }
/* See if we handle this sector size */ if (UNAL2(bootSector->bpb.bytesPerSector) != SECTOR_SIZE) return flFormatNotSupported;
vol.sectorsPerCluster = bootSector->bpb.sectorsPerCluster; vol.numberOfFATS = bootSector->bpb.noOfFATS; vol.sectorsPerFAT = LE2(bootSector->bpb.sectorsPerFAT); vol.firstFATSectorNo = vol.bootSectorNo + LE2(bootSector->bpb.reservedSectors); vol.secondFATSectorNo = vol.firstFATSectorNo + LE2(bootSector->bpb.sectorsPerFAT); vol.rootDirectorySectorNo = vol.firstFATSectorNo + bootSector->bpb.noOfFATS * LE2(bootSector->bpb.sectorsPerFAT); vol.sectorsInRootDirectory = (UNAL2(bootSector->bpb.rootDirectoryEntries) * DIRECTORY_ENTRY_SIZE - 1) / SECTOR_SIZE + 1; vol.firstDataSectorNo = vol.rootDirectorySectorNo + vol.sectorsInRootDirectory;
noOfSectors = UNAL2(bootSector->bpb.totalSectorsInVolumeDOS3); if (noOfSectors == 0) noOfSectors = (SectorNo) LE4(bootSector->bpb.totalSectorsInVolume);
vol.maxCluster = (unsigned) ((noOfSectors + vol.bootSectorNo - vol.firstDataSectorNo) / vol.sectorsPerCluster) + 1;
if (vol.maxCluster < 4085) {#ifdef FAT_12BIT
vol.flags |= VOLUME_12BIT_FAT; /* 12-bit FAT */#else
DEBUG_PRINT(("Debug: FAT_12BIT must be defined.\r\n")); return flFormatNotSupported;#endif
} vol.bytesPerCluster = vol.sectorsPerCluster * SECTOR_SIZE; vol.allocationRover = 2; /* Set rover at first cluster */ vol.flags |= VOLUME_MOUNTED; /* That's it */ return flOK;}
#ifndef FL_READ_ONLY
#ifdef DEFRAGMENT_VOLUME
/*----------------------------------------------------------------------*//* d e f r a g m e n t V o l u m e *//* *//* Performs a general defragmentation and recycling of non-writable *//* Flash areas, to achieve optimal write speed. *//* *//* NOTE: The required number of sectors (in irLength) may be changed *//* (from another execution thread) while defragmentation is active. In *//* particular, the defragmentation may be cut short after it began by *//* modifying the irLength field to 0. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* ioreq->irLength : Minimum number of sectors to make available *//* for writes. *//* *//* Returns: *//* ioreq->irLength : Actual number of sectors available for writes *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus defragmentVolume(Volume vol, IOreq FAR2 *ioreq){ return vol.tl.defragment(vol.tl.rec,&ioreq->irLength);}
#endif /* DEFRAGMENT_VOLUME */
#ifdef FORMAT_VOLUME
/*-----------------------------------------------------------------------*//* f l F o r m a t V o l u m e *//* *//* Formats a volume, writing a new and empty file-system. All existing *//* data is destroyed. Optionally, a low-level FTL formatting is also *//* done. *//* Formatting leaves the volume in the dismounted state, so that a *//* flMountVolume call is necessary after it. *//* *//* Note: This routine was left for backwards compatibility with OSAK 4.2 *//* and down therfore it is strongly recommended to use the *//* flFormatPhysicalDrive routine instead. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irFlags : FAT_ONLY_FORMAT : Do FAT formatting only *//* TL_FORMAT_ONLY : Do TL format only *//* TL_FORMAT : Translation layer + FAT *//* TL_FORMAT_IF_NEEDED: Do TL formatting only if *//* current format is invalid *//* but perform FAT anyway *//* irData : Address of FormatParams structure to use *//* (defined in flformat.h) *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*-----------------------------------------------------------------------*/
static FLStatus bdFormatVolume(Volume vol, IOreq FAR2 *ioreq){ FormatParams FAR2 *userFp = (FormatParams FAR2 *) ioreq->irData; BDTLPartitionFormatParams bdtlFp; TLFormatParams tlFp; FLBoolean mountOK = FALSE; FLStatus status; byte socket = FL_GET_SOCKET_FROM_HANDLE(ioreq);
/* Convert argument to TLFormatParmas */
tlFp.noOfBinaryPartitions = 0; tlFp.noOfBDTLPartitions = 1; tlFp.BDTLPartitionInfo = NULL; tlFp.binaryPartitionInfo = NULL; tlFp.bootImageLen = userFp->bootImageLen; tlFp.percentUse = (byte)userFp->percentUse; tlFp.noOfSpareUnits = (byte)userFp->noOfSpareUnits; tlFp.noOfCascadedDevices = 0; tlFp.progressCallback = userFp->progressCallback; tlFp.vmAddressingLimit = userFp->vmAddressingLimit; tlFp.embeddedCISlength = (word)userFp->embeddedCISlength; tlFp.embeddedCIS = (byte FAR1 *)userFp->embeddedCIS; tlFp.flags = FL_LEAVE_BINARY_AREA;#ifdef WRITE_EXB_IMAGE
tlFp.exbLen = 0;#endif /* WRITE_EXB_IMAGE */
#ifdef HW_PROTECTION
/* protectionKey[8]; */ tlFp.protectionType = 0;#endif /* HW_PROTECTION */
/* Dismount all physical drive volumes and set handle to the first */
checkStatus(dismountPhysicalDrive(socket)); pVol = &vols[socket];
/* Format according to the irFlags argument */
if ((ioreq->irFlags & TL_FORMAT)||(ioreq->irFlags & TL_FORMAT_ONLY)) { checkStatus(flFormat(socket,&tlFp,vol.flash)); } else { status = flMount(socket,socket,&vol.tl,FALSE,vol.flash); /* Try to mount translation layer */ mountOK = TRUE; if ((status == flUnknownMedia || status == flBadFormat) && (ioreq->irFlags & TL_FORMAT_IF_NEEDED)) { status = flFormat(socket,&tlFp,vol.flash); mountOK = FALSE; } else { /* assume sector 0 is DOS boot block */ vol.bootSectorNo = 0; /* Disable FAT monitoring */ vol.firstFATSectorNo = vol.secondFATSectorNo = 0; /* Enough to do abs operations */ vol.flags |= VOLUME_ABS_MOUNTED; } if (status != flOK) return status; }
if (!mountOK) checkStatus(absMountVolume(&vol)); /* Mount the first partition */
#if (defined(VERIFY_WRITE) || defined(VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
if(vol.tl.checkVolume != NULL) checkStatus(vol.tl.checkVolume(vol.tl.rec));#endif /* VERIFY_WRITE || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
if(!(ioreq->irFlags & TL_FORMAT_ONLY)) { /* build BDTL record for dos format routine */
tffscpy(bdtlFp.volumeId,userFp->volumeId,4); bdtlFp.volumeLabel = (byte FAR1 *)userFp->volumeLabel; bdtlFp.noOfFATcopies = (byte)userFp->noOfFATcopies; bdtlFp.flags = TL_FORMAT_FAT; checkStatus(flDosFormat(&vol.tl,&bdtlFp)); } return flOK;}
/*----------------------------------------------------------------------*//* f l F o r m a t P h y s i c a l D r i v e *//* *//* Low Level formats the media while partitioning it. *//* optionaly the followng additional formats are placed *//* 1) writing a new and empty file-system *//* 2) Compressed media format *//* 3) Quick Mount format *//* *//* 4) Place M-systems EXB file on the media *//* All existing data is destroyed. *//* Formatting leaves the volume in the dismounted state, so that a *//* flMountVolume call is necessary after it. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irFlags : *//* TL_NORMAL_FORMAT : Normal format *//* TL_LEAVE_BINARY_AREA : Leave binary area unchanged *//* *//* irData : Address of FormatParams2 structure to use *//* (defined in flformat.h) *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus bdFormatPhysicalDrive(Volume vol, IOreq FAR2 *ioreq){ FormatParams2 FAR2* userFp = (FormatParams2 FAR2 *) ioreq->irData; BDTLPartitionFormatParams FAR2* bdtl; TLFormatParams tlFp; byte socket = FL_GET_SOCKET_FROM_HANDLE(ioreq); byte partition; byte volNo;#ifdef COMPRESSION
FLStatus status;#endif /* COMPRESSION */
/***********************************************/ /* Convert format parameters to TLFormatParams */ /***********************************************/
if (userFp->BDTLPartitionInfo == NULL) return flBadParameter;
/* Note that the the BDTL partition are shiftet so that the second
becomes the first ... . This is for backwards compatibility with FTP \ NFTL where the first partition is not given as an array */
tlFp.bootImageLen = -1; /* either all or nothing */ tlFp.percentUse = userFp->percentUse; tlFp.noOfBDTLPartitions = userFp->noOfBDTLPartitions; tlFp.noOfBinaryPartitions = userFp->noOfBinaryPartitions; tlFp.BDTLPartitionInfo = userFp->BDTLPartitionInfo; tlFp.binaryPartitionInfo = userFp->binaryPartitionInfo; tlFp.progressCallback = userFp->progressCallback; tlFp.vmAddressingLimit = userFp->vmAddressingLimit; tlFp.embeddedCISlength = userFp->embeddedCISlength; tlFp.embeddedCIS = userFp->embeddedCIS; tlFp.cascadedDeviceNo = userFp->cascadedDeviceNo; tlFp.noOfCascadedDevices = userFp->noOfCascadedDevices; tlFp.flags = (byte)ioreq->irFlags;
/* Convert last partition arguments from array to dedicated fields */
bdtl = userFp->BDTLPartitionInfo; bdtl += (userFp->noOfBDTLPartitions - 1); tffscpy(tlFp.volumeId,bdtl->volumeId,4); tlFp.noOfSpareUnits = (byte)bdtl->noOfSpareUnits; tlFp.volumeLabel = bdtl->volumeLabel; tlFp.noOfFATcopies = bdtl->noOfFATcopies;#ifdef HW_PROTECTION
tffscpy(tlFp.protectionKey,bdtl->protectionKey,PROTECTION_KEY_LENGTH); tlFp.protectionType = bdtl->protectionType;#endif /* HW_PROTECTION */
/* Dismount all physical drive volumes */
checkStatus(dismountPhysicalDrive(socket));
/**********************/ /* Analize EXB buffer */ /**********************/
pVol = &vols[socket];#ifdef WRITE_EXB_IMAGE
if ((ioreq->irFlags & TL_LEAVE_BINARY_AREA) || ((userFp->exbBufferLen <= 0) && (userFp->exbLen == 0))) { tlFp.exbLen = 0; } else { if (userFp->exbLen <= 0) { checkStatus(getExbInfo(&vol, userFp->exbBuffer, userFp->exbBufferLen, userFp->exbFlags)); tlFp.exbLen = vol.binaryLength; } else { tlFp.exbLen = userFp->exbLen; } }#endif /* WRITE_EXB_IMAGE */
/*************************************************/ /* Perform low level format and write EXB buffer */ /*************************************************/
checkStatus(flFormat(socket,&tlFp,vol.flash));
/****************************************/ /* perform FAT and ZIP format if needed */ /****************************************/
for(partition=0, bdtl = userFp->BDTLPartitionInfo; partition<userFp->noOfBDTLPartitions; partition++,bdtl++) { if ( partition > 0) checkStatus(findFreeVolume(socket,partition)); volNo = handleConversionTable[socket][partition]; pVol = &vols[volNo];#ifdef COMPRESSION
if(bdtl->flags & TL_FORMAT_COMPRESSED) { checkStatus(flMount(volNo,socket,&(vol.tl),FALSE,vol.flash)); status = flFormatZIP(volNo,&vol.tl); vol.tl.dismount(vol.tl.rec); if(status!=flOK) return status; }#endif /* COMPRESSION */
checkStatus(absMountVolume(&vol));#if (defined(VERIFY_WRITE) || defined(VERIFY_VOLUME) || defined(VERIFY_ERASED_SECTOR))
if(vol.tl.checkVolume != NULL) checkStatus(vol.tl.checkVolume(vol.tl.rec));#endif /* VERIFY_WRITE || VERIFY_VOLUME || VERIFY_ERASED_SECTOR */
if(bdtl->flags & TL_FORMAT_FAT) /* perform FAT format as well */ checkStatus(flDosFormat(&vol.tl,bdtl)); checkStatus(dismountVolume(&vol)); }
#ifdef WRITE_EXB_IMAGE
if (userFp->exbBufferLen > 0 ) { pVol = &vols[socket]; checkStatus(placeExbByBuffer(&vol,(byte FAR1 *)userFp->exbBuffer, userFp->exbBufferLen,userFp->exbWindow,userFp->exbFlags)); }#endif /* WRITE_EXB_IMAGE */
checkStatus(mountLowLevel(&vol)); if (vol.flash->download!=NULL) { return vol.flash->download(vol.flash); /* download IPL */ } return flOK;}
/*-----------------------------------------------------------------------*//* f l F o r m a t L o g i c a l D r i v e *//* *//* Formats a logical drive, optionaly writing a new and empty *//* file-system and or a compressed format. All existing *//* data is destroyed. *//* Formatting leaves the volume in the dismounted state, so that a *//* flMountVolume call is necessary after it. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irData : Address of BDTLPartitionFormatParams to use *//* (defined in flformat.h) *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*-----------------------------------------------------------------------*/
static FLStatus bdFormatLogicalDrive(Volume vol, IOreq FAR2 *ioreq){ BDTLPartitionFormatParams FAR2 *userFp = (BDTLPartitionFormatParams FAR2 *) ioreq->irData; byte volNo = (byte)(&vol-vols);#ifdef COMPRESSION
FLStatus status;#endif /* COMPRESSION */
checkStatus(flMount(volNo,vol.tl.socketNo,&(vol.tl),FALSE,vol.flash)); /* assume sector 0 is DOS boot block */ vol.bootSectorNo = 0; /* Disable FAT monitoring */ vol.firstFATSectorNo = vol.secondFATSectorNo = 0; /* Enough to do abs operations */ vol.flags |= VOLUME_ABS_MOUNTED;
#ifdef COMPRESSION
if(userFp->flags & TL_FORMAT_COMPRESSED) { status = flFormatZIP(volNo,&vol.tl,vol.flash); vol.tl.dismount(vol.tl.rec); if(status!=flOK) return status; }#endif /* COMPRESSION */
if(userFp->flags & TL_FORMAT_FAT) /* perform FAT format as well */ { checkStatus(absMountVolume(&vol)); checkStatus(flDosFormat(&vol.tl,userFp)); checkStatus(dismountVolume(&vol)); } return flOK;}#endif /* FORMAT_VOLUME */
#endif /* FL_READ_ONLY */
/*----------------------------------------------------------------------*//* s e c t o r s I n V o l u m e *//* *//* Defines actual number of virtual sectors according to the low-level *//* format of the media. *//* *//* Returns: *//* vol : Pointer identifying drive *//* ioreq->irLength : Actual number of virtual sectors in volume *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/static FLStatus sectorsInVolume(Volume vol, IOreq FAR2 *ioreq){ dword sectorsInVol = vol.tl.sectorsInVolume(vol.tl.rec); if(sectorsInVol<=vol.bootSectorNo) { ioreq->irLength = 0; return flGeneralFailure; }
ioreq->irLength = sectorsInVol-vol.bootSectorNo; return flOK;}
#ifdef ABS_READ_WRITE
/*----------------------------------------------------------------------*//* a b s R e a d *//* *//* Reads absolute sectors by sector no. *//* *//* Note that if readSecots is not implemented irSectoCount will not *//* return the actual number of sectors written in case the operation *//* failed in the middle. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irData : Address of user buffer to read into *//* irSectorNo : First sector no. to read (sector 0 is the *//* DOS boot sector). *//* irSectorCount : Number of consectutive sectors to read *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//* irSectorCount : Number of sectors actually read *//*----------------------------------------------------------------------*/
static FLStatus absRead(Volume vol, IOreq FAR2 *ioreq){ char FAR1 *userBuffer = (char FAR1 *) ioreq->irData; SectorNo currSector = vol.bootSectorNo + ioreq->irSectorNo; void FAR0 *mappedSector; FLStatus status;
if (vol.tl.readSectors != NULL) { status = vol.tl.readSectors(vol.tl.rec , currSector, (byte FAR1* )ioreq->irData , ioreq->irSectorCount);
if (status == flSectorNotFound) { /* Do not report unassigned sectors. Simply report all 0's */ if(vol.tl.sectorsInVolume(vol.tl.rec) >= (currSector+ioreq->irSectorCount)) return flOK; } return status; } else { SectorNo sectorCount = (SectorNo)ioreq->irSectorCount; for (ioreq->irSectorCount = 0; (SectorNo)(ioreq->irSectorCount) < sectorCount; ioreq->irSectorCount++, currSector++, userBuffer += SECTOR_SIZE) {#ifdef SCATTER_GATHER
userBuffer = *((char FAR1 **)(ioreq->irData) + (int)(ioreq->irSectorCount));#endif
mappedSector = (void FAR0 *)findSector(&vol,currSector); if (mappedSector) { if(mappedSector==dataErrorToken) return flDataError;
tffscpy(userBuffer,mappedSector,SECTOR_SIZE); } else { if(vol.tl.sectorsInVolume(vol.tl.rec)<=(currSector)) return flSectorNotFound; tffsset(userBuffer,0,SECTOR_SIZE); } } } return flOK;}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*//* r e p l a c e F A T s e c t o r *//* *//* Monitors sector deletions in the FAT. *//* *//* When a FAT block is about to be written by an absolute write, this *//* routine will first scan whether any sectors are being logically *//* deleted by this FAT update, and if so, it will delete-sector them *//* before the actual FAT update takes place. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* sectorNo : FAT Sector no. about to be written *//* newFATsector : Address of FAT sector about to be written *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
FLStatus replaceFATsector(Volume vol, SectorNo sectorNo, const char FAR1 *newFATsector){ const char FAR0 *oldFATsector = (const char FAR0 *)findSector(&vol,sectorNo); SectorNo firstSector; unsigned firstCluster;#ifdef FAT_12BIT
word FAThalfBytes; word halfByteOffset;#else
word byteOffset;#endif
if((oldFATsector==NULL) || oldFATsector==dataErrorToken) return flOK;
#ifdef FAT_12BIT
FAThalfBytes = vol.flags & VOLUME_12BIT_FAT ? 3 : 4;
firstCluster = (FAThalfBytes == 3) ? (((unsigned) (sectorNo - vol.firstFATSectorNo) * (2 * SECTOR_SIZE) + 2) / 3) : ((unsigned) (sectorNo - vol.firstFATSectorNo) * (SECTOR_SIZE>>1)); firstSector = ((SectorNo) firstCluster - 2) * vol.sectorsPerCluster + vol.firstDataSectorNo; halfByteOffset = (firstCluster * FAThalfBytes) & ((SECTOR_SIZE<<1) - 1);
/* Find if any clusters were logically deleted, and if so, delete them */ /* NOTE: We are skipping over 12-bit FAT entries which span more than */ /* one sector. Nobody's perfect anyway. */ for (; halfByteOffset < ((SECTOR_SIZE<<1) - 2); firstSector += vol.sectorsPerCluster, halfByteOffset += FAThalfBytes) { unsigned short oldFATentry, newFATentry;
#ifdef FL_BIG_ENDIAN
oldFATentry = LE2(*(LEushort FAR0 *)(oldFATsector + (halfByteOffset>>1))); newFATentry = LE2(*(LEushort FAR1 *)(newFATsector + (halfByteOffset>>1)));#else
oldFATentry = UNAL2(*(Unaligned FAR0 *)(oldFATsector + (halfByteOffset / 2))); newFATentry = UNAL2(*(Unaligned FAR1 *)(newFATsector + (halfByteOffset / 2)));#endif
if (halfByteOffset & 1) { oldFATentry >>= 4; newFATentry >>= 4; } else if (FAThalfBytes == 3) { oldFATentry &= 0xfff; newFATentry &= 0xfff; }#else
firstCluster = ((unsigned) (sectorNo - vol.firstFATSectorNo) << (SECTOR_SIZE_BITS-1)); firstSector = ((SectorNo) firstCluster - 2) * vol.sectorsPerCluster + vol.firstDataSectorNo;
/* Find if any clusters were logically deleted, and if so, delete them */ for (byteOffset = 0; byteOffset < SECTOR_SIZE; firstSector += vol.sectorsPerCluster, byteOffset += 2) { unsigned short oldFATentry = LE2(*(LEushort FAR0 *)(oldFATsector + byteOffset)); unsigned short newFATentry = LE2(*(LEushort FAR1 *)(newFATsector + byteOffset));#endif
if (oldFATentry != FAT_FREE && newFATentry == FAT_FREE) checkStatus(vol.tl.deleteSector(vol.tl.rec,firstSector,vol.sectorsPerCluster));
/* make sure sector is still there */ oldFATsector = (const char FAR0 *) findSector(&vol,sectorNo); }
return flOK;}
/*----------------------------------------------------------------------*//* a b s W r i t e *//* *//* Writes absolute sectors by sector no. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irData : Address of user buffer to write from *//* irSectorNo : First sector no. to write (sector 0 is the *//* DOS boot sector). *//* irSectorCount : Number of consectutive sectors to write *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//* irSectorCount : Number of sectors actually written *//*----------------------------------------------------------------------*/
static FLStatus absWrite(Volume vol, IOreq FAR2 *ioreq){ char FAR1 *userBuffer = (char FAR1 *) ioreq->irData; SectorNo currSector = vol.bootSectorNo + ioreq->irSectorNo; SectorNo sectorCount = (SectorNo)ioreq->irSectorCount;
if (currSector < vol.secondFATSectorNo && currSector + sectorCount > vol.firstFATSectorNo) { SectorNo iSector;
for (iSector = 0; iSector < sectorCount; iSector++, currSector++, userBuffer += SECTOR_SIZE) {
if (currSector >= vol.firstFATSectorNo && currSector < vol.secondFATSectorNo) replaceFATsector(&vol,currSector,userBuffer); }
userBuffer = (char FAR1 *) ioreq->irData; currSector = (SectorNo)vol.bootSectorNo + (SectorNo)ioreq->irSectorNo; } if (vol.tl.writeMultiSector != NULL) { checkStatus(vol.tl.writeMultiSector(vol.tl.rec, currSector, ioreq->irData,ioreq->irSectorCount)); } else { for (ioreq->irSectorCount = 0; (SectorNo)(ioreq->irSectorCount) < sectorCount; ioreq->irSectorCount++, currSector++, userBuffer += SECTOR_SIZE) {#if FILES>0
if ((currSector == vol.volBuffer.sectorNo) && (&vol == vol.volBuffer.owner)) { vol.volBuffer.sectorNo = UNASSIGNED_SECTOR; /* no longer valid */ vol.volBuffer.dirty = vol.volBuffer.checkPoint = FALSE; }#endif
#ifdef SCATTER_GATHER
userBuffer = *((char FAR1 **)(ioreq->irData)+(int)(ioreq->irSectorCount));#endif
checkStatus(vol.tl.writeSector(vol.tl.rec,currSector,userBuffer)); } } return flOK;}
/*----------------------------------------------------------------------*//* a b s D e l e t e *//* *//* Marks absolute sectors by sector no. as deleted. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irSectorNo : First sector no. to write (sector 0 is the *//* DOS boot sector). *//* irSectorCount : Number of consectutive sectors to delete *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus absDelete(Volume vol, IOreq FAR2 *ioreq){ SectorNo first; first = (SectorNo)(vol.bootSectorNo + ioreq->irSectorNo); return vol.tl.deleteSector(vol.tl.rec,first,(SectorNo)ioreq->irSectorCount);}
#endif /* FL_READ_ONLY */
#ifndef NO_PHYSICAL_IO
/*----------------------------------------------------------------------*//* f l A b s A d d r e s s *//* *//* Returns the current physical media offset of an absolute sector by *//* sector no. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irSectorNo : Sector no. to address (sector 0 is the DOS *//* boot sector) *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//* irCount : Offset of the sector on the physical media *//*----------------------------------------------------------------------*/
static FLStatus absAddress(Volume vol, IOreq FAR2 *ioreq){ CardAddress cardOffset; const void FAR0 * sectorData = vol.tl.mapSector(vol.tl.rec,vol.bootSectorNo + ioreq->irSectorNo,&cardOffset);
if (sectorData) { if(sectorData==dataErrorToken) return flDataError;
ioreq->irCount = cardOffset; return flOK; } else return flSectorNotFound;}
#endif /* NO_PHYSICAL_IO */
/*----------------------------------------------------------------------*//* g e t B P B *//* *//* Reads the BIOS Parameter Block from the boot sector *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irData : Address of user buffer to read BPB into *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus getBPB(Volume vol, IOreq FAR2 *ioreq){ BPB FAR1 *userBPB = (BPB FAR1 *) ioreq->irData; DOSBootSector FAR0 *bootSector;
bootSector = (DOSBootSector FAR0 *) findSector(&vol,vol.bootSectorNo); if(bootSector == NULL) return flSectorNotFound; if(bootSector==dataErrorToken) return flDataError;
*userBPB = bootSector->bpb; return flOK;}
#ifndef FL_READ_ONLY
#ifdef WRITE_PROTECTION
/*----------------------------------------------------------------------*//* c h a n g e P a s s w o r d *//* *//* Change password for write protectipon. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus changePassword(Volume vol) { PartitionTable partitionTable; IOreq ioreq; FLStatus status;#ifdef SCATTER_GATHER
void FAR1 *iovec[1];#endif
ioreq.irHandle=(unsigned)(&vol-vols); ioreq.irSectorNo=0-(int)vol.bootSectorNo; ioreq.irSectorCount=1;#ifdef SCATTER_GATHER
iovec[0] = (void FAR1 *) &partitionTable; ioreq.irData = (void FAR1 *) iovec;#else
ioreq.irData=&partitionTable;#endif
if((status=absRead(&vol,&ioreq))!=flOK) return status; toUNAL4(partitionTable.passwordInfo[0], 0); toUNAL4(partitionTable.passwordInfo[1],vol.password[0]); toUNAL4(partitionTable.passwordInfo[2],vol.password[1]);
vol.flags &= ~VOLUME_WRITE_PROTECTED;
return absWrite(&vol,&ioreq);}
/*----------------------------------------------------------------------*//* w r i t e P r o t e c t *//* *//* Put and remove write protection from the volume *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number ( 0,1,2... ) *//* irFlags : FL_PROTECT = place protection *//* FL_UNPROTECT = remove protection *//* FL_UNLOCK = remove protection until next dismount *//* irData : password (8 bytes) *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus writeProtect(Volume vol,IOreq FAR2*ioreq){ FLStatus status=flWriteProtect; dword *flData=(dword *)ioreq->irData; dword passCode1 = flData[0] ^ SCRAMBLE_KEY_1; dword passCode2 = flData[1] ^ SCRAMBLE_KEY_2;
switch (ioreq->irFlags) {
case FL_UNLOCK: /* unlock volume */ if((vol.password[0] == passCode1 && vol.password[1] == passCode2)|| (vol.password[0] == 0 && vol.password[1] == 0)) { vol.flags &= ~VOLUME_WRITE_PROTECTED; status=flOK; } else status=flWriteProtect; break;
case FL_UNPROTECT: /* remove password */ if(vol.password[0] == passCode1 && vol.password[1] == passCode2) { vol.password[0] = vol.password[1] = 0; status = changePassword(&vol); } else status=flWriteProtect; break;
case FL_PROTECT: /* set password */ if(vol.password[0] == 0 && vol.password[1] == 0) { vol.password[0] = passCode1; vol.password[1] = passCode2; status = changePassword(&vol); vol.flags|=VOLUME_WRITE_PROTECTED; } else status=flWriteProtect; break;
default: status = flGeneralFailure; }return status;}#endif /* WRITE_PROTECTION */
#endif /* FL_READ_ONLY */
#endif /* ABS_READ_WRITE */
/*----------------------------------------------------------------------*//* s o c k e t I n f o *//* *//* Get socket Information (window base address) *//* *//* Parameters: *//* vol : Pointer identifying drive *//* baseAddress : pointer to receive window base address *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus socketInfo(Volume vol, dword FAR2 *baseAddress){ *baseAddress = (long)(vol.socket->window.baseAddress) << 12; return flOK;}
#ifdef FL_LOW_LEVEL
/*----------------------------------------------------------------------*//* g e t P h y s i c a l I n f o *//* *//* Get physical information of the media. The information includes *//* JEDEC ID, unit size and media size. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irData : Address of user buffer to read physical *//* information into. *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//* irLength : Physical base address of device *//*----------------------------------------------------------------------*/
static FLStatus getPhysicalInfo(Volume vol, IOreq FAR2 *ioreq){ PhysicalInfo FAR2 *physicalInfo = (PhysicalInfo FAR2 *)ioreq->irData;
physicalInfo->type = vol.flash->type; physicalInfo->unitSize = vol.flash->erasableBlockSize; physicalInfo->mediaSize = vol.flash->chipSize * vol.flash->noOfChips; physicalInfo->chipSize = vol.flash->chipSize; physicalInfo->interleaving = vol.flash->interleaving; switch(vol.flash->mediaType) { case NOT_DOC_TYPE: physicalInfo->mediaType = FL_NOT_DOC; break; case DOC_TYPE : physicalInfo->mediaType = FL_DOC; break; case MDOC_TYPE : physicalInfo->mediaType = FL_MDOC; break; case MDOCP_TYPE : physicalInfo->mediaType = FL_MDOCP; break; case DOC2000TSOP_TYPE : physicalInfo->mediaType = FL_DOC2000TSOP; break; case MDOCP_16_TYPE : physicalInfo->mediaType = FL_MDOCP_16; break; } socketInfo(&vol,(dword FAR2 *) &(ioreq->irLength)); return flOK;}
#ifndef NO_PHYSICAL_IO
/*----------------------------------------------------------------------*//* p h y s i c a l R e a d *//* *//* Read from a physical address. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irAddress : Physical address to read from. *//* irByteCount : Number of bytes to read. *//* irData : Address of user buffer to read into. *//* irFlags : Mode of the operation. *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus physicalRead(Volume vol, IOreq FAR2 *ioreq){ /* check that we are reading whithin the media boundaries */ if (ioreq->irAddress + (long)ioreq->irByteCount > (long)vol.flash->chipSize * vol.flash->noOfChips) return flBadParameter;
/* We don't read accross a unit boundary */ if ((long)ioreq->irByteCount > (long)(vol.flash->erasableBlockSize - (ioreq->irAddress % vol.flash->erasableBlockSize))) return flBadParameter;
checkStatus(vol.flash->read(vol.flash, ioreq->irAddress, ioreq->irData, (word)ioreq->irByteCount, (word)ioreq->irFlags)); return flOK;}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*//* p h y s i c a l W r i t e *//* *//* Write to a physical address. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irAddress : Physical address to write to. *//* irByteCount : Number of bytes to write. *//* irData : Address of user buffer to write from. *//* irFlags : Mode of the operation. *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus physicalWrite(Volume vol, IOreq FAR2 *ioreq){ /* check that we are writing whithin the media boundaries */ if (ioreq->irAddress + (long)ioreq->irByteCount > (long)(vol.flash->chipSize * vol.flash->noOfChips)) return flBadParameter;
/* We don't write accross a unit boundary */ if (ioreq->irByteCount > (long)(vol.flash->erasableBlockSize - (ioreq->irAddress % vol.flash->erasableBlockSize))) return flBadParameter;
checkStatus(vol.flash->write(vol.flash, ioreq->irAddress, ioreq->irData, (dword)ioreq->irByteCount, (word)ioreq->irFlags)); return flOK;}
/*----------------------------------------------------------------------*//* p h y s i c a l E r a s e *//* *//* Erase physical units. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irUnitNo : First unit to erase. *//* irUnitCount : Number of units to erase. *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus physicalErase(Volume vol, IOreq FAR2 *ioreq){ if (ioreq->irUnitNo + (long)ioreq->irUnitCount > (long) (vol.flash->chipSize * vol.flash->noOfChips / vol.flash->erasableBlockSize)) return flBadParameter;
checkStatus(vol.flash->erase(vol.flash, (word)ioreq->irUnitNo, (word)ioreq->irUnitCount)); return flOK;}#endif /* NO_PHYSICAL_IO */
#endif /* FL_READ_ONLY */
#ifndef NO_IPL_CODE
/*----------------------------------------------------------------------*//* r e a d I P L *//* *//* Read IPL to user buffer. *//* *//* Note : Read length must be a multiplication of 512 bytes *//* Note : Causes DiskOnChip Millennium Plus to download (i,e protection *//* key will be removed from all partitions. *//* *//* Parameters: *//* flash : Pointer identifying flash medium of the volume *//* irHandle : Socket number ( 0,1,2... ) *//* buf : User buffer to read into *//* bufLen : Size of user buffer *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus readIPL(FLFlash* flash, byte FAR1 * buf , dword bufLen){ FLStatus status; dword secondCopyOffset = 1024;
if(bufLen & 512) { DEBUG_PRINT(("ERROR - Must read a multiplication of 512 bytes.\r\n")); return flBadLength; }
switch (flash->mediaType) { case MDOCP_TYPE: /* have a special place for the IPL */ case MDOCP_16_TYPE: if (flash->readIPL != NULL) { checkStatus(flash->readIPL(flash,buf,(word)bufLen)); return flOK; } break; case MDOC_TYPE: if(bufLen != 512) { DEBUG_PRINT(("ERROR - DiskOnChip Millennium 8M has only 512 Bytes of XIP.\r\n")); return flBadLength; } secondCopyOffset = 512;
case DOC2000TSOP_TYPE: /* Have a special place for the IPL */ if(bufLen > 1024) { DEBUG_PRINT(("ERROR - DiskOnChip 2000 TSOP has only 1024 Bytes of XIP.\r\n")); return flBadLength; } if(flash->read != NULL) { status = flash->read(flash,0,buf,bufLen,EDC); if(status != flOK) return flash->read(flash,secondCopyOffset,buf,bufLen,EDC); return status; } break; default : if(bufLen != 512) { DEBUG_PRINT(("ERROR - DiskOnChip 2000 has only 512 Bytes of XIP.\r\n")); return flBadLength; } if(flash->win != NULL) { tffscpy(buf,(const void FAR1*)flash->win,bufLen); } break; } return flGeneralFailure;}
#ifndef FL_READ_ONLY
/*----------------------------------------------------------------------*//* w r i t e I P L *//* *//* Write IPL to the proper media location *//* *//* Parameters: *//* flash : Pointer identifying flash medium of the volume *//* irHandle : Socket number ( 0,1,2... ) *//* buf : User buffer containin data to write to the IPL *//* bufLen : Size of user buffer *//* flags : FL_IPL_MODE_NORMAL : None Strong Arm mode *//* FL_IPL_DOWNLOAD : Download new IPL when done *//* FL_IPL_MODE_SA : Strong Arm mode *//* FL_IPL_MODE_XSCALE : X-Scale mode *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus writeIPL(FLFlash* flash, byte FAR1 * buf , dword bufLen , unsigned flags){ switch (flash->mediaType) { case DOC2000TSOP_TYPE: /* Have a special place for the IPL */ case MDOCP_TYPE : case MDOCP_16_TYPE : if (flash->writeIPL != NULL) return (flash->writeIPL(flash,buf,(word)bufLen,0,flags)); DFORMAT_PRINT(("ERROR - MTD does not support write IPL (Please reconfigure MTD).\r\n")); break; case MDOC_TYPE: DFORMAT_PRINT(("ERROR - DiskOnChip Millennium does not support write IPL, use the /BDFK flag.\r\n")); break; default : DFORMAT_PRINT(("ERROR - DiskOnChip 2000 does not support a writiable IPL.\r\n")); break; } return flFeatureNotSupported;}#endif /* FL_READ_ONLY */
#endif /* NO_IPL_CODE */
#ifndef NO_INQUIRE_CAPABILITIES
/*----------------------------------------------------------------------*//* i n q u i r e C a p a b i l i t i e s *//* *//* Get the specific device S/W and H/W capabilities *//* *//* Parameters: *//* flash : Record discribing the media *//* 4 LSB - Socket number *//* capability : Enumarator representing the capability *//* Returns: *//* capability : CAPABILITY_SUPPORTED if the capability is *//* supported *//* *//*----------------------------------------------------------------------*/
static void inquireCapabilities(FLFlash* flash , FLCapability FAR2* capability){ FLCapability inquiredCapability = *capability;
*capability = CAPABILITY_NOT_SUPPORTED;
switch (inquiredCapability) {#ifdef HW_OTP
case SUPPORT_UNERASABLE_BBT: case SUPPORT_OTP_AREA: if(flash->otpSize != NULL) *capability = CAPABILITY_SUPPORTED; break; case SUPPORT_CUSTOMER_ID: case SUPPORT_UNIQUE_ID: if(flash->getUniqueId != NULL) *capability = CAPABILITY_SUPPORTED; break;#endif /* HW_OTP */
case SUPPORT_MULTIPLE_BDTL_PARTITIONS: case SUPPORT_MULTIPLE_BINARY_PARTITIONS: if(flash->flags & INFTL_ENABLED) *capability = CAPABILITY_SUPPORTED; break;
#ifdef HW_PROTECTION
case SUPPORT_HW_PROTECTION: case SUPPORT_HW_LOCK_KEY: if(flash->protectionKeyInsert != NULL) *capability = CAPABILITY_SUPPORTED; break;#endif /* HW_PROTECTION */
case SUPPORT_DEEP_POWER_DOWN_MODE: if(flash->enterDeepPowerDownMode != NULL) *capability = CAPABILITY_SUPPORTED; break; case SUPPORT_WRITE_IPL_ROUTINE: if((flash->mediaType == DOC2000TSOP_TYPE) || (flash->mediaType == MDOC_TYPE)) *capability = CAPABILITY_SUPPORTED; break; default: break; }}#endif /* NO_INQUIRE_CAPABILITIES */
#endif /* FL_LOW_LEVEL */
/*----------------------------------------------------------------------*//* f l B u i l d G e o m e t r y *//* *//* Get C/H/S information of the disk according to number of sectors. *//* *//* Parameters: *//* capacity : Number of Sectors in Volume *//* cylinders : Pointer to Number of Cylinders *//* heads : Pointer to Number of Heads *//* sectors : Pointer to Number of Sectors per Track *//* oldFormat : True for one sector per culoster *//* *//*----------------------------------------------------------------------*/
void NAMING_CONVENTION flBuildGeometry(dword capacity, dword FAR2 *cylinders, dword FAR2 *heads,dword FAR2 *sectors, FLBoolean oldFormat){ dword temp;
*cylinders = 1024; /* Set number of cylinders to max value */
if (oldFormat == TRUE) { *sectors = 62L; /* Max out number of sectors per track */ temp = (*cylinders) * (*sectors); /* Compute divisor for heads */ (*heads) = capacity / temp; /* Compute value for number of heads */ if (capacity % temp) { /* If no remainder, done! */ (*heads)++; /* Else, increment number of heads */ temp = (*cylinders) * (*heads); /* Compute divisor for sectors */ (*sectors) = capacity / temp; /* Compute value for sectors per track */ if (capacity % temp) { /* If no remainder, done! */ (*sectors)++; /* Else, increment number of sectors */ temp = (*heads) * (*sectors); /* Compute divisor for cylinders */ (*cylinders) = capacity / temp; /* Compute number of cylinders */ } } } else { *heads = 16L; /* Max out number of heads */ temp = (*cylinders) * (*heads); /* Compute divisor for heads */ *sectors = capacity / temp; /* Compute value for sectors per track */ while (*sectors > 0x3f ){ /* While number of sectors too big */ *heads *= 2; /* use one more head */ temp = (*cylinders) * (*heads); /* Recompute divisor for heads */ *sectors = capacity / temp; /* Recompute sectors per track */ } if (capacity % temp) { /* If no remainder, done! */ (*sectors)++; /* Else, increment number of sectors */ temp = (*cylinders) * (*sectors); /* Compute divisor for heads */ *heads = capacity / temp; /* Compute value for heads */ if (capacity % temp) { /* If no remainder, done! */ (*heads)++; /* Else, increment number of heads */ temp = (*heads) * (*sectors); /* Compute divisor for cylinders */ *cylinders = (dword)(capacity / temp); /* Compute number of cylinders */ } } }}
/*----------------------------------------------------------------------*//* v o l u m e I n f o *//* *//* Get general volume Information. *//* *//* Parameters: *//* vol : Pointer identifying drive *//* irHandle : Drive number (0, 1, ...) *//* irData : pointer to VolumeInfoRecord *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
static FLStatus volumeInfo(Volume vol, IOreq FAR2 *ioreq){ VolumeInfoRecord FAR2 *info = (VolumeInfoRecord FAR2 *)(ioreq->irData);#ifdef FL_LOW_LEVEL
IOreq ioreq2; PhysicalInfo physicalInfo; char wasLowLevelMounted = 1;#endif
TLInfo tlInfo;#ifdef FL_LOW_LEVEL
dword eraseCyclesPerUnit;#endif /* FL_LOW_LEVEL */
#ifdef FL_LOW_LEVEL
ioreq2.irHandle = ioreq->irHandle; if (!(vol.flags & VOLUME_LOW_LVL_MOUNTED)) { checkStatus(mountLowLevel(&vol)); wasLowLevelMounted = 0; } ioreq2.irData = &physicalInfo; checkStatus(getPhysicalInfo(&vol, &ioreq2)); info->flashType = physicalInfo.type; info->physicalUnitSize = (unsigned short)physicalInfo.unitSize; info->physicalSize = physicalInfo.mediaSize; info->DOCType = physicalInfo.mediaType;#endif /* FL_LOW_LEVEL */
tffsset(info->driverVer,0,sizeof(info->driverVer)); tffsset(info->OSAKVer,0,sizeof(info->OSAKVer)); tffscpy(info->driverVer,driverVersion, TFFSMIN(sizeof(info->driverVer),sizeof(driverVersion))); tffscpy(info->OSAKVer,OSAKVersion, TFFSMIN(sizeof(info->OSAKVer),sizeof(OSAKVersion))); checkStatus(socketInfo(&vol, &(info->baseAddress))); checkStatus(vol.tl.getTLInfo(vol.tl.rec,&tlInfo)); info->logicalSectors = tlInfo.sectorsInVolume; info->bootAreaSize = tlInfo.bootAreaSize;
#ifdef ABS_READ_WRITE
flBuildGeometry( tlInfo.sectorsInVolume, (dword FAR2 *)&(info->cylinders), (dword FAR2 *)&(info->heads), (dword FAR2 *)&(info->sectors),FALSE);#endif /* ABS_READ_WRITE */
#ifdef FL_LOW_LEVEL
eraseCyclesPerUnit = vol.flash->maxEraseCycles; info->lifeTime = (char)(((tlInfo.eraseCycles / (eraseCyclesPerUnit * (physicalInfo.mediaSize / physicalInfo.unitSize))) % 10) + 1); if(!wasLowLevelMounted) dismountLowLevel(&vol);#endif /* FL_LOW_LEVEL */
return flOK;}
/*----------------------------------------------------------------------*//* b d C a l l *//* *//* Common entry-point to all file-system functions. Macros are *//* to call individual function, which are separately described below. *//* *//* Parameters: *//* function : file-system function code (listed below) *//* ioreq : IOreq structure *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
FLStatus NAMING_CONVENTION bdCall(FLFunctionNo functionNo, IOreq FAR2 *ioreq){ Volume vol = NULL; FLStatus status; byte volNo;#if defined(FILES) && FILES>0
File *file;#endif
byte socket = FL_GET_SOCKET_FROM_HANDLE(ioreq); byte partition = FL_GET_PARTITION_FROM_HANDLE(ioreq); byte curPartitionForEnvVars;
/***********************************************//*** ***//*** find the volume record to work on ***//*** ***//***********************************************/
if (initDone == FALSE) checkStatus(flInit());
/** ori - We are not taking mutex befre cheking fileTable */
/**************************************//* working with open files operations *//**************************************/
#if defined(FILES) && FILES>0
/* Verify file handle if applicable */ if ((functionNo < INDEX_OPENFILES_END) && ((functionNo != FL_FIND_FILE)||(ioreq->irFlags & FIND_BY_HANDLE))) { if ((ioreq->irHandle < FILES) && (fileTable[ioreq->irHandle].flags & FILE_IS_OPEN)) { file = fileTable + ioreq->irHandle; pVol = file->fileVol; socket = vol.tl.socketNo; partition = vol.tl.partitionNo; } else { return flBadFileHandle; } }
#endif /* FILES>0 */
/* Set environment variable current partition. */ curPartitionForEnvVars = partition;
/****************************************************//* None files operations are divided into 3 groups: *//* 1. Uses the specific partition volume record. *//* 2. Must be called with partition number 0. *//* 3. Must use partition number 0 and ignore *//* the given partition (binary operations). *//****************************************************/
if (pVol == NULL) /* irHandle is drive no. */ {
/* Handle sanity check */
if ((socket >= noOfSockets) || (partition >= MAX_TL_PARTITIONS)) return flBadDriveHandle;
volNo = handleConversionTable[socket][partition];
/* Some operation must not be checked ONLY for socket sanity */
if((functionNo < INDEX_BINARY_END) && /* Group 3 */ (functionNo > INDEX_BINARY_START)) { volNo = socket;
/* Binary partitions are numbered after BDTL partitions */ curPartitionForEnvVars = (byte)(MAX_TL_PARTITIONS+partition); }
/* The rest must be checked for socket and volume sanity */
else { if (volNo == INVALID_VOLUME_NUMBER) /* Group 1 + 2 */ return flBadDriveHandle;
/* Some operation must be called with partition 0 */
if ((functionNo > INDEX_NEED_PARTITION_0_START) && /* Group 2 */ (functionNo < INDEX_NEED_PARTITION_0_END)) { if(partition != 0) { return flBadDriveHandle; } else /* Use general verify write environement variable */ { curPartitionForEnvVars = (MAX_TL_PARTITIONS<<1)-1; } } } pVol = &vols[volNo]; }
/********************************************************************//*** ***//*** Volume record has been found. Now verify that the volume ***//*** record is ready for the specific operation. ***//*** ***//********************************************************************/
status = setBusy(&vol,FL_ON,curPartitionForEnvVars); /* Let everyone know we are here */
/*******************************//* Verify S/W write protection *//*******************************/
#if defined(WRITE_PROTECTION)&& !defined(FL_READ_ONLY)
if(vol.flags&VOLUME_WRITE_PROTECTED) if(#if defined(FILES) && FILES>0
((functionNo > INDEX_WRITE_FILE_START) && (functionNo < FL_LAST_FAT_FUNCTION)) ||#endif /* FILES > 0 */
#ifdef FORMAT_VOLUME
(functionNo==BD_FORMAT_VOLUME) || (functionNo==BD_FORMAT_PHYSICAL_DRIVE) || (functionNo==BD_FORMAT_LOGICAL_DRIVE) ||#endif /* FORMAT_VOLUME */
#ifdef WRITE_EXB_IMAGE
(functionNo==FL_PLACE_EXB) ||#endif /* WRITE_EXB_IMAGE */
(functionNo==FL_DEFRAGMENT_VOLUME) ||#ifdef ABS_READ_WRITE
(functionNo==FL_ABS_WRITE) || (functionNo==FL_ABS_DELETE) ||#endif /* ABS_READ_WRITE */
#ifdef FL_LOW_LEVEL
(functionNo==FL_PHYSICAL_WRITE) || (functionNo==FL_PHYSICAL_ERASE) ||#endif /* FL_LOW_LEVEL */
#ifdef VERIFY_VOLUME
(functionNo==FL_VERIFY_VOLUME) ||#endif /* VERIFY_VOLUME */
0) { status = flWriteProtect; goto flCallExit; }
#endif /* WRITE_PROTECTION && !FL_READ_ONLY */
/***********************************************//* Binary partition operations *//* Low level mount and direct call the routine *//***********************************************/
#ifdef BDK_ACCESS
if ((functionNo > INDEX_BINARY_START) && (functionNo < INDEX_BINARY_END ) ) {#ifdef WRITE_EXB_IMAGE
if ((functionNo != FL_BINARY_PROTECTION_INSERT_KEY) && (functionNo != FL_BINARY_PROTECTION_REMOVE_KEY)) vol.moduleNo = INVALID_MODULE_NO; /* Stop place EXB operation */#endif
/* Mount flash and call binary module to proccess request */
if (!(pVol->flags & VOLUME_LOW_LVL_MOUNTED)) status = mountLowLevel(&vol); if (status == flOK) status = bdkCall(functionNo,ioreq,pVol->flash); goto flCallExit; }#endif /* BDK_ACCESS */
/***********************************//* None binary routine *//* Nag about mounting if necessary *//***********************************/
switch (functionNo) {#if FILES > 0
case FL_LAST_FAT_FUNCTION: status = flBadFunction; goto flCallExit;#endif
/* Pre mount routine - Make sure the volume is low level disMounted */
case FL_ABS_MOUNT: case FL_MOUNT_VOLUME:#ifndef FL_READ_ONLY
#ifdef FORMAT_VOLUME
case BD_FORMAT_VOLUME: case BD_FORMAT_LOGICAL_DRIVE:#endif /* FORMAT_VOLUME */
#endif /* FL_READ_ONLY */
#ifdef FL_LOW_LEVEL
if (vol.flags & VOLUME_LOW_LVL_MOUNTED) dismountLowLevel(&vol); /* mutual exclusive mounting */#endif /* FL_LOW_LEVEL */
break;
/* Physical operation must have the device low level (MTD) mounted */
/* Do not need any special operation */
case FL_UPDATE_SOCKET_PARAMS: case FL_COUNT_VOLUMES:#if (defined(FORMAT_VOLUME) && !defined(FL_READ_ONLY))
case FL_WRITE_BBT:#endif
#ifdef HW_PROTECTION
case FL_PROTECTION_GET_TYPE: case FL_PROTECTION_REMOVE_KEY: case FL_PROTECTION_INSERT_KEY:#ifndef FL_READ_ONLY
case FL_PROTECTION_SET_LOCK: case FL_PROTECTION_CHANGE_KEY: case FL_PROTECTION_CHANGE_TYPE:#endif /* FL_READ_ONLY */
#endif /* HW_PROTECTION */
#ifdef QUICK_MOUNT_FEATURE
case FL_CLEAR_QUICK_MOUNT_INFO:#endif /* QUICK_MOUNT_FEATURE */
break;
/* MTD must be mounted first */
#ifdef FL_LOW_LEVEL
/* Some physical operation must not be done while abs mounted */ case FL_GET_PHYSICAL_INFO: case FL_PHYSICAL_READ:#ifndef FL_READ_ONLY
case FL_PHYSICAL_WRITE: case FL_PHYSICAL_ERASE:#endif /* FL_READ_ONLY */
#ifndef BDK_ACCESS
#ifdef MULTI_DOC
#ifdef ENVIRONMENT_VARS
if (flUseMultiDoc == FL_ON)#endif
{ volNo = handleConversionTable[0][0]; if ((volNo != INVALID_VOLUME_NUMBER) && (pVol[volNo].flags & VOLUME_ABS_MOUNTED))#else
{ if(vol.flags & VOLUME_ABS_MOUNTED)#endif
{ status = flGeneralFailure; /* mutual exclusive mounting */ goto flCallExit; } }#endif /* BDK_ACCESS */
#ifndef NO_INQUIRE_CAPABILITIES
case FL_INQUIRE_CAPABILITIES:#endif /* NO_INQUIRE_CAPABILITIES */
case FL_DEEP_POWER_DOWN_MODE:#ifdef HW_OTP
case FL_OTP_SIZE: case FL_OTP_READ:#ifndef FL_READ_ONLY
case FL_OTP_WRITE:#endif /* FL_READ_ONLY */
case FL_UNIQUE_ID: case FL_CUSTOMER_ID:#endif /* HW_OTP */
#ifndef NO_IPL_CODE
case FL_READ_IPL:#ifndef FL_READ_ONLY
case FL_WRITE_IPL:#endif /* FL_READ_ONLY */
#endif /* NO_IPL_CODE */
#ifndef FL_READ_ONLY
#ifdef WRITE_EXB_IMAGE
case FL_PLACE_EXB:#endif /* WRITE_EXB_IMAGE */
#ifdef FORMAT_VOLUME
case BD_FORMAT_PHYSICAL_DRIVE:#endif /* FORMAT_VOLUME */
#endif /* FL_READ_ONLY */
if (!(vol.flags & VOLUME_LOW_LVL_MOUNTED)) { status = mountLowLevel(&vol); /* automatic low level mounting */ } else { status = flOK;#ifndef FIXED_MEDIA
status = flMediaCheck(vol.socket); if (status == flDiskChange) status = mountLowLevel(&vol); /* card was changed, remount */#endif /* FIXED_MEDIA */
} if (status != flOK) { dismountLowLevel(&vol); goto flCallExit; } break;#endif /* FL_LOW_LEVEL */
/* Check for abs mount */
default: if (vol.flags & VOLUME_ABS_MOUNTED) {#ifndef NT5PORT
FLStatus status = flOK;#else /*NT5PORT*/
FLStatus istatus = flOK;#endif /*NT5PORT*/
#ifndef FIXED_MEDIA
#ifndef NT5PORT
status = flMediaCheck(vol.socket);#else /*NT5PORT*/
istatus = flMediaCheck(vol.socket);#endif /*NT5PORT*/
#endif /*FIXED_MEDIA*/
#ifndef NT5PORT
if (status != flOK)#else /*NT5PORT*/
if (istatus != flOK)#endif /*NT5PORT*/
dismountVolume(&vol); } if (!(vol.flags & VOLUME_ABS_MOUNTED)#if defined(FILES) && FILES>0
&& (functionNo > FL_LAST_FAT_FUNCTION)#endif
) { status = flNotMounted; goto flCallExit; }
/* We know that the tl is abs mounted (except for files )
now check for high level mounted */
if (!( vol.flags & VOLUME_MOUNTED ) && ( functionNo != FL_DISMOUNT_VOLUME ) && ( functionNo != FL_CHECK_VOLUME ) &&#ifndef FL_READ_ONLY
( functionNo != FL_DEFRAGMENT_VOLUME ) &&#endif /* FL_READ_ONLY */
#ifdef ABS_READ_WRITE
( functionNo != FL_ABS_READ ) && ( functionNo != FL_ABS_ADDRESS ) &&#ifndef FL_READ_ONLY
( functionNo != FL_ABS_WRITE ) && ( functionNo != FL_ABS_DELETE ) &&#endif /* FL_READ_ONLY */
#endif /* ABS_READ_WRITE */
#if (defined(WRITE_PROTECTION) && !defined(FL_READ_ONLY))
( functionNo != FL_WRITE_PROTECTION ) &&#endif /* WRITE_PROTECTION */
#ifdef VERIFY_VOLUME
( functionNo != FL_VERIFY_VOLUME ) &&#endif /* VERIFY_VOLUME */
( functionNo != FL_READ_BBT ) && ( functionNo != FL_SECTORS_IN_VOLUME ) && ( functionNo != FL_VOLUME_INFO )) { status = flNotMounted; goto flCallExit; } }
/*****************************************************//*** ***//*** The Volume record is already initialized. ***//*** Exceute the proper function. ***//*** ***//*****************************************************/
switch (functionNo) {
#if defined(FILES) && FILES > 0
#ifndef FL_READ_ONLY
case FL_FLUSH_BUFFER: status = flushBuffer(&vol); break;#endif /* FL_READ_ONLY */
case FL_OPEN_FILE: status = openFile(&vol,ioreq); break;
case FL_CLOSE_FILE: status = closeFile(file); break;#ifndef FL_READ_ONLY
#ifdef SPLIT_JOIN_FILE
case FL_JOIN_FILE: status = joinFile(file, ioreq); break;
case FL_SPLIT_FILE: status = splitFile(file, ioreq); break;#endif
#endif /* FL_READ_ONLY */
case FL_READ_FILE: status = readFile(file,ioreq); break;#ifndef FL_READ_ONLY
case FL_WRITE_FILE: status = writeFile(file,ioreq); break;#endif
case FL_SEEK_FILE: status = seekFile(file,ioreq); break;
case FL_FIND_FILE: status = findFile(&vol,file,ioreq); break;
case FL_FIND_FIRST_FILE: status = findFirstFile(&vol,ioreq); break;
case FL_FIND_NEXT_FILE: status = findNextFile(file,ioreq); break;
case FL_GET_DISK_INFO: status = getDiskInfo(&vol,ioreq); break;#ifndef FL_READ_ONLY
case FL_DELETE_FILE: status = deleteFile(&vol,ioreq,FALSE); break;
#ifdef RENAME_FILE
case FL_RENAME_FILE: status = renameFile(&vol,ioreq); break;#endif
#ifdef SUB_DIRECTORY
case FL_MAKE_DIR: status = makeDir(&vol,ioreq); break;
case FL_REMOVE_DIR: status = deleteFile(&vol,ioreq,TRUE); break;#endif
#endif /* FL_READ_ONLY */
#endif /* FILES > 0 */
case FL_MOUNT_VOLUME: status = mountVolume(&vol,&(ioreq->irFlags)); break;
case FL_DISMOUNT_VOLUME: status = dismountVolume(&vol); break;
case FL_CHECK_VOLUME: status = flOK; /* If we got this far */ break;
case FL_UPDATE_SOCKET_PARAMS: status = updateSocketParameters(flSocketOf(ioreq->irHandle), ioreq->irData); break;
#ifndef NO_READ_BBT_CODE
case FL_READ_BBT: if(vol.tl.readBBT != NULL) { status = vol.tl.readBBT(vol.tl.rec,(CardAddress FAR1 *)ioreq->irData, &(ioreq->irLength),&(ioreq->irFlags)); } else { status = flFeatureNotSupported; } break;#endif /* NO_READ_BBT_CODE */
#ifndef FL_READ_ONLY
#ifdef DEFRAGMENT_VOLUME
case FL_DEFRAGMENT_VOLUME: status = defragmentVolume(&vol,ioreq); break;#endif /* DEFRAGMENT_VOLUME */
#if defined (FORMAT_VOLUME) && !defined(FL_READ_ONLY)
case BD_FORMAT_VOLUME: status = bdFormatVolume(&vol,ioreq); break;
case BD_FORMAT_PHYSICAL_DRIVE: status = bdFormatPhysicalDrive(&vol,ioreq); break;
case BD_FORMAT_LOGICAL_DRIVE: status = bdFormatLogicalDrive(&vol,ioreq); break;
#endif /* FORMAT_VOLUME AND NOT FL_READ_ONLY */
#ifdef WRITE_EXB_IMAGE
case FL_PLACE_EXB: status = placeExbByBuffer(&vol,(byte FAR1*)ioreq->irData, ioreq->irLength,(word)ioreq->irWindowBase ,(word)ioreq->irFlags); break;
#endif /* WRITE_EXB_IMAGE */
#endif /* FL_READ_ONLY */
case FL_SECTORS_IN_VOLUME: status = sectorsInVolume(&vol,ioreq); break;
case FL_ABS_MOUNT: status = absMountVolume(&vol); break;
#ifdef ABS_READ_WRITE
case FL_ABS_READ: status = absRead(&vol,ioreq); break;
#ifndef NO_PHYSICAL_IO
case FL_ABS_ADDRESS: status = absAddress(&vol,ioreq); break;#endif /* NO_PHYSICAL_IO */
#ifndef FL_READ_ONLY
case FL_ABS_DELETE: status = absDelete(&vol,ioreq); break;
case FL_ABS_WRITE: status = absWrite(&vol,ioreq); break;
#endif /* FL_READ_ONLY */
case FL_GET_BPB: status = getBPB(&vol,ioreq); break;
#ifndef FL_READ_ONLY
#if (defined(WRITE_PROTECTION) && !defined(FL_READ_ONLY))
case FL_WRITE_PROTECTION : status = writeProtect(&vol,ioreq); break;
#endif /* WRITE_PROTECTION */
#endif /* FL_READ_ONLY */
#endif /* ABS_READ_WRITE */
#ifdef VERIFY_VOLUME
case FL_VERIFY_VOLUME : if ((vol.tl.checkVolume != NULL) && (ioreq->irData == NULL) && (ioreq->irLength == 0 ) ) { status = vol.tl.checkVolume(vol.tl.rec); } else { status = flFeatureNotSupported; } break;#endif /* VERIFY_VOLUME */
#ifdef FL_LOW_LEVEL
case FL_GET_PHYSICAL_INFO: status = getPhysicalInfo(&vol, ioreq); break;
#ifndef NO_PHYSICAL_IO
case FL_PHYSICAL_READ: status = physicalRead(&vol, ioreq); break;
#ifndef FL_READ_ONLY
case FL_PHYSICAL_WRITE: status = physicalWrite(&vol, ioreq); break;
case FL_PHYSICAL_ERASE: status = physicalErase(&vol, ioreq); break;#endif /* FL_READ_ONLY */
#endif /* NO_PHYSICAL_IO */
/* direct calls to the MTD */#ifdef HW_OTP
case FL_OTP_SIZE: if (vol.flash->otpSize != NULL) { word tmp = (word)ioreq->irFlags; status = vol.flash->otpSize(vol.flash, (dword FAR2 *)(&ioreq->irCount ), (dword FAR2 *)(&ioreq->irLength), &tmp); ioreq->irFlags = (unsigned)tmp; } else { status = flFeatureNotSupported; } break;
case FL_OTP_READ: if (vol.flash->readOTP != NULL) { status = vol.flash->readOTP(vol.flash, (word)ioreq->irCount, ioreq->irData, (word)ioreq->irLength); } else { status = flFeatureNotSupported; } break;
#ifndef FL_READ_ONLY
case FL_OTP_WRITE: if (vol.flash->writeOTP != NULL) { status = vol.flash->writeOTP(vol.flash,ioreq->irData, (word)ioreq->irLength); } else { status = flFeatureNotSupported; } break;
#endif /* FL_READ_ONLY */
case FL_UNIQUE_ID: if (vol.flash->getUniqueId !=NULL) { status = vol.flash->getUniqueId(vol.flash, ioreq->irData); } else { status = flFeatureNotSupported; } break;
case FL_CUSTOMER_ID: if (vol.flash->getUniqueId !=NULL) { byte buf[UNIQUE_ID_LEN]; status = vol.flash->getUniqueId (vol.flash, buf); tffscpy (ioreq->irData,buf,CUSTOMER_ID_LEN); } else { status = flFeatureNotSupported; } break;#endif /* HW_OTP */
#ifndef NO_IPL_CODE
#ifndef FL_READ_ONLY
case FL_WRITE_IPL: status = writeIPL(vol.flash,(byte FAR1*)ioreq->irData,ioreq->irLength,ioreq->irFlags); break;#endif /* FL_READ_ONLY */
case FL_READ_IPL: status = readIPL(vol.flash,(byte FAR1*)ioreq->irData,ioreq->irLength); break;#endif /* NO_IPL_CODE */
case FL_DEEP_POWER_DOWN_MODE: if (vol.flash->enterDeepPowerDownMode !=NULL) { vol.flash->enterDeepPowerDownMode(vol.flash,(word)ioreq->irFlags); status = flOK; } else { status = flFeatureNotSupported; } break;
#ifndef NO_INQUIRE_CAPABILITIES
case FL_INQUIRE_CAPABILITIES: inquireCapabilities(vol.flash,(FLCapability FAR2 *)&(ioreq->irLength)); break;#endif /* NO_INQUIRE_CAPABILITIES */
#endif /* FL_LOW_LEVEL */
case FL_VOLUME_INFO: status = volumeInfo(&vol, ioreq); break;
/* Pre mount routines */#if (defined(FORMAT_VOLUME) && !defined(FL_READ_ONLY))
case FL_WRITE_BBT:#ifndef NT5PORT
checkStatus(dismountPhysicalDrive(socket));#else /*NT5PORT*/
status = dismountPhysicalDrive(socket); if (status != flOK) goto flCallExit;#endif /*NT5PORT*/
#endif
case FL_COUNT_VOLUMES:#ifdef QUICK_MOUNT_FEATURE
case FL_CLEAR_QUICK_MOUNT_INFO:#endif /* QUICK_MOUNT_FEATURE */
#ifdef HW_PROTECTION
case FL_PROTECTION_GET_TYPE: case FL_PROTECTION_REMOVE_KEY: case FL_PROTECTION_INSERT_KEY:#ifndef FL_READ_ONLY
case FL_PROTECTION_SET_LOCK: case FL_PROTECTION_CHANGE_KEY: case FL_PROTECTION_CHANGE_TYPE:#endif /* FL_READ_ONLY */
#endif /* HW_PROTECTION */
status = flPreMount(functionNo , ioreq , vol.flash); break; default: status = flBadFunction; }
#if ((defined(FILES)) && (FILES > 0) && (!defined(FL_READ_ONLY)))
if (vol.volBuffer.checkPoint) { FLStatus st = flushBuffer(&vol); if (status == flOK) status = st; }#endif
/*********************************************//* Exit nicely - Release mutex of the socket *//*********************************************/
flCallExit: if(status==flOK) status = setBusy(&vol,FL_OFF,curPartitionForEnvVars); else setBusy(&vol,FL_OFF,curPartitionForEnvVars); /* We're leaving */
return status;}
#if POLLING_INTERVAL != 0
/*----------------------------------------------------------------------*//* s o c k e t I n t e r v a l R o u t i n e *//* *//* Routine called by the interval timer to perform periodic socket *//* actions and handle the watch-dog timer. *//* *//* Parameters: *//* None *//* *//*----------------------------------------------------------------------*/
/* Routine called at time intervals to poll sockets */static void socketIntervalRoutine(void){ unsigned volNo; Volume vol = vols;
flMsecCounter += POLLING_INTERVAL;
for (volNo = 0; volNo < noOfSockets; volNo++, pVol++) if (flTakeMutex(&flMutex[volNo])) {#ifdef FL_BACKGROUND
if (vol.flags & VOLUME_ABS_MOUNTED) /* Allow background operation to proceed */ vol.tl.tlSetBusy(vol.tl.rec,FL_OFF);#endif
flIntervalRoutine(vol.socket); flFreeMutex(&flMutex[volNo]); }}
#endif /* POLLING_INTERVAL != 0 */
/*----------------------------------------------------------------------*//* f l I n i t *//* *//* Initializes the FLite system, sockets and timers. *//* *//* Calling this function is optional. If it is not called, *//* initialization will be done automatically on the first FLite call. *//* This function is provided for those applications who want to *//* explicitly initialize the system and get an initialization status. *//* *//* Calling flInit after initialization was done has no effect. *//* *//* Parameters: *//* None *//* *//* Returns: *//* FLStatus : 0 on success, otherwise failed *//*----------------------------------------------------------------------*/
FLStatus flInit(void){ if (!initDone) { FLStatus status; unsigned volNo; Volume vol = vols; IOreq req;#ifdef LOG_FILE
FILE *out;
out=FL_FOPEN("EDCerr.txt","w"); FL_FPRINTF(out,"EDC error LOG\n"); FL_FCLOSE(out);#endif /* LOG_FILE */
flInitGlobalVars();
#ifdef ENVIRONMENT_VARS
/* Call users initialization routine for :
* flUse8Bit,flUseNFTLCache,flUseisRAM */ flSetEnvVar();
if(flUse8Bit==1) { tffscpy = flmemcpy; tffscmp = flmemcmp; tffsset = flmemset; } else { tffscpy = flcpy; tffsset = flset; tffscmp = flcmp; }
#endif /* ENVIRONMENT_VARS */
/*
* 1) Mark all the volumes as not used and free to be allocated. * 2) Clear passowrd in order to make it invald. */ tffsset(vols,0,sizeof(vols));
for (volNo = 0,pVol = vols; volNo < VOLUMES; volNo++,pVol++) { /* The actual number of sockets is not yet known and will be retreaved by
* flRegisterComponents routine by the socket componenets. For now supply * each of the possible sockets with its buffer and socket number. */ if ( volNo < SOCKETS) { vol.socket = flSocketOf(volNo); vol.flash = flFlashOf(volNo); tffsset(vol.socket,0,sizeof(FLSocket)); tffsset(vol.flash,0,sizeof(FLFlash)); vol.socket->volNo = volNo; #ifdef WRITE_EXB_IMAGE
vol.moduleNo = INVALID_MODULE_NO; /* Ready for exb write operation */#endif
} else { vol.flash = NULL; } vol.volExecInProgress = NULL; }
#if FILES > 0
initFS();#endif
flSysfunInit();
#ifdef FL_BACKGROUND
flCreateBackground();#endif
/* Initialize variales */ for (noOfTLs = 0 ;noOfTLs < TLS;noOfTLs++) { tlTable[noOfTLs].mountRoutine = NULL; tlTable[noOfTLs].preMountRoutine = NULL; tlTable[noOfTLs].formatRoutine = NULL; } initDone = TRUE; noOfTLs = 0; noOfDrives = 0; noOfSockets = 0; noOfMTDs = 0;
checkStatus(flRegisterComponents());
#ifdef COMPRESSION
checkStatus(flRegisterZIP());#endif
#ifdef MULTI_DOC
#ifdef ENVIRONMENT_VARS
if(flUseMultiDoc==FL_ON) { checkStatus(flRegisterMTL()); }#else
checkStatus(flRegisterMTL());#endif /* ENVIRONMENT_VARS */
#endif /* MULT_DOC */
#ifdef BDK_ACCESS
bdkInit();#endif
checkStatus(flInitSockets());
#if POLLING_INTERVAL > 0
checkStatus(flInstallTimer(socketIntervalRoutine,POLLING_INTERVAL));#endif
/*
* Now that the number of actual sockets is known, create a mutex for * each of the systems sockets. Multi-doc uses only 1 mutex. */
#ifdef MULTI_DOC
if ((noOfSockets)#ifdef ENVIRONMENT_VARS
&&(flUseMultiDoc == FL_ON)#endif /* ENVIRONMENT_VARS */
) { /* All sockets use the same mutex */
if (flCreateMutex(&flMutex[0]) != flOK) return flGeneralFailure;
for (volNo = 0; volNo < noOfSockets ; volNo++) { vols[volNo].volExecInProgress = &flMutex[0]; } } else#endif /* MULTI_DOC */
{ /* Each socket uses a diffren mutex */
for (volNo = 0; volNo < noOfSockets ; volNo++) { if (flCreateMutex(&flMutex[volNo]) != flOK) return flGeneralFailure; vols[volNo].volExecInProgress = &flMutex[volNo]; } }
/* Count the number of volumes on all the systems sockets and
* initialize conversion table. The table is used to convert a socket * and a partition numbers to the correct volume index in the vols record. * Partition 0 of each of the sockets will recieve the volume record * indexed with the socket number in the vols array. The rest of the * volumes will be serialy allocated. New volume records can be allocated * By the format routine. The format and the write BBT routines clear all * volume records taken by the sockets except for the first. * * The partition and socket are passed to the TL module using 2 dedicated * fields in the TL record. Both those values are also initiaized. * All volumes on a specific socket will share the same mutex. */
tffsset(handleConversionTable,INVALID_VOLUME_NUMBER, /* Clear table */ sizeof(handleConversionTable));
for (pVol = vols , noOfDrives = (unsigned)noOfSockets , req.irHandle = 0; req.irHandle < noOfSockets; req.irHandle++, pVol++) { /* Initialize partition 0 */
handleConversionTable[req.irHandle][0] = (byte)req.irHandle; vol.tl.socketNo = (byte)req.irHandle; vol.tl.partitionNo = 0; vol.flags = VOLUME_ACCUPIED;
/* The rest of the partitions are initialzed only if multi-doc
* is not active since Multi-doc supports only the first volume * of each socket. */
status = flPreMount(FL_COUNT_VOLUMES , &req , vol.flash); if (status == flOK) { vol.volExecInProgress = &flMutex[req.irHandle]; for(volNo = 1;(volNo < req.irFlags) && (noOfDrives < VOLUMES); volNo++,noOfDrives++) { handleConversionTable[req.irHandle][volNo] = (byte)noOfDrives; vols[noOfDrives].socket = vol.socket; vols[noOfDrives].flash = vol.flash; vols[noOfDrives].tl.socketNo = (byte)req.irHandle; vols[noOfDrives].tl.partitionNo = (byte)volNo; vols[noOfDrives].volExecInProgress = vol.volExecInProgress; vol.flags = VOLUME_ACCUPIED; } } } } return flOK;}
#ifdef EXIT
/*----------------------------------------------------------------------*//* f l E x i t *//* *//* If the application ever exits, flExit should be called before exit. *//* flExit flushes all buffers, closes all open files, powers down the *//* sockets and removes the interval timer. *//* *//* Parameters: *//* None *//* *//* Returns: *//* Nothing *//*----------------------------------------------------------------------*/
void NAMING_CONVENTION flExit(void){ unsigned volNo; Volume vol = vols; FLBoolean mutexTaken = FALSE;
if(flInit==FALSE) return;
/* Dismount the TL and MTD */
for (volNo = 0; (volNo < VOLUMES); volNo++,pVol++) { if ((vol.flags & VOLUME_ACCUPIED) && (setBusy(&vol,FL_ON,vol.tl.partitionNo) == flOK)) { dismountVolume(&vol);
#ifdef FL_LOW_LEVEL
dismountLowLevel(&vol);#endif
setBusy(&vol,FL_OFF,vol.tl.partitionNo); } }
/* Dismount SOCKET */
pVol = vols; for (volNo = 0; volNo < noOfSockets ; volNo++,pVol++) {#ifdef MULTI_DOC
#ifdef ENVIRONMENT_VARS
if (flUseMultiDoc == FL_ON) /* multi-doc not active */#endif /* ENVIRONMENT_VARS */
if (volNo == 0)#endif /* MULTI_DOC */
mutexTaken = (setBusy(&vol,FL_ON,vol.tl.partitionNo) == flOK) ? TRUE:FALSE;
if (mutexTaken == TRUE) { flFreeMutex(execInProgress); /* free the mutex that was taken in setBusy(FL_ON) */ /* delete mutex protecting FLite volume access */ flDeleteMutex(execInProgress); mutexTaken = FALSE; } flExitSocket(vol.socket); }
#if POLLING_INTERVAL != 0
flRemoveTimer();#endif
#ifdef ALLOCTST
out_data_sz();#endif
initDone = FALSE; initGlobalVarsDone = FALSE; pVol = NULL;}
#ifdef __BORLANDC__
#ifdef EXIT
#pragma exit flExit
#endif /* EXIT */
#include <dos.h>
static int cdecl flBreakExit(void){ flExit();
return 0;}
static void setCBreak(void){ ctrlbrk(flBreakExit);}
#pragma startup setCBreak
#endif
#endif
|
