flsysvxw.c

DOC文件系统驱动源代码

/*
 * $Log:   V:/Flite/archives/OSAK/examples/drivers/VxWorks/systems/flsysvxw.c_V  $
 * 
 *    Rev 1.10   16 May 2003 20:02:44   andrayk
 * TrueFFS-5.1.4
 * 
 *    Rev 1.9   Jun 20 2001 19:56:28   oris
 * minor change to copyright statement
 * 
 *    Rev 1.8   17 May 2001 02:33:14   andreyk
 * bug fixes in osak-5
 * 
 *    Rev 1.7   19 Feb 2001 20:48:04   andreyk
 * dosFs-2 support added
 * 
 *    Rev 1.6   Aug 16 2000 14:39:00   vadimk
 * 32-bit bug fixed in flset()
 * 
 *    Rev 1.5   May 28 2000 11:15:46   vadimk
 * OSAK-4.1 with IOCTL support
 * 
 *    Rev 1.4   Apr 27 2000 11:44:32   vadimk
 * add 32-bit stdmemcpy,cmp,set routines
 * 
 *    Rev 1.3   Mar 08 2000 11:49:02   veredg
 * OSAK-4.1/VxWorks
 *
 *    Rev 1.2   Jul 21 1999 15:22:02   Administrator
 * OSAK-121 based driver
 *
 *    Rev 1.0   25 Aug 1997 12:06:28   ANDRY
 * 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 = [e-mail]                                                * 
 *                                                                             * 
 ******************************************************************************* 
 *                                                                             * 
 *                         Module: FLSYSVXW                                    * 
 *                                                                             * 
 *  This module implements VxWorks-to-TFFS bindings.                           *
 *                                                                             * 
 *******************************************************************************/




#include "flbase.h"
#include "fldrvvxw.h"




/*
 * configuration
 */

/* #define FL_SYS_MEM_CORRUPTION */    /* enable to catch heap corruption */




/*
 * extern
 */

extern unsigned char  flDelay;




/*
 * static data
 */

static int  flSysClkRate;             /* BSP's ticks-per-second setting */

static char * dbgLog     = NULL;
static char * dbgCurrent = NULL;

#ifdef FL_SYS_MEM_CORRUPTION

#define  FL_SYS_SENTINEL_STR_LEN  32
 
static char const sentinelStr[FL_SYS_SENTINEL_STR_LEN + 1] = 
                              "M-SystemsDynamicMemoryAllocation";
#endif




/* ---------------------------------------------------------------------- * 
 *                                                                        * 
 *               f l S y s f u n I n i t                                  *
 *                                                                        *
 * Called from flInit().                                                  *
 *                                                                        *
 * ---------------------------------------------------------------------- */

void  flSysfunInit ( void )
{
    /* obtain BSP's ticks-per-second setting */

    flSysClkRate = sysClkRateGet ();
}




/* ---------------------------------------------------------------------- * 
 *                                                                        * 
 *                 f l R a n d B y t e                                    * 
 *                                                                        * 
 * Generate random value in range 0..255.                                 * 
 *                                                                        * 
 * Returns:                                                               * 
 *                                                                        * 
 *      random value in range 0..255                                      * 
 *                                                                        * 
 * ---------------------------------------------------------------------- */

unsigned  flRandByte ( void )
{
    return (unsigned) (tickGet() & 0xff);
}




/* ---------------------------------------------------------------------- * 
 *                                                                        * 
 *                 f l A d d L o n g T o F a r P o i n t e r              * 
 *                                                                        * 
 * Add unsigned long offset to the far pointer                            * 
 *                                                                        * 
 * Parameters:                                                            * 
 *      ptr             : far pointer                                     * 
 *      offset          : offset in bytes                                 * 
 *                                                                        * 
 * ---------------------------------------------------------------------- */

void FAR0 * flAddLongToFarPointer ( void FAR0 *    ptr, 
                                    unsigned long  offset )
{
    return  ((char FAR0 *)ptr + ((int) offset));
}




/* ---------------------------------------------------------------------- * 
 *                                                                        * 
 *              f l D e l a y M s e c s                                   * 
 *                                                                        * 
 * Spin for specified number of milliseconds                              * 
 *                                                                        * 
 * Parameters:                                                            * 
 *                                                                        * 
 *      millisec    : Number of milliseconds to spin                      * 
 *                                                                        * 
 * ---------------------------------------------------------------------- */

void  doc_flDelayMsecs ( unsigned  millisec )
{
    register unsigned long  ticks;

    ticks = (unsigned long) ((millisec * flSysClkRate) / 500);

    if (ticks == (unsigned long)0)
        ticks++;

    ticks += tickGet ();

    /* spin specified number of milliseconds */

    while( tickGet() <= ticks )
        ;
}




/* ---------------------------------------------------------------------- * 
 *                                                                        * 
 *                 f l s l e e p                                          * 
 *                                                                        * 
 * This routine should be called during the flash erase operation to      * 
 * yield the CPU for a 'msec' milliseconds.                               * 
 *                                                                        * 
 * Parameters:                                                            * 
 *                                                                        * 
 *      millisec    : Number of milliseconds to sleep                     * 
 *                                                                        * 
 * ---------------------------------------------------------------------- */

void  flsleep ( unsigned long  millisec )
{
    register int  ticks;

    if (flDelay) {

        /* covert millisec to clock ticks */

        ticks = (((int)millisec * flSysClkRate) / 1000);

        if (ticks <= 0)
            ticks = 1;

        /* yield CPU */

        taskDelay (ticks);
    }
}




/* ---------------------------------------------------------------------- * 
 *                                                                        * 
 *                   f l m e m c p y                                      * 
 *                                                                        * 
 * 8-bit 'memcopy' routine.                                               * 
 *                                                                        * 
 * Parameters:                                                            * 
 *                                                                        * 
 *      dest            : pointer to the destination buffer               * 
 *      src             : pointer to the source buffer                    * 
 *      size            : number of bytes to copy                         * 
 *                                                                        * 
 * Returns:                                                               * 
 *                                                                        * 
 *      arguement 'dest'                                                  * 
 *                                                                        * 
 * ---------------------------------------------------------------------- */

void FAR0 *  flmemcpy ( void FAR0       * dest, 
                        const void FAR0 * src, 
                        size_t            count )
{
    register size_t  i;

    for (i = 0;  i < count;  i++)
        *((unsigned char FAR0 *)dest + i) = *((const unsigned char FAR0*)src + i);

    return dest;
}