/* 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #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 #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 #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 */