293 lines
8.9 KiB
C
293 lines
8.9 KiB
C
/* flsystem.h - True Flash File System */
|
|
|
|
/*
|
|
* Copyright (c) 1984-2004, 2010 Wind River Systems, Inc.
|
|
*
|
|
* The right to copy, distribute or otherwise make use of this software
|
|
* may be licensed only pursuant to the terms of an applicable Wind River
|
|
* license agreement.
|
|
*/
|
|
|
|
/* FAT-FTL Lite Software Development Kit
|
|
* Copyright (C) M-Systems Ltd. 1995-1997 */
|
|
|
|
/*
|
|
modification history
|
|
--------------------
|
|
01b,29jul10,pad Moved extern C statement after include statements.
|
|
01a,29jul04,alr modified file header, restarted history
|
|
*/
|
|
|
|
#ifndef FLSYSTEM_H
|
|
#define FLSYSTEM_H
|
|
|
|
#include <vxWorks.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
#include <ctype.h>
|
|
#include <tickLib.h>
|
|
#include <wdLib.h>
|
|
#include <sysLib.h>
|
|
#include <excLib.h>
|
|
#include <semLib.h>
|
|
#include <ioLib.h>
|
|
#include <iosLib.h>
|
|
#include <memLib.h>
|
|
#include <errnoLib.h>
|
|
#include <vxLib.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/*
|
|
* signed/unsigned char
|
|
*
|
|
* It is assumed that 'char' is signed. If this is not your compiler
|
|
* default, use compiler switches, or insert a #pragma here to define this.
|
|
*
|
|
*/
|
|
|
|
/* char is signed by default in GNU C */
|
|
|
|
|
|
/* CPU target
|
|
*
|
|
* Use compiler switches or insert a #pragma here to select the CPU type
|
|
* you are targeting.
|
|
*
|
|
* If the target is an Intel 80386 or above, also uncomment the CPU_i386
|
|
* definition.
|
|
*/
|
|
|
|
/* defined in VxWorks makefile */
|
|
|
|
/* NULL constant
|
|
*
|
|
* Some compilers require a different definition for the NULL pointer
|
|
*/
|
|
|
|
/* #include <_null.h> */
|
|
|
|
|
|
/* Little-endian/big-endian
|
|
*
|
|
* FAT and FTL structures use the little-endian (Intel) format for integers.
|
|
* If your machine uses the big-endian (Motorola) format, uncomment the
|
|
* following line.
|
|
* This option needs a C++ compiler.
|
|
* Note that even on big-endian machines you may omit the BIG_ENDIAN
|
|
* definition for smaller code size and better performance, but your media
|
|
* will not be compatible with standard FAT and FTL.
|
|
*/
|
|
|
|
/* we are using VxWorks #define _BYTE_ORDER here */
|
|
#ifndef _BYTE_ORDER
|
|
#error "byte order is not defined"
|
|
#else /* _BYTE_ORDER */
|
|
#if (_BYTE_ORDER == _BIG_ENDIAN)
|
|
#define TFFS_BIG_ENDIAN
|
|
#else /* (_BYTE_ORDER == _BIG_ENDIAN) */
|
|
#undef TFFS_BIG_ENDIAN
|
|
#endif /* (_BYTE_ORDER == _BIG_ENDIAN) */
|
|
#endif /* _BYTE_ORDER */
|
|
|
|
|
|
/* Far pointers
|
|
*
|
|
* Specify here which pointers may be far, if any.
|
|
* Far pointers are usually relevant only to 80x86 architectures.
|
|
*
|
|
* Specify FAR_LEVEL:
|
|
* 0 - if using a flat memory model or having no far pointers.
|
|
* 1 - if only the socket window may be far
|
|
* 2 - if only the socket window and caller's read/write buffers
|
|
* may be far.
|
|
* 3 - if socket window, caller's read/write buffers and the
|
|
* caller's I/O request packet may be far
|
|
*/
|
|
|
|
#define FAR_LEVEL 0
|
|
|
|
|
|
/* Memory routines
|
|
*
|
|
* You need to supply library routines to copy, set and compare blocks of
|
|
* memory, internally and to/from callers. The code uses the names 'tffscpy',
|
|
* 'tffsset' and 'tffscmp' with parameters as in the standard 'memcpy',
|
|
* 'memset' and 'memcmp' C library routines.
|
|
*/
|
|
|
|
#if FAR_LEVEL > 0
|
|
#define tffscpy _fmemcpy
|
|
#define tffsset _fmemset
|
|
#define tffscmp _fmemcmp
|
|
#else
|
|
/* XXX
|
|
#define tffscpy sysTffsCpy
|
|
#define tffsset sysTffsSet
|
|
*/
|
|
#define tffscpy memcpy
|
|
#define tffsset memset
|
|
#define tffscmp memcmp
|
|
#endif
|
|
|
|
#define tffscpyWords(dest,src,nbytes) bcopyWords((char *)(src), \
|
|
(char *)(dest), (nbytes)/2)
|
|
#define tffscpyLongs(dest,src,nbytes) bcopyLongs((char *)(src), \
|
|
(char *)(dest), (nbytes)/4)
|
|
|
|
extern int tffscmpWords(void *buf1, void *buf2, int nbytes);
|
|
|
|
|
|
/* Pointer arithmetic
|
|
*
|
|
* The following macros define machine- and compiler-dependent macros for
|
|
* handling pointers to physical window addresses. The definitions below are
|
|
* for PC real-mode Borland-C.
|
|
*
|
|
* 'physicalToPointer' translates a physical flat address to a (far) pointer.
|
|
* Note that if when your processor uses virtual memory, the code should
|
|
* map the physical address to virtual memory, and return a pointer to that
|
|
* memory (the size parameter tells how much memory should be mapped).
|
|
*
|
|
* 'addToFarPointer' adds an increment to a pointer and returns a new
|
|
* pointer. The increment may be as large as your window size. The code
|
|
* below assumes that the increment may be larger than 64 KB and so performs
|
|
* huge pointer arithmetic.
|
|
*/
|
|
|
|
#if FAR_LEVEL > 0
|
|
#include <dos.h>
|
|
|
|
#define physicalToPointer(physical,size,drive) \
|
|
MK_FP((int) ((physical) >> 4),(int) (physical) & 0xF)
|
|
|
|
#define addToFarPointer(base,increment) \
|
|
MK_FP(FP_SEG(base) + \
|
|
((unsigned short) ((FP_OFF(base) + (increment)) >> 16) << 12), \
|
|
FP_OFF(base) + (int) (increment))
|
|
#else
|
|
#define physicalToPointer(physical,size,drive) \
|
|
((void *) (physical))
|
|
|
|
#define addToFarPointer(base,increment) \
|
|
((void *) ((unsigned char *) (base) + (increment)))
|
|
#endif
|
|
|
|
|
|
/* Default calling convention
|
|
*
|
|
* C compilers usually use the C calling convention to routines (cdecl), but
|
|
* often can also use the pascal calling convention, which is somewhat more
|
|
* economical in code size. Some compilers also have specialized calling
|
|
* conventions which may be suitable. Use compiler switches or insert a
|
|
* #pragma here to select your favorite calling convention.
|
|
*/
|
|
|
|
/* use GNU C default calling convention */
|
|
|
|
|
|
|
|
/* Mutex type
|
|
*
|
|
* If you intend to access the FLite API in a multi-tasking environment,
|
|
* you may need to implement some resource management and mutual-exclusion
|
|
* of FLite with mutex & semaphore services that are available to you. In
|
|
* this case, define here the Mutex type you will use, and provide your own
|
|
* implementation of the Mutex functions incustom.c
|
|
*
|
|
* By default, a Mutex is defined as a simple counter, and the Mutex
|
|
* functions in custom.c implement locking and unlocking by incrementing
|
|
* and decrementing the counter. This will work well on all single-tasking
|
|
* environment, as well as on many multi-tasking environments.
|
|
*/
|
|
|
|
typedef SEM_ID FLMutex;
|
|
|
|
#define flStartCriticalSection(mutexPtr) flTakeMutex(mutexPtr,1)
|
|
#define flEndCriticalSection(mutexPtr) flFreeMutex(mutexPtr)
|
|
|
|
|
|
|
|
/* Memory allocation
|
|
*
|
|
* The translation layers (e.g. FTL) need to allocate memory to handle
|
|
* Flash media. The size needed depends on the media being handled.
|
|
*
|
|
* You may choose to use the standard 'malloc' and 'free' to handle such
|
|
* memory allocations, provide your own equivalent routines, or you may
|
|
* choose not to define any memory allocation routine. In this case, the
|
|
* memory will be allocated statically at compile-time on the assumption of
|
|
* the largest media configuration you need to support. This is the simplest
|
|
* choice, but may cause your RAM requirements to be larger than you
|
|
* actually need.
|
|
*
|
|
* If you define routines other than malloc & free, they should have the
|
|
* same parameters and return types as malloc & free. You should either code
|
|
* these routines in custom.c or include them when you link your application.
|
|
*/
|
|
|
|
#define MALLOC_TFFS malloc
|
|
#define FREE_TFFS free
|
|
|
|
/* isRAM fault safe write
|
|
* The function isRAM() does a direct write to verify if the location
|
|
* specified is RAM. It is possible that hardware is tailered to fault
|
|
* in such situations.
|
|
*/
|
|
|
|
#ifdef ORIG
|
|
#define ISRAM_WRITE(src,dst) dst = src
|
|
#else /* !ORG */
|
|
#define ISRAM_WRITE(src,dst) \
|
|
vxMemProbe ((char *)dst, VX_WRITE, 4, (char *)&src)
|
|
#endif /* ORIG */
|
|
|
|
/* Pointer arithmetic
|
|
*
|
|
* The following macros define machine- and compiler-dependent macros for
|
|
* handling pointers to physical window addresses. The definitions below are
|
|
* for PC real-mode Borland-C.
|
|
*
|
|
* 'physicalToPointer' translates a physical flat address to a (far) pointer.
|
|
* Note that if when your processor uses virtual memory, the code should
|
|
* map the physical address to virtual memory, and return a pointer to that
|
|
* memory (the size parameter tells how much memory should be mapped).
|
|
*
|
|
* 'addToFarPointer' adds an increment to a pointer and returns a new
|
|
* pointer. The increment may be as large as your window size. The code
|
|
* below assumes that the increment may be larger than 64 KB and so performs
|
|
* huge pointer arithmetic.
|
|
*/
|
|
|
|
#if FAR_LEVEL > 0
|
|
#include <dos.h>
|
|
|
|
#define physicalToPointer(physical,size,drive) \
|
|
MK_FP((int) ((physical) >> 4),(int) (physical) & 0xF)
|
|
|
|
/*NEW*/ #define pointerToPhysical(ptr) \
|
|
(((unsigned long) FP_SEG(ptr) << 4) + FP_OFF(ptr))
|
|
|
|
#define addToFarPointer(base,increment) \
|
|
MK_FP(FP_SEG(base) + \
|
|
((unsigned short) ((FP_OFF(base) + (increment)) >> 16) << 12), \
|
|
FP_OFF(base) + (int) (increment))
|
|
#else
|
|
#define physicalToPointer(physical,size,drive) \
|
|
((void *) (physical))
|
|
|
|
/*NEW*/ #define pointerToPhysical(ptr) ((unsigned long)(ptr))
|
|
|
|
#define addToFarPointer(base,increment) \
|
|
((void *) ((unsigned char *) (base) + (increment)))
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#endif /* FLSYSTEM_H */
|