开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
fatlite.h
资源名称：ixp425BSP.rar　[点击查看]
上传用户：luoyougen
上传日期：2008-05-12
资源大小：23136k
文件大小：39k
源码类别：

VxWorks

开发平台：

C/C++

fatlite.h：源码内容
  2. /*
  3.  * $Log:   P:/user/amir/lite/vcs/fatlite.h_v  $
  4.    
  5.       Rev 1.13   11 Sep 1997 15:24:04   danig
  6.    FlashType -> unsigned short
  7.    
  8.       Rev 1.12   10 Aug 1997 18:02:26   danig
  9.    Comments
  10.    
  11.       Rev 1.11   04 Aug 1997 13:18:28   danig
  12.    Low level API
  13.    
  14.       Rev 1.10   07 Jul 1997 15:23:24   amirban
  15.    Ver 2.0
  16.    
  17.       Rev 1.9   21 Oct 1996 18:10:10   amirban
  18.    Defragment I/F change
  19.    
  20.       Rev 1.8   17 Oct 1996 16:19:24   danig
  21.    Audio features
  22.    
  23.       Rev 1.7   20 Aug 1996 13:22:44   amirban
  24.    fsGetBPB
  26.       Rev 1.6   14 Jul 1996 16:47:44   amirban
  27.    Format Params
  29.       Rev 1.5   04 Jul 1996 18:19:24   amirban
  30.    New fsInit and modified fsGetDiskInfo
  31.    
  32.       Rev 1.4   09 Jun 1996 18:16:56   amirban
  33.    Added fsExit
  34.    
  35.       Rev 1.3   03 Jun 1996 16:20:48   amirban
  36.    Separated fsParsePath
  37.    
  38.       Rev 1.2   19 May 1996 19:31:16   amirban
  39.    Got rid of aliases in IOreq
  40.    
  41.       Rev 1.1   12 May 1996 20:05:38   amirban
  42.    Changes to findFile
  43.    
  44.       Rev 1.0   20 Mar 1996 13:33:20   amirban
  45.    Initial revision.
  46.  */
  48. /************************************************************************/
  49. /*                                                                      */
  50. /* FAT-FTL Lite Software Development Kit */
  51. /* Copyright (C) M-Systems Ltd. 1995-1996 */
  52. /* */
  53. /************************************************************************/
  56. #ifndef FATLITE_H
  57. #define FATLITE_H
  59. #ifdef __cplusplus
  60. extern "C" {
  61. #endif
  63. #include "flbase.h"
  64. #include "dosformt.h"
  66. typedef unsigned FLHandle; /* Handle of an open file or drive. */
  67. /* Actually an index to file table or */
  68. /* drive table. */
  71. /*----------------------------------------------------------------------*/
  72. /* P a t h - N a m e s */
  73. /* */
  74. /* A path-name is represented as an array of SimplePath records. */
  75. /* Each SimplePath record holds a directory or file name segment, with  */
  76. /* the full 8.3 (spaces not compressed) name. */
  77. /* */
  78. /* Path-names always start at the root directory. There is no current   */
  79. /* directory. The directories pointers '.' and '..' can be specified */
  80. /* as the 'name' part of the path-segment, except at the root-directory.*/
  81. /* */
  82. /* Lower-case letters are different from upper-case. To be compatible   */
  83. /* with DOS, file-names should be upper-case. File names may contain    */
  84. /* any character, but files starting with hex E5 are considered deleted */
  85. /* according to DOS convention. */
  86. /* */
  87. /* A null (hex 0) in the first byte of the name field denotes that the  */
  88. /* path ends here. */
  89. /*                                                                      */
  90. /* Note that paths can be specified as strings: For example:      */
  91. /* */
  92. /* "UTIL       FATLITE H  "    ===> "UTILFATLITE.H". */
  93. /* ""  ===> "" (root directory) */
  94. /* "AUTOEXECBAT"                ===> "AUTOEXEC.BAT" */
  95. /* "UTIL       ..         "  ===> "UTIL.." (root directory) */
  96. /* */
  97. /* The optional service flParsePath may be used to convert regular */
  98. /* string paths to this format. */
  99. /*----------------------------------------------------------------------*/
  101. typedef struct {
  102.    char name[8]; /* name part of path segment */
  103. /* A hex 0 in 1st character indicates end of path */
  104.    char ext[3]; /* extension part of path segment */
  105. } FLSimplePath;
  108. /*----------------------------------------------------------------------*/
  109. /*   I O r e q */
  110. /* */
  111. /* IOreq is a common structure passed to all file-system functions. */
  112. /* Refer to the description of individual functions for specific usage  */
  113. /* of fields. Some fields have different names when used by different   */
  114. /* functions, hence the use of unions. */
  115. /* */
  116. /*----------------------------------------------------------------------*/
  118. typedef struct {
  119.   FLHandle irHandle; /* Handle of file or drive for operation*/
  120.   unsigned irFlags; /* function-specific flags  */
  121.   FLSimplePath FAR1 * irPath; /* path of file for operation  */
  122.   void FAR1 * irData; /* Pointer to user-buffer for operation */
  123.   long irLength; /* No. of bytes, size or position for   */
  124. /* operation   */
  125. } IOreq;
  127. /* definiftions for absolute read & write */
  128. #define irSectorCount irFlags
  129. #define irSectorNo irLength
  131. /* definitions for physical read & write */
  132. #define irByteCount irFlags
  133. #define irAddress       irLength
  135. /* definitions for physical erase */
  136. #define irUnitCount     irFlags
  137. #define irUnitNo irLength
  139. /*----------------------------------------------------------------------*/
  140. /*            f l C a l l    */
  141. /* */
  142. /* Common entry-point to all file-system functions. Macros are          */
  143. /* to call individual function, which are separately described below. */
  144. /*                                                                      */
  145. /* Parameters:                                                          */
  146. /* function : file-system function code (listed below) */
  147. /* ioreq : IOreq structure */
  148. /*                                                                      */
  149. /* Returns:                                                             */
  150. /* FLStatus : 0 on success, otherwise failed                */
  151. /*----------------------------------------------------------------------*/
  153. typedef enum    {FL_MOUNT_VOLUME,
  154.  FL_DISMOUNT_VOLUME,
  155.  FL_CHECK_VOLUME,
  156.  FL_OPEN_FILE,
  157.  FL_CLOSE_FILE,
  158.  FL_READ_FILE,
  159.  FL_WRITE_FILE,
  160.  FL_SEEK_FILE,
  161.  FL_FIND_FILE,
  162.  FL_FIND_FIRST_FILE,
  163.  FL_FIND_NEXT_FILE,
  164.  FL_GET_DISK_INFO,
  165.  FL_DELETE_FILE,
  166.  FL_RENAME_FILE,
  167.  FL_DEFRAGMENT_VOLUME,
  168.  FL_FORMAT_VOLUME,
  169.  FL_MAKE_DIR,
  170.  FL_REMOVE_DIR,
  171.  FL_ABS_READ,
  172.  FL_ABS_WRITE,
  173.  FL_ABS_DELETE,
  174.  FL_GET_BPB,
  175.  FL_SPLIT_FILE,
  176.  FL_JOIN_FILE,
  177.  FL_GET_PHYSICAL_INFO,
  178.  FL_PHYSICAL_READ,
  179.  FL_PHYSICAL_WRITE,
  180.  FL_PHYSICAL_ERASE,
  181.  FL_DONT_MONITOR_FAT} FLFunctionNo;
  184. FLStatus flCall(FLFunctionNo functionNo, IOreq FAR2 *ioreq);
  187. /*----------------------------------------------------------------------*/
  188. /*       f l M o u n t V o l u m e */
  189. /* */
  190. /* Mounts, verifies or dismounts the Flash medium. */
  191. /* */
  192. /* In case the inserted volume has changed, or on the first access to   */
  193. /* the file system, it should be mounted before file operations can be  */
  194. /* done on it. */
  195. /* Mounting a volume has the effect of discarding all open files (the   */
  196. /* files cannot be properly closed since the original volume is gone),  */
  197. /* and turning off the media-change indication to allow file processing */
  198. /* calls. */
  199. /* */
  200. /* The volume automatically becomes unmounted if it is removed or       */
  201. /* changed. */
  202. /*                                                                      */
  203. /* Parameters:                                                          */
  204. /* irHandle : Drive number (0, 1, ...) */
  205. /*                                                                      */
  206. /* Returns:                                                             */
  207. /* FLStatus : 0 on success, otherwise failed                */
  208. /*----------------------------------------------------------------------*/
  210. #define flMountVolume(ioreq) flCall(FL_MOUNT_VOLUME,ioreq)
  213. /*----------------------------------------------------------------------*/
  214. /*    f l D i s m o u n t V o l u m e */
  215. /* */
  216. /* Dismounts the volume, closing all files. */
  217. /* This call is not normally necessary, unless it is known the volume   */
  218. /* will soon be removed. */
  219. /* */
  220. /* Parameters:                                                          */
  221. /* irHandle : Drive number (0, 1, ...) */
  222. /*                                                                      */
  223. /* Returns:                                                             */
  224. /* FLStatus : 0 on success, otherwise failed                */
  225. /*----------------------------------------------------------------------*/
  227. #define flDismountVolume(ioreq) flCall(FL_DISMOUNT_VOLUME,ioreq)
  230. /*----------------------------------------------------------------------*/
  231. /*      f l C h e c k V o l u m e */
  232. /* */
  233. /* Verifies that the current volume is mounted. */
  234. /*                                                                      */
  235. /* Parameters:                                                          */
  236. /* irHandle : Drive number (0, 1, ...) */
  237. /*                                                                      */
  238. /* Returns:                                                             */
  239. /* FLStatus : 0 on success, otherwise failed                */
  240. /*----------------------------------------------------------------------*/
  242. #define flCheckVolume(ioreq) flCall(FL_CHECK_VOLUME,ioreq)
  245. #ifdef DEFRAGMENT_VOLUME
  247. /*----------------------------------------------------------------------*/
  248. /*       f l D e f r a g m e n t V o l u m e */
  249. /* */
  250. /* Performs a general defragmentation and recycling of non-writable */
  251. /* Flash areas, to achieve optimal write speed. */
  252. /*                                                                      */
  253. /* NOTE: The required number of sectors (in irLength) may be changed    */
  254. /* (from another execution thread) while defragmentation is active. In  */
  255. /* particular, the defragmentation may be cut short after it began by */
  256. /* modifying the irLength field to 0. */
  257. /* */
  258. /* Parameters:                                                          */
  259. /* irHandle : Drive number (0, 1, ...) */
  260. /* irLength : Minimum number of sectors to make available   */
  261. /*   for writes. */
  262. /*                                                                      */
  263. /* Returns:                                                             */
  264. /* irLength : Actual number of sectors available for writes */
  265. /* FLStatus : 0 on success, otherwise failed                */
  266. /*----------------------------------------------------------------------*/
  268. #define flDefragmentVolume(ioreq) flCall(FL_DEFRAGMENT_VOLUME,ioreq)
  270. #endif /* DEFRAGMENT_VOLUME */
  273. #ifdef FORMAT_VOLUME
  275. /*----------------------------------------------------------------------*/
  276. /*       f l F o r m a t V o l u m e */
  277. /* */
  278. /* Formats a volume, writing a new and empty file-system. All existing  */
  279. /* data is destroyed. Optionally, a low-level FTL formatting is also    */
  280. /* done. */
  281. /* Formatting leaves the volume in the dismounted state, so that a */
  282. /* flMountVolume call is necessary after it. */
  283. /*                                                                      */
  284. /* Parameters:                                                          */
  285. /* irHandle : Drive number (0, 1, ...) */
  286. /* irFlags : NO_FTL_FORMAT: Do FAT formatting only */
  287. /*   FTL_FORMAT: Do FTL & FAT formatting           */
  288. /*   FTL_FORMAT_IF_NEEDED: Do FTL formatting only */
  289. /*       if current format is invalid */
  290. /* irData : Address of FormatParams structure to use */
  291. /*   (defined in dosformt.h) */
  292. /*                                                                      */
  293. /* Returns:                                                             */
  294. /* FLStatus : 0 on success, otherwise failed                */
  295. /*----------------------------------------------------------------------*/
  297. /** Values of irFlags for flFormatVolume: */
  299. #define NO_FTL_FORMAT 0 /* FAT formatting only */
  300. #define FTL_FORMAT 1 /* FAT & FTL formatting */
  301. #define FTL_FORMAT_IF_NEEDED 2 /* FAT formatting & FTL formatting if necessary */
  302. #define PROGRESS_REPORT /* Format progress is reported via callback */
  304. #define flFormatVolume(ioreq) flCall(FL_FORMAT_VOLUME,ioreq)
  306. #endif /* FORMAT_VOLUME */
  309. #if FILES > 0
  311. /*----------------------------------------------------------------------*/
  312. /*       f l O p e n F i l e */
  313. /* */
  314. /* Opens an existing file or creates a new file. Creates a file handle  */
  315. /* for further file processing. */
  316. /*                                                                      */
  317. /* Parameters:                                                          */
  318. /* irHandle : Drive number (0, 1, ...) */
  319. /* irFlags : Access and action options, defined below */
  320. /* irPath : path of file to open              */
  321. /*                                                                      */
  322. /* Returns:                                                             */
  323. /* FLStatus : 0 on success, otherwise failed                */
  324. /* irHandle : New file handle for open file                 */
  325. /*                                                                      */
  326. /*----------------------------------------------------------------------*/
  328. /** Values of irFlags for flOpenFile: */
  330. #define ACCESS_MODE_MASK 3 /* Mask for access mode bits */
  332. /* Individual flags */
  334. #define ACCESS_READ_WRITE 1 /* Allow read and write */
  335. #define ACCESS_CREATE 2 /* Create new file */
  337. /* Access mode combinations */
  338. #define OPEN_FOR_READ 0 /* open existing file for read-only */
  339. #define OPEN_FOR_UPDATE 1 /* open existing file for read/write access */
  340. #define OPEN_FOR_WRITE 3 /* create a new file, even if it exists */
  343. #define flOpenFile(ioreq) flCall(FL_OPEN_FILE,ioreq)
  346. /*----------------------------------------------------------------------*/
  347. /*       f l C l o s e F i l e */
  348. /* */
  349. /* Closes an open file, records file size and dates in directory and    */
  350. /* releases file handle. */
  351. /*                                                                      */
  352. /* Parameters:                                                          */
  353. /* irHandle : Handle of file to close.                      */
  354. /*                                                                      */
  355. /* Returns:                                                             */
  356. /* FLStatus : 0 on success, otherwise failed                */
  357. /*----------------------------------------------------------------------*/
  359. #define flCloseFile(ioreq)      flCall(FL_CLOSE_FILE,ioreq)
  362. #ifdef SPLIT_JOIN_FILE
  364. /*------------------------------------------------------------------------*/
  365. /*       f l S p l i t F i l e                               */
  366. /*                                                                        */
  367. /* Splits the file into two files. The original file contains the first   */
  368. /* part, and a new file (which is created for that purpose) contains      */
  369. /* the second part. If the current position is on a cluster               */
  370. /* boundary, the file will be split at the current position. Otherwise,   */
  371. /* the cluster of the current position is duplicated, one copy is the     */
  372. /* first cluster of the new file, and the other is the last cluster of the*/
  373. /* original file, which now ends at the current position.                 */
  374. /*                                                                        */
  375. /* Parameters:                                                            */
  376. /* file            : file to split.                                  */
  377. /*      irPath          : Path name of the new file.                      */
  378. /*                                                                        */
  379. /* Returns:                                                               */
  380. /* irHandle        : handle of the new file.                         */
  381. /* FLStatus        : 0 on success, otherwise failed.                 */
  382. /*                                                                        */
  383. /*------------------------------------------------------------------------*/
  385. #define flSplitFile(ioreq)     flCall(FL_SPLIT_FILE,ioreq)
  388. /*------------------------------------------------------------------------*/
  389. /*       f l J o i n F i l e                                 */
  390. /*                                                                        */
  391. /* joins two files. If the end of the first file is on a cluster          */
  392. /* boundary, the files will be joined there. Otherwise, the data in       */
  393. /* the second file from the beginning until the offset that is equal to   */
  394. /* the offset in cluster of the end of the first file will be lost. The   */
  395. /* rest of the second file will be joined to the first file at the end of */
  396. /* the first file. On exit, the first file is the expanded file and the   */
  397. /* second file is deleted.                                                */
  398. /* Note: The second file will be open by this function, it is advised to  */
  399. /*  close it before calling this function in order to avoid          */
  400. /*  inconsistencies.                                                 */
  401. /*                                                                        */
  402. /* Parameters:                                                            */
  403. /* file            : file to join to.                                */
  404. /* irPath          : Path name of the file to be joined.             */
  405. /*                                                                        */
  406. /* Return:                                                                */
  407. /* FLStatus        : 0 on success, otherwise failed.                 */
  408. /*                                                                        */
  409. /*------------------------------------------------------------------------*/
  411. #define flJoinFile(ioreq)     flCall(FL_JOIN_FILE,ioreq)
  413. #endif /* SPLIT_JOIN_FILE */
  415. /*----------------------------------------------------------------------*/
  416. /*       f l R e a d F i l e */
  417. /* */
  418. /* Reads from the current position in the file to the user-buffer. */
  419. /* Parameters:                                                          */
  420. /* irHandle : Handle of file to read.                       */
  421. /*      irData : Address of user buffer */
  422. /* irLength : Number of bytes to read. If the read extends  */
  423. /*   beyond the end-of-file, the read is truncated */
  424. /*   at the end-of-file. */
  425. /*                                                                      */
  426. /* Returns:                                                             */
  427. /* FLStatus : 0 on success, otherwise failed                */
  428. /* irLength : Actual number of bytes read */
  429. /*----------------------------------------------------------------------*/
  431. #define flReadFile(ioreq) flCall(FL_READ_FILE,ioreq)
  434. /*----------------------------------------------------------------------*/
  435. /*       f l W r i t e F i l e */
  436. /* */
  437. /* Writes from the current position in the file from the user-buffer.   */
  438. /*                                                                      */
  439. /* Parameters:                                                          */
  440. /* irHandle : Handle of file to write. */
  441. /*      irData : Address of user buffer */
  442. /* irLength : Number of bytes to write. */
  443. /*                                                                      */
  444. /* Returns:                                                             */
  445. /* FLStatus : 0 on success, otherwise failed                */
  446. /* irLength : Actual number of bytes written */
  447. /*----------------------------------------------------------------------*/
  449. #define flWriteFile(ioreq) flCall(FL_WRITE_FILE,ioreq)
  452. /*----------------------------------------------------------------------*/
  453. /*       f l S e e k F i l e */
  454. /* */
  455. /* Sets the current position in the file, relative to file start, end or*/
  456. /* current position. */
  457. /* Note: This function will not move the file pointer beyond the */
  458. /* beginning or end of file, so the actual file position may be */
  459. /* different from the required. The actual position is indicated on     */
  460. /* return. */
  461. /*                                                                      */
  462. /* Parameters:                                                          */
  463. /* irHandle : File handle to close.                         */
  464. /*      irLength : Offset to set position. */
  465. /* irFlags : Method code */
  466. /*   SEEK_START: absolute offset from start of file  */
  467. /*   SEEK_CURR:  signed offset from current position */
  468. /*   SEEK_END:   signed offset from end of file    */
  469. /*                                                                      */
  470. /* Returns:                                                             */
  471. /* FLStatus : 0 on success, otherwise failed                */
  472. /* irLength : Actual absolute offset from start of file */
  473. /*----------------------------------------------------------------------*/
  475. /** Values of irFlags for flSeekFile: */
  477. #define SEEK_START 0 /* offset from start of file */
  478. #define SEEK_CURR 1 /* offset from current position */
  479. #define SEEK_END 2 /* offset from end of file */
  482. #define flSeekFile(ioreq) flCall(FL_SEEK_FILE,ioreq)
  485. /*----------------------------------------------------------------------*/
  486. /*           f l F i n d F i l e */
  487. /*                                                                      */
  488. /* Finds a file entry in a directory, optionally modifying the file     */
  489. /* time/date and/or attributes.                                         */
  490. /* Files may be found by handle no. provided they are open, or by name. */
  491. /* Only the Hidden, System or Read-only attributes may be modified. */
  492. /* Entries may be found for any existing file or directory other than   */
  493. /* the root. A DirectoryEntry structure describing the file is copied   */
  494. /* to a user buffer. */
  495. /*                                                                      */
  496. /* The DirectoryEntry structure is defined in dosformt.h */
  497. /*                                                                      */
  498. /* Parameters:                                                          */
  499. /* irHandle : If by name: Drive number (0, 1, ...) */
  500. /*   else      : Handle of open file */
  501. /* irPath : If by name: Specifies a file or directory path*/
  502. /* irFlags : Options flags */
  503. /*   FIND_BY_HANDLE: Find open file by handle.  */
  504. /*   Default is access by path.    */
  505. /*                        SET_DATETIME: Update time/date from buffer */
  506. /*   SET_ATTRIBUTES: Update attributes from buffer */
  507. /* irDirEntry : Address of user buffer to receive a */
  508. /*   DirectoryEntry structure */
  509. /*                                                                      */
  510. /* Returns:                                                             */
  511. /* irLength : Modified */
  512. /* FLStatus : 0 on success, otherwise failed                */
  513. /*----------------------------------------------------------------------*/
  515. /** Bit assignment of irFlags for flFindFile: */
  517. #define SET_DATETIME 1 /* Change date/time */
  518. #define SET_ATTRIBUTES 2 /* Change attributes */
  519. #define FIND_BY_HANDLE 4 /* Find file by handle rather than by name */
  521. #define flFindFile(ioreq) flCall(FL_FIND_FILE,ioreq)
  524. /*----------------------------------------------------------------------*/
  525. /*  f l F i n d F i r s t F i l e */
  526. /*                                                                      */
  527. /* Finds the first file entry in a directory. */
  528. /* This function is used in combination with the flFindNextFile call,   */
  529. /* which returns the remaining file entries in a directory sequentially.*/
  530. /* Entries are returned according to the unsorted directory order. */
  531. /* flFindFirstFile creates a file handle, which is returned by it. Calls*/
  532. /* to flFindNextFile will provide this file handle. When flFindNextFile */
  533. /* returns 'noMoreEntries', the file handle is automatically closed.    */
  534. /* Alternatively the file handle can be closed by a 'closeFile' call    */
  535. /* before actually reaching the end of directory. */
  536. /* A DirectoryEntry structure is copied to the user buffer describing   */
  537. /* each file found. This structure is defined in dosformt.h. */
  538. /*                                                                      */
  539. /* Parameters:                                                          */
  540. /* irHandle : Drive number (0, 1, ...) */
  541. /* irPath : Specifies a directory path */
  542. /* irData : Address of user buffer to receive a */
  543. /*   DirectoryEntry structure */
  544. /*                                                                      */
  545. /* Returns:                                                             */
  546. /* irHandle : File handle to use for subsequent operations. */
  547. /* FLStatus : 0 on success, otherwise failed                */
  548. /*----------------------------------------------------------------------*/
  550. #define flFindFirstFile(ioreq) flCall(FL_FIND_FIRST_FILE,ioreq)
  553. /*----------------------------------------------------------------------*/
  554. /*  f l F i n d N e x t F i l e */
  555. /*                                                                      */
  556. /* See the description of 'flFindFirstFile'. */
  557. /*                                                                      */
  558. /* Parameters:                                                          */
  559. /* irHandle : File handle returned by flFindFirstFile. */
  560. /* irData : Address of user buffer to receive a */
  561. /*   DirectoryEntry structure */
  562. /*                                                                      */
  563. /* Returns:                                                             */
  564. /* FLStatus : 0 on success, otherwise failed                */
  565. /*----------------------------------------------------------------------*/
  567. #define flFindNextFile(ioreq) flCall(FL_FIND_NEXT_FILE,ioreq)
  570. /*----------------------------------------------------------------------*/
  571. /*       f l G e t D i s k I n f o */
  572. /* */
  573. /* Returns general allocation information. */
  574. /* */
  575. /* The bytes/sector, sector/cluster, total cluster and free cluster */
  576. /* information are returned into a DiskInfo structure. */
  577. /*                                                                      */
  578. /* Parameters:                                                          */
  579. /* irHandle : Drive number (0, 1, ...) */
  580. /* irData : Address of DiskInfo structure                 */
  581. /*                                                                      */
  582. /* Returns:                                                             */
  583. /* FLStatus : 0 on success, otherwise failed                */
  584. /*----------------------------------------------------------------------*/
  586. typedef struct {
  587.   unsigned bytesPerSector;
  588.   unsigned sectorsPerCluster;
  589.   unsigned totalClusters;
  590.   unsigned freeClusters;
  591. } DiskInfo;
  594. #define flGetDiskInfo(ioreq) flCall(FL_GET_DISK_INFO,ioreq)
  597. /*----------------------------------------------------------------------*/
  598. /*       f l D e l e t e F i l e */
  599. /* */
  600. /* Deletes a file.                                                      */
  601. /*                                                                      */
  602. /* Parameters:                                                          */
  603. /* irHandle : Drive number (0, 1, ...) */
  604. /* irPath : path of file to delete */
  605. /*                                                                      */
  606. /* Returns:                                                             */
  607. /* FLStatus : 0 on success, otherwise failed                */
  608. /*----------------------------------------------------------------------*/
  610. #define flDeleteFile(ioreq) flCall(FL_DELETE_FILE,ioreq)
  613. #ifdef RENAME_FILE
  615. /*----------------------------------------------------------------------*/
  616. /*       f l R e n a m e F i l e */
  617. /* */
  618. /* Renames a file to another name. */
  619. /* */
  620. /* Parameters:                                                          */
  621. /* irHandle : Drive number (0, 1, ...) */
  622. /* irPath : path of existing file */
  623. /*      irData : path of new name. */
  624. /*                                                                      */
  625. /* Returns:                                                             */
  626. /* FLStatus : 0 on success, otherwise failed                */
  627. /*----------------------------------------------------------------------*/
  629. #define flRenameFile(ioreq) flCall(FL_RENAME_FILE,ioreq)
  631. #endif /* RENAME_FILE */
  634. #ifdef SUB_DIRECTORY
  636. /*----------------------------------------------------------------------*/
  637. /*       f l M a k e D i r */
  638. /* */
  639. /* Creates a new directory. */
  640. /*                                                                      */
  641. /* Parameters:                                                          */
  642. /* irHandle : Drive number (0, 1, ...) */
  643. /* irPath : path of new directory. */
  644. /*                                                                      */
  645. /* Returns:                                                             */
  646. /* FLStatus : 0 on success, otherwise failed                */
  647. /*----------------------------------------------------------------------*/
  649. #define flMakeDir(ioreq) flCall(FL_MAKE_DIR,ioreq)
  652. /*----------------------------------------------------------------------*/
  653. /*       f l R e m o v e D i r */
  654. /* */
  655. /* Removes an empty directory. */
  656. /*                                                                      */
  657. /* Parameters:                                                          */
  658. /* irHandle : Drive number (0, 1, ...) */
  659. /* irPath : path of directory to remove. */
  660. /*                                                                      */
  661. /* Returns:                                                             */
  662. /* FLStatus : 0 on success, otherwise failed                */
  663. /*----------------------------------------------------------------------*/
  665. #define flRemoveDir(ioreq) flCall(FL_REMOVE_DIR,ioreq)
  667. #endif /* SUB_DIRECTORY */
  669. #endif /* FILES > 0 */
  671. #ifdef PARSE_PATH
  673. /*----------------------------------------------------------------------*/
  674. /*       f l P a r s e P a t h */
  675. /* */
  676. /* Converts a DOS-like path string to a simple-path array. */
  677. /*                                                                      */
  678. /* Parameters:                                                          */
  679. /* irHandle : Drive number (0, 1, ...) */
  680. /* irData : address of path string to convert */
  681. /* irPath : address of array to receive parsed-path */
  682. /*                                                                      */
  683. /* Returns:                                                             */
  684. /* FLStatus : 0 on success, otherwise failed                */
  685. /*----------------------------------------------------------------------*/
  687. extern FLStatus flParsePath(IOreq FAR2 *ioreq);
  689. #endif /* PARSE_PATH */
  692. #ifdef ABS_READ_WRITE
  694. /*----------------------------------------------------------------------*/
  695. /*            f l A b s R e a d  */
  696. /* */
  697. /* Reads absolute sectors by sector no. */
  698. /* */
  699. /* Parameters:                                                          */
  700. /* irHandle : Drive number (0, 1, ...) */
  701. /*      irData : Address of user buffer to read into */
  702. /* irSectorNo : First sector no. to read (sector 0 is the */
  703. /*   DOS boot sector). */
  704. /* irSectorCount : Number of consectutive sectors to read */
  705. /*                                                                      */
  706. /* Returns:                                                             */
  707. /* FLStatus : 0 on success, otherwise failed                */
  708. /* irSectorCount : Number of sectors actually read */
  709. /*----------------------------------------------------------------------*/
  711. #define flAbsRead(ioreq) flCall(FL_ABS_READ,ioreq)
  714. /*----------------------------------------------------------------------*/
  715. /*          f l A b s W r i t e  */
  716. /* */
  717. /* Writes absolute sectors by sector no. */
  718. /* */
  719. /* Parameters:                                                          */
  720. /* irHandle : Drive number (0, 1, ...) */
  721. /*      irData : Address of user buffer to write from */
  722. /* irSectorNo : First sector no. to write (sector 0 is the */
  723. /*   DOS boot sector). */
  724. /* irSectorCount : Number of consectutive sectors to write */
  725. /*                                                                      */
  726. /* Returns:                                                             */
  727. /* FLStatus : 0 on success, otherwise failed                */
  728. /* irSectorCount : Number of sectors actually written */
  729. /*----------------------------------------------------------------------*/
  731. #define flAbsWrite(ioreq) flCall(FL_ABS_WRITE,ioreq)
  734. /*----------------------------------------------------------------------*/
  735. /*          f l A b s D e l e t e  */
  736. /* */
  737. /* Marks absolute sectors by sector no. as deleted. */
  738. /* */
  739. /* Parameters:                                                          */
  740. /* irHandle : Drive number (0, 1, ...) */
  741. /* irSectorNo : First sector no. to write (sector 0 is the */
  742. /*   DOS boot sector). */
  743. /* irSectorCount : Number of consectutive sectors to delete */
  744. /*                                                                      */
  745. /* Returns:                                                             */
  746. /* FLStatus : 0 on success, otherwise failed                */
  747. /* irSectorCount : Number of sectors actually deleted */
  748. /*----------------------------------------------------------------------*/
  750. #define flAbsDelete(ioreq) flCall(FL_ABS_DELETE,ioreq)
  753. /*----------------------------------------------------------------------*/
  754. /*            f l G e t B P B  */
  755. /* */
  756. /* Reads the BIOS Parameter Block from the boot sector */
  757. /* */
  758. /* Parameters:                                                          */
  759. /* irHandle : Drive number (0, 1, ...) */
  760. /*      irData : Address of user buffer to read BPB into */
  761. /*                                                                      */
  762. /* Returns:                                                             */
  763. /* FLStatus : 0 on success, otherwise failed                */
  764. /*----------------------------------------------------------------------*/
  766. #define flGetBPB(ioreq) flCall(FL_GET_BPB,ioreq)
  768. #endif /* ABS_READ_WRITE */
  770. #ifdef LOW_LEVEL
  772. /*----------------------------------------------------------------------*/
  773. /*   P h y s i c a l I n f o */
  774. /* */
  775. /* A structure that holds physical information about the media. The  */
  776. /* information includes JEDEC ID, unit size and media size. Pointer */
  777. /* to this structure is passed to the function flGetPhysicalInfo where  */
  778. /* it receives the relevant data. */
  779. /* */
  780. /*----------------------------------------------------------------------*/
  782. typedef struct {
  783.   unsigned short type; /* Flash device type (JEDEC id) */
  784.   long int unitSize; /* Smallest physically erasable size
  785.    (with interleaving taken in account) */
  786.   long int mediaSize; /* media size */
  787. } PhysicalInfo;
  789. /*----------------------------------------------------------------------*/
  790. /*          f l G e t P h y s i c a l I n f o  */
  791. /* */
  792. /* Get physical information of the media. The information includes */
  793. /* JEDEC ID, unit size and media size. */
  794. /* */
  795. /* Parameters: */
  796. /* irHandle : Drive number (0,1,..) */
  797. /*      irData : Address of user buffer to read physical */
  798. /*   information into. */
  799. /*                                                                      */
  800. /* Returns:                                                             */
  801. /* FLStatus : 0 on success, otherwise failed                */
  802. /*----------------------------------------------------------------------*/
  804. #define flGetPhysicalInfo(ioreq) flCall(FL_GET_PHYSICAL_INFO, ioreq)
  806. /*----------------------------------------------------------------------*/
  807. /*              f l P h y s i c a l R e a d   */
  808. /* */
  809. /* Read from a physical address. */
  810. /* */
  811. /* Parameters: */
  812. /* irHandle : Drive number (0,1,..) */
  813. /* irAddress : Physical address to read from. */
  814. /* irByteCount : Number of bytes to read. */
  815. /*      irData : Address of user buffer to read into. */
  816. /*                                                                      */
  817. /* Returns:                                                             */
  818. /* FLStatus : 0 on success, otherwise failed                */
  819. /*----------------------------------------------------------------------*/
  821. #define flPhysicalRead(ioreq) flCall(FL_PHYSICAL_READ,ioreq)
  823. /*----------------------------------------------------------------------*/
  824. /*              f l P h y s i c a l W r i t e   */
  825. /* */
  826. /* Write to a physical address. */
  827. /* */
  828. /* Parameters: */
  829. /* irHandle : Drive Number (0,1,..) */
  830. /* irAddress : Physical address to write to. */
  831. /* irByteCount : Number of bytes to write. */
  832. /*      irData : Address of user buffer to write from. */
  833. /*                                                                      */
  834. /* Returns:                                                             */
  835. /* FLStatus : 0 on success, otherwise failed                */
  836. /*----------------------------------------------------------------------*/
  838. #define flPhysicalWrite(ioreq) flCall(FL_PHYSICAL_WRITE,ioreq)
  840. /*----------------------------------------------------------------------*/
  841. /*              f l P h y s i c a l E r a s e   */
  842. /* */
  843. /* Erase physical units. */
  844. /* */
  845. /* Parameters: */
  846. /*  irHandle : Drive number (0,1,..) */
  847. /* irUnitNo : First unit to erase. */
  848. /* irUnitCount : Number of units to erase. */
  849. /*                                                                      */
  850. /* Returns:                                                             */
  851. /* FLStatus : 0 on success, otherwise failed                */
  852. /*----------------------------------------------------------------------*/
  854. #define flPhysicalErase(ioreq) flCall(FL_PHYSICAL_ERASE,ioreq)
  856. #endif /* LOW_LEVEL */
  858. /*----------------------------------------------------------------------*/
  859. /*                 f l D o n t W a t c h F A T                          */
  860. /*                                                                      */
  861. /* Turns off FAT monitoring.                                            */
  862. /*                                                                      */
  863. /* Parameters:                                                          */
  864. /*      irHandle        : Drive number (0, 1, ...)                      */
  865. /*                                                                      */
  866. /* Returns:                                                             */
  867. /*      FLStatus        : 0 on success, otherwise failed                */
  868. /*----------------------------------------------------------------------*/
  870. #define flDontMonitorFAT(ioreq)    flCall(FL_DONT_MONITOR_FAT,ioreq)
  873. /*----------------------------------------------------------------------*/
  874. /*             f l I n i t */
  875. /* */
  876. /* Initializes the FLite system, sockets and timers. */
  877. /* */
  878. /* Calling this function is optional. If it is not called, */
  879. /* initialization will be done automatically on the first FLite call. */
  880. /* This function is provided for those applications who want to */
  881. /* explicitly initialize the system and get an initialization status. */
  882. /* */
  883. /* Calling flInit after initialization was done has no effect. */
  884. /* */
  885. /* Parameters:                                                          */
  886. /* None */
  887. /*                                                                      */
  888. /* Returns:                                                             */
  889. /* FLStatus : 0 on success, otherwise failed                */
  890. /*----------------------------------------------------------------------*/
  892. extern FLStatus flInit(void);
  895. #ifdef EXIT
  897. /*----------------------------------------------------------------------*/
  898. /*             f l E x i t */
  899. /* */
  900. /* If the application ever exits, flExit should be called before exit.  */
  901. /* flExit flushes all buffers, closes all open files, powers down the   */
  902. /* sockets and removes the interval timer. */
  903. /*                                                                      */
  904. /* Parameters:                                                          */
  905. /* None */
  906. /*                                                                      */
  907. /* Returns:                                                             */
  908. /* Nothing */
  909. /*----------------------------------------------------------------------*/
  911. extern void flExit(void);
  913. #endif /* EXIT */
  915. #ifdef __cplusplus
  916. }
  917. #endif
  919. #endif