/* * $Log: V:/Flite/archives/TrueFFS5/Src/BLOCKDEV.H_V $ * * Rev 1.20 Apr 15 2002 07:34:06 oris * Bug fix - FL_IPL_MODE_XSCALE define was set to 3 instead of 4 and therefore caused FL_IPL_DOWNLOAD and FL_IPL_MODE_SA to be set as well. * * Rev 1.19 Feb 19 2002 20:58:20 oris * Removed warnings. * Moved FLFunctionNo enumerator to dedicated file flfuncno.h * Added include directive for cleaner customer usage. * * Rev 1.18 Jan 29 2002 20:07:16 oris * Moved flParsePath declaration to the end of the file. * Changed LOW_LEVEL compilation flag with FL_LOW_LEVEL to prevent definition clashes. * Added documentation of irFlags in flMountVolume (returns no of hidden sectors of the media). * flSetEnvVolume, flSetEnvSocket , flSetEnvAll , flSetDocBusRoutine , flGetDocBusRoutine, flBuildGeometry , bdCall and flExit * Added FL_IPL_MODE_XSCALE definition and change FL_IPL_XXX values. * * Rev 1.17 Jan 28 2002 21:23:46 oris * Changed FL_NFTL_CACHE_ENABLED to FL_TL_CACHE_ENABLED. * Changed flSetDocBusRoutine interface and added flGetDocBusRoutine. * * Rev 1.16 Jan 23 2002 23:30:54 oris * Added documentation of irData and irLength to flCheckVolume. * * Rev 1.15 Jan 20 2002 20:27:40 oris * Added TL_NORMAL_FORMAT flag was added to bdFormatPhisycalDrive instead of 0 (in the comments). * Removed TL_QUICK_MOUNT_FORMAT flag definition. * * Rev 1.14 Jan 17 2002 22:57:18 oris * Added flClearQuickMountInfo() routine - FL_CLEAR_QUICK_MOUNT_INFO * Added flVerifyVolume() routine - FL_VERIFY_VOLUME * Added DiskOnChip Millennium Plus 16MB type * Changed the order of FLEnvVars enumerator. * Added FLEnvVars values for : * FL_SECTORS_VERIFIED_PER_FOLDING * FL_SUSPEND_MODE * FL_VERIFY_WRITE_OTHER * FL_MTD_BUS_ACCESS_TYPE * FL_VERIFY_WRITE_BDTL * FL_VERIFY_WRITE_BINARY * flSetEnv() routine was changed into 3 different routines: flSetEnvVolume / flSetEnvSocket / flSetEnvAll * Removed TL_SINGLE_FLOOR_FORMATTING flag definition from format routine. * Added flSetDocBusRoutines prototype and required definitions. * * Rev 1.13 Nov 21 2001 11:39:36 oris * Changed FL_VERIFY_WRITE_MODE to FL_MTD_VERIFY_WRITE. * * Rev 1.12 Nov 08 2001 10:44:18 oris * Added FL_VERIFY_WRITE_MODE enumerator type for the flSetEnv routine . * Moved environment variable states definitions to flbase.h. * * Rev 1.11 Sep 15 2001 23:44:30 oris * Placed flDeepPowerDownMone under LOW_LEVEL compilation flag. * * Rev 1.10 May 17 2001 16:50:32 oris * Removed warnings. * * Rev 1.9 May 16 2001 21:16:22 oris * Added the Binary state (0,1) of the environment variables to meaningful definitions. * Removed LAST function enumerator. * Improved documentation. * * Rev 1.8 May 06 2001 22:41:14 oris * Added SUPPORT_WRITE_IPL_ROUTIN capability. * * Rev 1.7 Apr 30 2001 17:57:50 oris * Added required defintions to support the flMarkDeleteOnFlash environment variable. * * Rev 1.6 Apr 24 2001 17:05:52 oris * Changed bdcall function numbers in order to allow future grouth. * * Rev 1.5 Apr 01 2001 07:49:04 oris * Added FL_READ_IPL . * flChangeEnvironmentVariable prototype removed. * Moved s/w protection definitions from iovtl.h to blockdev.h * Changed s\w and h\w to s/w and h/w. * Added flBuildGeometry prototype * Moved bdcall prototype to the end of the file with the rest of the prototypes. * * Rev 1.4 Feb 18 2001 14:15:38 oris * Changed function enums order. * * Rev 1.3 Feb 14 2001 01:44:16 oris * Changed capabilities from defined flags to an enumerator * Improoved documentation of readBBT, writeBBT InquireCapabilities, countVolumes * Added environment variables defintions * * Rev 1.2 Feb 13 2001 02:08:42 oris * Moved LOCKED_OTP and DEEP_POWER_DOWN to flflash.h * Moved TL_FORMAT_FAT and TL_FORMAT_COMPRESSION to flformat.h * Added extern declaration for flSetEnv routine. * * Rev 1.1 Feb 12 2001 11:54:46 oris * Added baseAddress in flGetPhysicalInfo as irLength. * Added boot sectors in flMountVolumes as irFlags. * Change order of routines definition. * * Rev 1.0 Feb 04 2001 18:05: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 = info@m-sys.com */ /***********************************************************************************/ #ifndef BLOCKDEV_H #define BLOCKDEV_H #include "flreq.h" #include "flfuncno.h" #include "docsys.h" #ifdef FORMAT_VOLUME #include "dosformt.h" #endif /* FORMAT_VOLUME */ #ifdef WRITE_EXB_IMAGE #include "doc2exb.h" #else #ifdef BDK_ACCESS #include "docbdk.h" #endif /* BDK_ACCESS */ #endif /* WRITE_EXB_IMAGE */ /*----------------------------------------------------------------------*/ /* b d C a l l */ /* */ /* Common entry-point to all TrueFFS functions. Macros are to call */ /* individual function, which are separately described below. */ /* */ /* Parameters: */ /* function : Block device driver function code (listed below) */ /* ioreq : IOreq structure */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #if FILES > 0 #ifndef FL_READ_ONLY /*----------------------------------------------------------------------*/ /* f l F l u s h B u f f e r */ /* */ /* If there is relevant data in the RAM buffer then writes it on */ /* the flash memory. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flFlushBuffer(ioreq) bdCall(FL_FLUSH_BUFFER,ioreq) #endif /* READ_ONLY */ /*----------------------------------------------------------------------*/ /* f l O p e n F i l e */ /* */ /* Opens an existing file or creates a new file. Creates a file handle */ /* for further file processing. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irFlags : Access and action options, defined below */ /* irPath : path of file to open */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irHandle : New file handle for open file */ /* */ /*----------------------------------------------------------------------*/ /** Values of irFlags for flOpenFile: */ #define ACCESS_MODE_MASK 3 /* Mask for access mode bits */ /* Individual flags */ #define ACCESS_READ_WRITE 1 /* Allow read and write */ #define ACCESS_CREATE 2 /* Create new file */ /* Access mode combinations */ #define OPEN_FOR_READ 0 /* open existing file for read-only */ #define OPEN_FOR_UPDATE 1 /* open existing file for read/write access */ #define OPEN_FOR_WRITE 3 /* create a new file, even if it exists */ #define flOpenFile(ioreq) bdCall(FL_OPEN_FILE,ioreq) /*----------------------------------------------------------------------*/ /* f l C l o s e F i l e */ /* */ /* Closes an open file, records file size and dates in directory and */ /* releases file handle. */ /* */ /* Parameters: */ /* irHandle : Handle of file to close. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flCloseFile(ioreq) bdCall(FL_CLOSE_FILE,ioreq) #ifndef FL_READ_ONLY #ifdef SPLIT_JOIN_FILE /*------------------------------------------------------------------------*/ /* f l S p l i t F i l e */ /* */ /* Splits the file into two files. The original file contains the first */ /* part, and a new file (which is created for that purpose) contains */ /* the second part. If the current position is on a cluster */ /* boundary, the file will be split at the current position. Otherwise, */ /* the cluster of the current position is duplicated, one copy is the */ /* first cluster of the new file, and the other is the last cluster of the*/ /* original file, which now ends at the current position. */ /* */ /* Parameters: */ /* file : file to split. */ /* irPath : Path name of the new file. */ /* */ /* Returns: */ /* irHandle : handle of the new file. */ /* FLStatus : 0 on success, otherwise failed. */ /* */ /*------------------------------------------------------------------------*/ #define flSplitFile(ioreq) bdCall(FL_SPLIT_FILE,ioreq) /*------------------------------------------------------------------------*/ /* f l J o i n F i l e */ /* */ /* joins two files. If the end of the first file is on a cluster */ /* boundary, the files will be joined there. Otherwise, the data in */ /* the second file from the beginning until the offset that is equal to */ /* the offset in cluster of the end of the first file will be lost. The */ /* rest of the second file will be joined to the first file at the end of */ /* the first file. On exit, the first file is the expanded file and the */ /* second file is deleted. */ /* Note: The second file will be open by this function, it is advised to */ /* close it before calling this function in order to avoid */ /* inconsistencies. */ /* */ /* Parameters: */ /* file : file to join to. */ /* irPath : Path name of the file to be joined. */ /* */ /* Return: */ /* FLStatus : 0 on success, otherwise failed. */ /* */ /*------------------------------------------------------------------------*/ #define flJoinFile(ioreq) bdCall(FL_JOIN_FILE,ioreq) #endif /* SPLIT_JOIN_FILE */ #endif /* FL_READ_ONLY */ /*----------------------------------------------------------------------*/ /* f l R e a d F i l e */ /* */ /* Reads from the current position in the file to the user-buffer. */ /* Parameters: */ /* irHandle : Handle of file to read. */ /* irData : Address of user buffer */ /* irLength : Number of bytes to read. If the read extends */ /* beyond the end-of-file, the read is truncated */ /* at the end-of-file. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irLength : Actual number of bytes read */ /*----------------------------------------------------------------------*/ #define flReadFile(ioreq) bdCall(FL_READ_FILE,ioreq) #ifndef FL_READ_ONLY /*----------------------------------------------------------------------*/ /* f l W r i t e F i l e */ /* */ /* Writes from the current position in the file from the user-buffer. */ /* */ /* Parameters: */ /* irHandle : Handle of file to write. */ /* irData : Address of user buffer */ /* irLength : Number of bytes to write. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irLength : Actual number of bytes written */ /*----------------------------------------------------------------------*/ #define flWriteFile(ioreq) bdCall(FL_WRITE_FILE,ioreq) #endif /* FL_READ_ONLY */ /*----------------------------------------------------------------------*/ /* f l S e e k F i l e */ /* */ /* Sets the current position in the file, relative to file start, end or*/ /* current position. */ /* Note: This function will not move the file pointer beyond the */ /* beginning or end of file, so the actual file position may be */ /* different from the required. The actual position is indicated on */ /* return. */ /* */ /* Parameters: */ /* irHandle : File handle to close. */ /* irLength : Offset to set position. */ /* irFlags : Method code */ /* SEEK_START: absolute offset from start of file */ /* SEEK_CURR: signed offset from current position */ /* SEEK_END: signed offset from end of file */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irLength : Actual absolute offset from start of file */ /*----------------------------------------------------------------------*/ /* Values of irFlags for flSeekFile: */ #define SEEK_START 0 /* offset from start of file */ #define SEEK_CURR 1 /* offset from current position */ #define SEEK_END 2 /* offset from end of file */ #define flSeekFile(ioreq) bdCall(FL_SEEK_FILE,ioreq) /*----------------------------------------------------------------------*/ /* f l F i n d F i l e */ /* */ /* Finds a file entry in a directory, optionally modifying the file */ /* time/date and/or attributes. */ /* Files may be found by handle no. provided they are open, or by name. */ /* Only the Hidden, System or Read-only attributes may be modified. */ /* Entries may be found for any existing file or directory other than */ /* the root. A DirectoryEntry structure describing the file is copied */ /* to a user buffer. */ /* */ /* The DirectoryEntry structure is defined in dosformt.h */ /* */ /* Parameters: */ /* irHandle : If by name: Drive number (socket+partitions) */ /* else : Handle of open file */ /* irPath : If by name: Specifies a file or directory path */ /* irFlags : Options flags */ /* FIND_BY_HANDLE: Find open file by handle. */ /* Default is access by path. */ /* SET_DATETIME: Update time/date from buffer */ /* SET_ATTRIBUTES: Update attributes from buffer */ /* irDirEntry : Address of user buffer to receive a */ /* DirectoryEntry structure */ /* */ /* Returns: */ /* irLength : Modified */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ /** Bit assignment of irFlags for flFindFile: */ #define SET_DATETIME 1 /* Change date/time */ #define SET_ATTRIBUTES 2 /* Change attributes */ #define FIND_BY_HANDLE 4 /* Find file by handle rather than by name */ #define flFindFile(ioreq) bdCall(FL_FIND_FILE,ioreq) /*----------------------------------------------------------------------*/ /* f l F i n d F i r s t F i l e */ /* */ /* Finds the first file entry in a directory. */ /* This function is used in combination with the flFindNextFile call, */ /* which returns the remaining file entries in a directory sequentially.*/ /* Entries are returned according to the unsorted directory order. */ /* flFindFirstFile creates a file handle, which is returned by it. Calls*/ /* to flFindNextFile will provide this file handle. When flFindNextFile */ /* returns 'noMoreEntries', the file handle is automatically closed. */ /* Alternatively the file handle can be closed by a 'closeFile' call */ /* before actually reaching the end of directory. */ /* A DirectoryEntry structure is copied to the user buffer describing */ /* each file found. This structure is defined in dosformt.h. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irPath : Specifies a directory path */ /* irData : Address of user buffer to receive a */ /* DirectoryEntry structure */ /* */ /* Returns: */ /* irHandle : File handle to use for subsequent operations */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flFindFirstFile(ioreq) bdCall(FL_FIND_FIRST_FILE,ioreq) /*----------------------------------------------------------------------*/ /* f l F i n d N e x t F i l e */ /* */ /* See the description of 'flFindFirstFile'. */ /* */ /* Parameters: */ /* irHandle : File handle returned by flFindFirstFile. */ /* irData : Address of user buffer to receive a */ /* DirectoryEntry structure */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flFindNextFile(ioreq) bdCall(FL_FIND_NEXT_FILE,ioreq) /*----------------------------------------------------------------------*/ /* f l G e t D i s k I n f o */ /* */ /* Returns general allocation information. */ /* */ /* The bytes/sector, sector/cluster, total cluster and free cluster */ /* information are returned into a DiskInfo structure. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irData : Address of DiskInfo structure */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ typedef struct { unsigned bytesPerSector; unsigned sectorsPerCluster; unsigned totalClusters; unsigned freeClusters; } DiskInfo; #define flGetDiskInfo(ioreq) bdCall(FL_GET_DISK_INFO,ioreq) #ifndef FL_READ_ONLY /*----------------------------------------------------------------------*/ /* f l D e l e t e F i l e */ /* */ /* Deletes a file. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irPath : path of file to delete */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flDeleteFile(ioreq) bdCall(FL_DELETE_FILE,ioreq) #ifdef RENAME_FILE /*----------------------------------------------------------------------*/ /* f l R e n a m e F i l e */ /* */ /* Renames a file to another name. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irPath : path of existing file */ /* irData : path of new name. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flRenameFile(ioreq) bdCall(FL_RENAME_FILE,ioreq) #endif /* RENAME_FILE */ #ifdef SUB_DIRECTORY /*----------------------------------------------------------------------*/ /* f l M a k e D i r */ /* */ /* Creates a new directory. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irPath : path of new directory. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flMakeDir(ioreq) bdCall(FL_MAKE_DIR,ioreq) /*----------------------------------------------------------------------*/ /* f l R e m o v e D i r */ /* */ /* Removes an empty directory. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irPath : path of directory to remove. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flRemoveDir(ioreq) bdCall(FL_REMOVE_DIR,ioreq) #endif /* SUB_DIRECTORY */ #endif /* FL_READ_ONLY */ #endif /* FILES > 0 */ /*----------------------------------------------------------------------*/ /* V o l u m e I n f o R e c o r d */ /* */ /* A structure that holds general information about the media. The */ /* information includes Physical Info (see flGetPhysicalInfo), Logical */ /* partition (number of sectors and CHS), boot area size, S/W versions */ /* Media life-time etc. */ /* A pointer to this structure is passed to the function flVolumeInfo */ /* where it receives the relevant data. */ /*----------------------------------------------------------------------*/ typedef struct { unsigned long logicalSectors; /* number of logical sectors */ unsigned long bootAreaSize; /* boot area size */ unsigned long baseAddress; /* physical base address */ #ifdef FL_LOW_LEVEL unsigned short flashType; /* JEDEC id of the flash */ unsigned long physicalSize; /* physical size of the media */ unsigned short physicalUnitSize; /* Erasable block size */ char DOCType; /* DiskOnChip type (MDoc/Doc2000) */ char lifeTime; /* Life time indicator for the media (1-10) */ /* 1 - the media is fresh, */ /* 10 - the media is close to its end of life */ #endif char driverVer[10]; /* driver version (NULL terminated string) */ char OSAKVer[10]; /* OSAK version that driver is based on (NULL terminated string) */ #ifdef ABS_READ_WRITE unsigned long cylinders; /* Media..... */ unsigned long heads; /* geometry...... */ unsigned long sectors; /* parameters. */ #endif } VolumeInfoRecord; /*----------------------------------------------------------------------*/ /* f l V o l u m e I n f o */ /* */ /* Get general information about the media. */ /* */ /* Parameters: */ /* irHandle : Socket number (0,1,..) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irData : Address of user buffer to read general */ /* information into. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flVolumeInfo(ioreq) bdCall(FL_VOLUME_INFO,ioreq) /*----------------------------------------------------------------------*/ /* f l C o u n t V o l u m e s */ /* */ /* Counts the number of volumes on the Flash device. */ /* */ /* This routine is applicable only for TL that can accomdate more then */ /* a single volume on a flash medium. other TL's will simply return 1 */ /* while not even tring to access the medium. */ /* */ /* Not all the volumes can neccesaryly be mounted. A drive formated */ /* with a read protection will be registered but can not be accessed. */ /* */ /* Parameters: */ /* irHandle : Socket number ( 0,1,2... ) */ /* : Partition number ( 0,1,2... ) */ /* irFlags : Returns the number of partitions */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flCountVolumes(ioreq) bdCall(FL_COUNT_VOLUMES,ioreq) /*----------------------------------------------------------------------*/ /* f l C l e a r Q u i c k M o u n t I n f o */ /* */ /* Clear all quick mount informtion. */ /* */ /* Must be called before calling mount volume routines. */ /* */ /* Parameters: */ /* irHandle : Socket number ( 0,1,2... ) */ /* : Partition number ( 0,1,2... ) */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flClearQuickMountInfo(ioreq) bdCall(FL_CLEAR_QUICK_MOUNT_INFO,ioreq) /*----------------------------------------------------------------------*/ /* f l M o u n t V o l u m e */ /* */ /* Mounts, verifies or dismounts the Flash medium. */ /* */ /* 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. */ /* */ /* The volume automatically becomes unmounted if it is removed or */ /* changed. */ /* */ /* Parameters: */ /* irHandle : Socket number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irFlags : Number of hidden sectors. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flMountVolume(ioreq) bdCall(FL_MOUNT_VOLUME,ioreq) /*----------------------------------------------------------------------*/ /* f l A b s M o u n t V o l u m e */ /* */ /* Mounts, verifies or dismounts the Flash medium. */ /* */ /* The volume automatically becomes unmounted if it is removed or */ /* changed. */ /* */ /* Parameters: */ /* irHandle : Socket number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flAbsMountVolume(ioreq) bdCall(FL_ABS_MOUNT,ioreq) /*----------------------------------------------------------------------*/ /* f l V e r i f y V o l u m e */ /* */ /* Verifies a mounted volume for partialy written sectors. */ /* */ /* Note: The volume must be mounted first. */ /* */ /* Parameters: */ /* irHandle : Socket number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irData : Must be set to NULL */ /* irLength : Must be set to 0 */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flVerifyVolume(ioreq) bdCall(FL_VERIFY_VOLUME,ioreq) /*----------------------------------------------------------------------*/ /* f l D i s m o u n t V o l u m e */ /* */ /* Dismounts the volume. */ /* This call is not normally necessary, unless it is known the volume */ /* will soon be removed. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flDismountVolume(ioreq) bdCall(FL_DISMOUNT_VOLUME,ioreq) /*----------------------------------------------------------------------*/ /* f l C h e c k V o l u m e */ /* */ /* Verifies that the current volume is mounted. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flCheckVolume(ioreq) bdCall(FL_CHECK_VOLUME,ioreq) /*----------------------------------------------------------------------*/ /* r e a d B B T */ /* */ /* Read Bad Blocks Table of device to user buffer */ /* */ /* Note: The user buffer is filled with the address of the bad units */ /* the buffer maximum size is 2% of the number of TL units of the */ /* specific device * 4 bytes. therfore a 8M device of 8KB erase */ /* zone will need a maximum size buffer of 1024 * 0.02 * 4 = 82B */ /* and a 192M with 16KB erase zones will need 960Bytes */ /* */ /* Note: the buffer is not initialized by the function */ /* */ /* Parameters: */ /* irData : User buffer. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irLength : returns the media size */ /* irFlags : returns the actual number of badBlocks */ /*----------------------------------------------------------------------*/ #define flReadBBT(ioreq) bdCall(FL_READ_BBT,ioreq) /*----------------------------------------------------------------------*/ /* f l S e c t o r s I n V o l u m e */ /* */ /* Returns number of virtual sectors in volume. */ /* */ /* In case the inserted volume is not mounted, returns current status. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irLength : number of virtual sectors in volume */ /*----------------------------------------------------------------------*/ #define flSectorsInVolume(ioreq) bdCall(FL_SECTORS_IN_VOLUME,ioreq) #ifndef FL_READ_ONLY #ifdef DEFRAGMENT_VOLUME /*----------------------------------------------------------------------*/ /* f l 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: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irLength : Minimum number of sectors to make available for */ /* writes. */ /* */ /* Returns: */ /* irLength : Actual number of sectors available for writes */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flDefragmentVolume(ioreq) bdCall(FL_DEFRAGMENT_VOLUME,ioreq) #endif /* DEFRAGMENT_VOLUME */ #ifdef FORMAT_VOLUME /*----------------------------------------------------------------------*/ /* f l F o r m a t V o l u m e */ /* */ /* Performs formatting of the DiskOnChip. */ /* All existing data is destroyed. */ /* */ /* Note : This routine does not support some of the new feature */ /* introduces in OSAK 5.0 and was left in order to support */ /* backwards compatibility with application build on OSAK 4.2 */ /* and down. */ /* */ /* Parameters: */ /* irHandle : Socket number (0, 1, ...) */ /* : Partition number must be 0 */ /* irFlags : TL_FORMAT : Translation layer formatting */ /* + FAT formating */ /* TL_FORMAT_IF_NEEDED: Translation layer formatting */ /* only if current format is */ /* invalid + FAT format */ /* : FAT_ONLY_FORMAT : FAT only formatting */ /* : TL_FORMAT_ONLY : Translation layer formatting */ /* without FAT format */ /* irData : Address of FormatParams structure to use */ /* (defined in format.h) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flFormatVolume(ioreq) bdCall(BD_FORMAT_VOLUME,ioreq) /** Values of irFlags for flLowLevelFormat: */ #define FAT_ONLY_FORMAT 0 #define TL_FORMAT 1 #define TL_FORMAT_IF_NEEDED 2 #define TL_FORMAT_ONLY 8 /*----------------------------------------------------------------------*/ /* f l F o r m a t P h i s i c a l D r i v e */ /* */ /* Performs formatting of the DiskOnChip. */ /* All existing data is destroyed. */ /* */ /* Note : This routine is the format routine for OSAK 5.0 and up. */ /* Note : This routine is the format routine for OSAK 5.0 */ /* */ /* Parameters: */ /* irHandle : Socket number (0, 1, ...) */ /* Partition number must be 0 */ /* irFlags : */ /* TL_NORMAL_FORMAT : Normal format */ /* TL_LEAVE_BINARY_AREA : Leave the previous binary area */ /* irData : Address of FormatParams2 structure to use */ /* (defined in format.h) */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flFormatPhysicalDrive(ioreq) bdCall(BD_FORMAT_PHYSICAL_DRIVE,ioreq) #define TL_NORMAL_FORMAT 0 #define TL_LEAVE_BINARY_AREA 8 /*----------------------------------------------------------------------*/ /* f l F o r m a t L o g i c a l D r i v e */ /* */ /* Performs formatting of a single block device partition of a */ /* DiskOnChip. All existing data of the partition is destroyed. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irData : Address of BDTLPartitionFormatParams structure */ /* to use (defined in format.h) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flFormatLogicalDrive(ioreq) bdCall(BD_FORMAT_LOGICAL_DRIVE,ioreq) /*----------------------------------------------------------------------*/ /* w r i t e B B T */ /* */ /* Erase the flash medium while marking bad block with 2 zeros in the */ /* first page of the unit. This state is the virgin state of the flash */ /* device allowing it to be reformated while incorporating the written */ /* bad blocks. */ /* */ /* Note that tl units are marked and not actual erasable blocks */ /* */ /* Parameters: */ /* irData : User buffer. */ /* irLength : Size of the media to erase. */ /* irFlags : User buffer length in bytes. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flWriteBBT(ioreq) bdCall(FL_WRITE_BBT,ioreq) #endif /* FORMAT_VOLUME */ #endif /*FL_READ_ONLY */ #ifdef ABS_READ_WRITE /*----------------------------------------------------------------------*/ /* f l A b s R e a d */ /* */ /* Reads absolute sectors by sector no. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* 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 */ /*----------------------------------------------------------------------*/ #define flAbsRead(ioreq) bdCall(FL_ABS_READ,ioreq) /*----------------------------------------------------------------------*/ /* 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: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* 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 */ /*----------------------------------------------------------------------*/ #define flAbsAddress(ioreq) bdCall(FL_ABS_ADDRESS,ioreq) /*----------------------------------------------------------------------*/ /* f l G e t B P B */ /* */ /* Reads the BIOS Parameter Block from the boot sector */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irData : Address of user buffer to read BPB into */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flGetBPB(ioreq) bdCall(FL_GET_BPB,ioreq) #ifndef FL_READ_ONLY /*----------------------------------------------------------------------*/ /* f l A b s W r i t e */ /* */ /* Writes absolute sectors by sector no. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* 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 */ /*----------------------------------------------------------------------*/ #define flAbsWrite(ioreq) bdCall(FL_ABS_WRITE,ioreq) /*----------------------------------------------------------------------*/ /* f l A b s D e l e t e */ /* */ /* Marks absolute sectors by sector no. as deleted. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irSectorNo : First sector no. to delete (sector 0 is the */ /* DOS boot sector). */ /* irSectorCount : Number of consectutive sectors to delete */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irSectorCount : Number of sectors actually deleted */ /*----------------------------------------------------------------------*/ #define flAbsDelete(ioreq) bdCall(FL_ABS_DELETE,ioreq) #ifdef WRITE_PROTECTION /*----------------------------------------------------------------------*/ /* f l W r i t e P r o t e c t i o n */ /* */ /* Put and remove write protection from the volume */ /* */ /* Note partition number 0 protectes the binary partition as well */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irFlags : FL_PROTECT=remove, FL_UNPROTECT=put */ /* and FL_UNLOCK=unlock */ /* irData : password (8 bytes) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flWriteProtection(ioreq) bdCall(FL_WRITE_PROTECTION,ioreq) #define FL_PROTECT 0 #define FL_UNPROTECT 1 #define FL_UNLOCK 2 #endif /* WRITE_PROTETION */ #endif /* FL_READ_ONLY */ #endif /* ABS_READ_WRITE */ #ifdef FL_LOW_LEVEL /*----------------------------------------------------------------------*/ /* P h y s i c a l I n f o */ /* */ /* A structure that holds physical information about the media. The */ /* information includes JEDEC ID, unit size and media size. Pointer */ /* to this structure is passed to the function flGetPhysicalInfo where */ /* it receives the relevant data. */ /* */ /*----------------------------------------------------------------------*/ typedef struct { unsigned short type; /* Flash device type (JEDEC id) */ char mediaType; /* type of media see below */ long int unitSize; /* Smallest physically erasable size (with interleaving taken in account) */ long int mediaSize; /* media size in bytes */ long int chipSize; /* individual chip size in bytes */ int interleaving; /* device interleaving */ } PhysicalInfo; /* media types */ #define FL_NOT_DOC 0 #define FL_DOC 1 #define FL_MDOC 2 #define FL_DOC2000TSOP 3 #define FL_MDOCP_16 4 #define FL_MDOCP 5 /*----------------------------------------------------------------------*/ /* f l 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: */ /* irHandle : Socket number (0,1,..) */ /* irData : Address of user buffer to read physical */ /* information into. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irLength : Window base address. note mast be cast to */ /* unsigned. */ /*----------------------------------------------------------------------*/ #define flGetPhysicalInfo(ioreq) bdCall(FL_GET_PHYSICAL_INFO, ioreq) /*----------------------------------------------------------------------*/ /* f l P h y s i c a l R e a d */ /* */ /* Read from a physical address. */ /* */ /* Parameters: */ /* irHandle : Socket number (0,1,..) */ /* irAddress : Physical address to read from. */ /* irByteCount : Number of bytes to read. */ /* irData : Address of user buffer to read into. */ /* irFlags : Method mode */ /* EDC: Activate ECC/EDC */ /* EXTRA: Read/write spare area */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flPhysicalRead(ioreq) bdCall(FL_PHYSICAL_READ,ioreq) #ifndef FL_READ_ONLY /*----------------------------------------------------------------------*/ /* f l P h y s i c a l W r i t e */ /* */ /* Write to a physical address. */ /* */ /* Parameters: */ /* irHandle : Socket number (0,1,..) */ /* irAddress : Physical address to write to. */ /* irByteCount : Number of bytes to write. */ /* irData : Address of user buffer to write from. */ /* irFlags : Method mode */ /* EDC: Activate ECC/EDC */ /* EXTRA: Read/write spare area */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flPhysicalWrite(ioreq) bdCall(FL_PHYSICAL_WRITE,ioreq) /* Bit assignment of irFlags for flPhysicalRead or flPhysicalWrite: */ /* ( defined in file flflash.h ) */ /* #define OVERWRITE 1 *//* Overwriting non-erased area */ /* #define EDC 2 *//* Activate ECC/EDC */ /* #define EXTRA 4 *//* Read/write spare area */ /*----------------------------------------------------------------------*/ /* f l P h y s i c a l E r a s e */ /* */ /* Erase physical units. */ /* */ /* Parameters: */ /* irHandle : Socket number (0,1,..) */ /* irUnitNo : First unit to erase. */ /* irUnitCount : Number of units to erase. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flPhysicalErase(ioreq) bdCall(FL_PHYSICAL_ERASE,ioreq) #endif /* FL_READ_ONLY */ #ifdef BDK_ACCESS /*------------------------------------------------------------------- * bdkReadInit - Init read operations on the DiskOnChip starting * at 'startUnit', with a size of 'areaLen' bytes and 'signature'. * * Note: Blocks in the DiskOnChip are marked with a 4-character signature * followed by a 4-digit hexadecimal number. * * Parameters: * 'irHandle' - Drive number (0, 1, ...) * bits 7-4 - Partition # (zero based) * bits 3-0 - Socket # (zero based) * 'irData' - bdkParams record * startingBlock - unit number of the sub-partition to start reading from * length - number of bytes to read * oldSign - signature of the sub-partition * flags - EDC or not * signOffset - signature offset 0 or 8 * * Return : * flOK - success * flDriveNotAvailable - DiskOnChip ASIC was not found * flUnknownMedia - failed in Flash chips recognition * flBadFormat - TL format does not exists * flNoSpaceInVolume - there are 0 units marked with this signature * flDataError - MTD read fault. * flHWReadProtect - HW read protection was triggerd *-------------------------------------------------------------------*/ #define bdkReadInit(ioreq) bdCall(FL_BINARY_READ_INIT,ioreq) /*------------------------------------------------------------------- * bdkReadBlock - Read to 'buffer' from the DiskOnChip BDK Image area. * * Note: Before the first use of this function 'bdkCopyBootAreaInit' * must be called * * Parameters: * 'irHandle' - Drive number (0, 1, ...) * bits 7-4 - Partition # (zero based) * bits 3-0 - Socket # (zero based) * 'irData' - bdkParams record * length - number of bytes to read * bdkBuffer - buffer to read into * * Return : * flOK - success * flDriveNotAvailable - DiskOnChip ASIC was not found * flUnknownMedia - failed in Flash chips recognition * flBadFormat - TL format does not exists * flNoSpaceInVolume - there are 0 units marked with this signature * flDataError - MTD read fault. * flHWReadProtect - HW read protection was triggerd *-------------------------------------------------------------------*/ #define bdkReadBlock(ioreq) bdCall(FL_BINARY_READ_BLOCK,ioreq) /*------------------------------------------------------------------- * bdkWriteInit - Init update operations on the DiskOnChip starting * at 'startUnit', with a size of 'areaLen' bytes and 'signature'. * * Note: Blocks in the DiskOnChip are marked with a 4-character signature * followed by a 4-digit hexadecimal number. * * Parameters: * 'irHandle' - Drive number (0, 1, ...) * bits 7-4 - Partition # (zero based) * bits 3-0 - Socket # (zero based) * 'irData' - bdkParams record * startingBlock - unit number of the sub-partition to start writting to * length - number of bytes to write * oldSign - signature of the sub-partition * flags - EDC \ BDK_COMPLETE_IMAGE_UPDATE * signOffset - signature offset 0 or 8 * * Return: flOK - success * flGeneralFailure - DiskOnChip ASIC was not found * flUnknownMedia - fail in Flash chips recognition * flNoSpaceInVolume - 'areaLen' is bigger than BootImage length *-------------------------------------------------------------------*/ #define bdkWriteInit(ioreq) bdCall(FL_BINARY_WRITE_INIT,ioreq) /*------------------------------------------------------------------- * bdkWriteBlock - Write 'buffer' to the DiskOnChip BDK Image area. * * Note: Before the first use of this function 'bdkUpdateBootAreaInit' * must be called * * Parameters: * 'irHandle' - Drive number (0, 1, ...) * bits 7-4 - Partition # (zero based) * bits 3-0 - Socket # (zero based) * 'irData' - bdkParams record * length - number of bytes to write * bdkBuffer - buffer to write from * flags - ERASE_BEFORE_WRITE * * Return: flOK - success * flBadLength - buffer length > Erasable Block Size * flWriteFault - fail in buffer writing * flNoSpaceInVolume - end of media was prematurely reached *-------------------------------------------------------------------*/ #define bdkWriteBlock(ioreq) bdCall(FL_BINARY_WRITE_BLOCK,ioreq) /*------------------------------------------------------------------- * bdkErase - erase given number of blockdsin the BDK area. * * Erase given number of blockds in the binary sub partition. * * Parameters: ioreq * 'irHandle' - Drive number (0, 1, ...) * bits 7-4 - Partition # (zero based) * bits 3-0 - Socket # (zero based) * 'irData' - bdkParams record * startingBlock - unit number of the sub-partition to start erasing from * length - number of blocks to erase * oldSign - signature of the sub-partition * signOffset - signature offset 0 or 8 * * Return: flOK - success * flBadLength - buffer length > Erasable Block Size * flWriteFault - fail in buffer writing * flNoSpaceInVolume - end of media was prematurely reached *-------------------------------------------------------------------*/ #define bdkErase(ioreq) bdCall(FL_BINARY_ERASE,ioreq) /*------------------------------------------------------------------- * bdkCreate - create new BDK partition . * * Init create operations on the DiskOnChip starting at 'startUnit', with * a # of 'units' and 'signature'. * * Note : Blocks in the DiskOnChip are marked with a 4-character signature * followed by a 4-digit hexadecimal number. * * Parameters: ioreq * 'irHandle' - Drive number (0, 1, ...) * bits 7-4 - Partition # (zero based) * bits 3-0 - Socket # (zero based) * 'irData' - bdkParams record * length - number of blocks to create * oldSign - signature of the sub-partition * newSign - the replacing signature * signOffset - signature offset 0 or 8 * * Return: flOK - success * flBadLength - buffer length > Erasable Block Size * flWriteFault - fail in buffer writing * flNoSpaceInVolume - end of media was prematurely reached *-------------------------------------------------------------------*/ #define bdkCreate(ioreq) bdCall(FL_BINARY_CREATE,ioreq) /*----------------------------------------------------------------------*/ /* b d k P a r t i t i o n I n f o */ /* */ /* Parameters: */ /* irHandle : volume number */ /* irData : pointer to structure that hold socket */ /* parameters */ /* irLength : Physical size of the binary volume */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed. */ /*----------------------------------------------------------------------*/ #define bdkPartitionInfo(ioreq) bdCall(FL_BINARY_PARTITION_INFO,ioreq) #endif /* BDK_ACCESS */ #ifdef HW_OTP /*----------------------------------------------------------------------*/ /* f l O T P S i z e */ /* */ /* Get the OTP size and stated */ /* */ /* Parameters: */ /* irHandle : Socket number ( 0,1,2... ) */ /* 4 LSB - Socket number */ /* irLength : The size of the used OTP area in bytes */ /* irCount : The size of the OTP ara in bytes */ /* irFlags : LOCKED_OTP for a locked area otherwise unlocked */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flOTPSize(ioreq) bdCall(FL_OTP_SIZE,ioreq) /* LOCKED_OTP 1 defined in flflash.h */ /*----------------------------------------------------------------------*/ /* f l O T P R e a d */ /* */ /* Read from the OTP area */ /* */ /* Parameters: */ /* irHandle : Socket number ( 0,1,2... ) */ /* 4 LSB - Socket number */ /* irData : pointer to user buffer to read into */ /* irLength : number of bytes to read */ /* irCount : offset to read from (starting at the begining of */ /* the OTP area */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flOTPRead(ioreq) bdCall(FL_OTP_READ,ioreq) /*----------------------------------------------------------------------*/ /* f l O T P W r i t e A n d L o c k */ /* */ /* Write to the OTP area while locking it at the end. */ /* */ /* Parameters: */ /* irHandle : Socket number ( 0,1,2... ) */ /* 4 LSB - Socket number */ /* irData : pointer to user buffer to write from */ /* irLength : number of bytes to write */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flOTPWriteAndLock(ioreq) bdCall(FL_OTP_WRITE,ioreq) /*----------------------------------------------------------------------*/ /* f l G e t U n i q u e I D */ /* */ /* Returns the 16 bytes device unique ID */ /* */ /* Parameters: */ /* irHandle : Socket number ( 0,1,2... ) */ /* 4 LSB - Socket number */ /* irData : pointer to a 16 bytes buffer to read into the */ /* unique ID data */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irData : 16 bytes unique ID buffer */ /*----------------------------------------------------------------------*/ #define flGetUniqueID(ioreq) bdCall(FL_UNIQUE_ID,ioreq) /*----------------------------------------------------------------------*/ /* f l G e t C u s t o m e r I D */ /* */ /* Returns the 4 bytes customer ID */ /* */ /* Parameters: */ /* irHandle : Socket number ( 0,1,2... ) */ /* 4 LSB - Socket number */ /* irData : pointer to a 4 bytes buffer to read into the */ /* customer ID */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irData : 4 bytes unique ID buffer */ /*----------------------------------------------------------------------*/ #define flGetCustomerID(ioreq) bdCall(FL_CUSTOMER_ID,ioreq) #endif /* HW_OTP */ #ifdef FL_LOW_LEVEL /*----------------------------------------------------------------------*/ /* f l D e e p P o w e r D o w n M o d e */ /* */ /* Forces the device into and out of the deep power down mode */ /* */ /* Parameters: */ /* irHandle : Socket number ( 0,1,2... ) */ /* 4 LSB - Socket number */ /* irFlags : DEEP_POWER_DOWN forces the low power consumption */ /* mode. otherwise turning to the regular mode */ /* */ /* Returns: None */ /*----------------------------------------------------------------------*/ #define flDeepPowerDownMode(ioreq) bdCall(FL_DEEP_POWER_DOWN_MODE,ioreq) /* DEEP_POWER_DOWN 1 defined in flflash.h */ #endif /* FL_LOW_LEVEL */ /*----------------------------------------------------------------------*/ /* f l 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: */ /* irHandle : Socket number ( 0,1,2... ) */ /* 4 LSB - Socket number */ /* irLength : One of the capabilities below to examine */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irLength : Either CAPABILITY_NOT_SUPPORTED or */ /* CAPABILITY_SUPPORTED. */ /*----------------------------------------------------------------------*/ #define flInquireCapabilities(ioreq) bdCall(FL_INQUIRE_CAPABILITIES,ioreq) /* capabilities flags */ typedef enum{ CAPABILITY_NOT_SUPPORTED = 0, CAPABILITY_SUPPORTED = 1, SUPPORT_UNERASABLE_BBT = 2, SUPPORT_MULTIPLE_BDTL_PARTITIONS = 3, SUPPORT_MULTIPLE_BINARY_PARTITIONS = 4, SUPPORT_HW_PROTECTION = 5, SUPPORT_HW_LOCK_KEY = 6, SUPPORT_CUSTOMER_ID = 7, SUPPORT_UNIQUE_ID = 8, SUPPORT_DEEP_POWER_DOWN_MODE = 9, SUPPORT_OTP_AREA = 10, SUPPORT_WRITE_IPL_ROUTINE = 11 }FLCapability; /*----------------------------------------------------------------------*/ /* f l P l a c e E x b B y B u f f e r */ /* */ /* Place M-systems firmware file on the media. */ /* This routine analizes the exb file calclats the media space needed */ /* for it taking only the device specific code. */ /* In addition the routine customizes the file and places it on the */ /* media. */ /* */ /* Note : The media must be already formated with enough binary area */ /* already marked with the SPL signature. This routine is best used */ /* with the format routine where the format routine is givven the first */ /* 512 bytes while the rest of the file is given with this routine */ /* */ /* Parameters: */ /* irHandle : Socket number (0,1,..) */ /* 4 LSB - Socket number */ /* irData : Buffer containing the entire/part of EXB file */ /* irLength : Size of the current buffer */ /* irWindowBase : Optional window base address to be loaded to */ /* irFlags : One of the following exb flags */ /* : INSTALL_FIRST - Install device as drive C: */ /* FLOPPY - Install device as drive A: */ /* QUIET - Do not show TFFS titles */ /* INT15_DISABLE - Do not hook int 15 */ /* SIS5598 - Support for SIS5598 platforms */ /* NO_PNP_HEADER - Do not place the PNP bios header */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flPlaceExbByBuffer(ioreq) bdCall(FL_PLACE_EXB,ioreq) /*----------------------------------------------------------------------*/ /* f l W r i t e I P L */ /* */ /* Place a user buffer to both copies of the IPL area */ /* */ /* Note : This routine is applicable only to docPlus famaly devices */ /* Doc2000 family devices will return flFeatureNotSupported */ /* */ /* Parameters: */ /* irHandle : Socket number (0,1,..) */ /* 4 LSB - Socket number */ /* irData : Pointer to user buffer */ /* irLength : Size of the buffer */ /* irFlags : See flags bellow */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flWriteIPL(ioreq) bdCall(FL_WRITE_IPL,ioreq) /* * defined in flflash.h * * FL_IPL_MODE_NORMAL 0 - Written as usual * FL_IPL_DOWNLOAD 1 - Download new IPL when done * FL_IPL_MODE_SA 2 - Written with Strong Arm mode enabled * FL_IPL_MODE_XSCALE 4 - Written with X-Scale mode enabled */ /*----------------------------------------------------------------------*/ /* 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: */ /* irHandle : Socket number (0,1,..) */ /* 4 LSB - Socket number */ /* irData : Pointer to user buffer */ /* irLength : Size of the buffer */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flReadIPL(ioreq) bdCall(FL_READ_IPL,ioreq) #endif /* FL_LOW_LEVEL */ /*----------------------------------------------------------------------*/ /* f l U p d a t e S o c k e t P a r a m s */ /* */ /* Pass socket parameters to the socket interface layer. */ /* This function should be called after the socket parameters (like */ /* size and base) are known. If these parameters are known at */ /* registration time then there is no need to use this function, and */ /* the parameters can be passed to the registration routine. */ /* The structure passed in irData is specific for each socket interface.*/ /* */ /* Parameters: */ /* irHandle : volume number */ /* irData : pointer to structure that hold socket */ /* parameters */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed. */ /*----------------------------------------------------------------------*/ #define flUpdateSocketParams(ioreq) bdCall(FL_UPDATE_SOCKET_PARAMS,ioreq) #ifdef HW_PROTECTION /*----------------------------------------------------------------------*/ /* f l I d e n t i f y P r o t e c t i o n */ /* b d k I d e n t i f y P r o t e c t i o n */ /* */ /* Returns the specified partitions protection attributes */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /* irFlags CHANGEABLE_PROTECTION - changeable protection type */ /* PROTECTABLE - partition can recieve protection */ /* READ_PROTECTED - partition is read protected */ /* WRITE_PROTECTED - partition is write protected */ /* LOCK_ENABLED - HW lock signal is enabled */ /* LOCK_ASSERTED - HW lock signal is asserted */ /* KEY_INSERTED - key is inserted (not currently */ /* protected. */ /*----------------------------------------------------------------------*/ #define flIdentifyProtection(ioreq) bdCall(FL_PROTECTION_GET_TYPE,ioreq) #define bdkIdentifyProtection(ioreq) bdCall(FL_BINARY_PROTECTION_GET_TYPE,ioreq) /* Protection partition flags (see flbase.h)*/ /*----------------------------------------------------------------------*/ /* f l I n s e r t P r o t e c t i o n K e y */ /* b d k I n s e r t P r o t e c t i o n K e y */ /* */ /* Insert the protection key in order to remove the protection of the */ /* partititon specified by the drive handle */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irData : pointer to an 8 bytes key array */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flInsertProtectionKey(ioreq) bdCall(FL_PROTECTION_INSERT_KEY,ioreq) #define bdkInsertProtectionKey(ioreq) bdCall(FL_BINARY_PROTECTION_INSERT_KEY,ioreq) /*----------------------------------------------------------------------*/ /* f l R e m o v e P r o t e c t i o n K e y */ /* b d k R e m o v e P r o t e c t i o n K e y */ /* */ /* Remove the protection key making the partition protected again */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flRemoveProtectionKey(ioreq) bdCall(FL_PROTECTION_REMOVE_KEY,ioreq) #define bdkRemoveProtectionKey(ioreq) bdCall(FL_BINARY_PROTECTION_REMOVE_KEY,ioreq) /*----------------------------------------------------------------------*/ /* f l H a r d w a r e P r o t e c t i o n L o c k */ /* b d k H a r d w a r e P r o t e c t i o n L o c k */ /* */ /* Enabled or disabled the affect of the hardware LOCK signal */ /* The hardware lock signal disables the removal of protection through */ /* the key therfore the partition will remain protected until the */ /* hardware LOCK signal will be removed */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irFlags : LOCK_ENABLED locks the partition otherwise */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flHardwareProtectionLock(ioreq) bdCall(FL_PROTECTION_SET_LOCK,ioreq) #define bdkHardwareProtectionLock(ioreq) bdCall(FL_BINARY_PROTECTION_CHANGE_LOCK,ioreq) /*----------------------------------------------------------------------*/ /* f l C h a n g e P r o t e c t i o n K e y */ /* b d k C h a n g e P r o t e c t i o n K e y */ /* */ /* Changes the current protection key with a new one. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* irData : Pointer to the new 8 bytes key array */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flChangeProtectionKey(ioreq) bdCall(FL_PROTECTION_CHANGE_KEY,ioreq) #define bdkChangeProtectionKey(ioreq) bdCall(FL_BINARY_PROTECTION_CHANGE_KEY,ioreq) /*----------------------------------------------------------------------*/ /* f l C h a n g e P r o t e c t i o n T y p e */ /* b d k C h a n g e P r o t e c t i o n T y p e */ /* */ /* Changes the protection attributes of the partitions. */ /* In order for a partition to change its protection type (without */ /* reformating the media) it must have the CHANGEABLE_PRTOECTION */ /* attribute. */ /* */ /* Parameters: */ /* irHandle : Drive number (0, 1, ...) */ /* bits 7-4 - Partition # (zero based) */ /* bits 3-0 - Socket # (zero based) */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #define flChangeProtectionType(ioreq) bdCall(FL_PROTECTION_CHANGE_TYPE,ioreq) #define bdkChangeProtectionType(ioreq) bdCall(FL_BINARY_PROTECTION_SET_TYPE,ioreq) #endif /* HW_PROTECTION */ #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 */ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ void NAMING_CONVENTION flExit(void); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* EXIT */ #ifdef ENVIRONMENT_VARS typedef enum { /* Variable type code for flSetEnv routin */ FL_ENV_VARS_PER_SYSTEM = 0, FL_IS_RAM_CHECK_ENABLED = 1, FL_TL_CACHE_ENABLED = 2, FL_DOC_8BIT_ACCESS = 3, FL_MULTI_DOC_ENABLED = 4, FL_SET_MAX_CHAIN = 5, FL_MARK_DELETE_ON_FLASH = 6, FL_MTL_POLICY = 7, FL_SECTORS_VERIFIED_PER_FOLDING = 8, FL_SUSPEND_MODE = 9, FL_ENV_VARS_PER_SOCKET = 100, FL_VERIFY_WRITE_OTHER = 101, FL_MTD_BUS_ACCESS_TYPE = 102, FL_ENV_VARS_PER_VOLUME = 200, FL_SET_POLICY = 201, FL_VERIFY_WRITE_BDTL = 202, FL_VERIFY_WRITE_BINARY = 203 } FLEnvVars; /*----------------------------------------------------------------------*/ /* 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 */ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ FLStatus NAMING_CONVENTION flSetEnvVolume(FLEnvVars variableType , byte socket,byte volume , dword value, dword FAR2 *prevValue); #ifdef __cplusplus } #endif /* __cplusplus */ /*----------------------------------------------------------------------*/ /* 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*/ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ FLStatus NAMING_CONVENTION flSetEnvSocket(FLEnvVars variableType , byte socket , dword value, dword FAR2 *prevValue); #ifdef __cplusplus } #endif /* __cplusplus */ /*----------------------------------------------------------------------*/ /* 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 */ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ FLStatus NAMING_CONVENTION flSetEnvAll(FLEnvVars variableType , dword value, dword FAR2 *prevValue); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* ENVIRONMENT_VARS */ /*----------------------------------------------------------------------*/ /* 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 */ /* */ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ void NAMING_CONVENTION flBuildGeometry(dword capacity, dword FAR2 *cylinders, dword FAR2 *heads,dword FAR2 *sectors, FLBoolean oldFormat); #ifdef __cplusplus } #endif /* __cplusplus */ #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 */ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ FLStatus NAMING_CONVENTION flSetDocBusRoutine(byte socket, FLAccessStruct FAR1 * structPtr); #ifdef __cplusplus } #endif /* __cplusplus */ /*----------------------------------------------------------------------*/ /* 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 */ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ FLStatus NAMING_CONVENTION flGetDocBusRoutine(byte socket, FLAccessStruct FAR1 * structPtr); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* FL_NO_USE_FUNC */ /*----------------------------------------------------------------------*/ /* 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 */ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ FLStatus NAMING_CONVENTION bdCall(FLFunctionNo functionNo, IOreq FAR2 *ioreq); #ifdef __cplusplus } #endif /* __cplusplus */ #ifdef PARSE_PATH /*----------------------------------------------------------------------*/ /* f l P a r s e P a t h */ /* */ /* Converts a DOS-like path string to a simple-path array. */ /* */ /* Note: Array length received in irPath must be greater than the */ /* number of path components in the path to convert. */ /* */ /* Parameters: */ /* irData : address of path string to convert */ /* irPath : address of array to receive parsed-path. */ /* */ /* Returns: */ /* FLStatus : 0 on success, otherwise failed */ /*----------------------------------------------------------------------*/ #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ extern FLStatus NAMING_CONVENTION flParsePath(IOreq FAR2 *ioreq); #ifdef __cplusplus } #endif /* __cplusplus */ #endif /* PARSE_PATH */ #endif /* BLOCKDEV_H */