VxWorks

开发平台：
C/C++

tffsLib.c：源码内容
							/* tffsLib.c - TFFS FLite library for VxWorks. */
/* Copyright 1984-1997 Wind River Systems, Inc. */
#include "copyright_wrs.h"
/* FAT-FTL Lite Software Development Kit
 * Copyright (C) M-Systems Ltd. 1995-1997	*/
/*
modification history
--------------------
01f,13apr98,yp   made interval timer a task instead of exc task.(SPR #20693)
01e,06jan98,hdn  added INVERSION_SAFE to the mutex semaphore.
01d,17dec97,hdn  fixed a typo in return value at RETURNS:
01c,15dec97,yp   doc cleanup.
01b,07nov97,hdn  cleaned up.
01a,20mar96,ami  written by Amirban in M-Systems
*/
/*
DESCRIPTION
This library provides the OS binding to vxWorks for TFFS FLite .
INCLUDE FILES: 
*/
/* includes */
#include "flbase.h"
#include "tffsDrv.h"
#include "taskLib.h"
/* defines */
#if     (POLLING_INTERVAL > 0)
#define FL_POLL_TASK_PRIORITY 	100
#define FL_POLL_TASK_OPT 	0
#define FL_POLL_TASK_STACK_SIZE	2048
#endif /* (POLLING_INTERVAL > 0) */
/* externs */
#if	(POLLING_INTERVAL > 0)
IMPORT SEM_ID 	flPollSemId;
#endif	/* (POLLING_INTERVAL > 0) */
/* globals */
/* locals */
LOCAL int	flSysClkRate;	/* ticks per second       */
#if	(POLLING_INTERVAL > 0)
LOCAL int	flPollInterval;	/* socket polling interval in milliseconds */
LOCAL int	flPollTaskId;
#endif	/* (POLLING_INTERVAL > 0) */
/* forward declarations */
LOCAL void	flTimerInit (void);
#if	(POLLING_INTERVAL > 0)
LOCAL void	(*flSocketPollingRoutine) (void);
#endif	/* (POLLING_INTERVAL > 0) */
/*******************************************************************************
*
* flCreateMutex - create a mutex semaphore
*
* This translates a TFFS mutex create call to vxWorks.
*
* RETURNS: flOK, or flNotEnoughMemory if it fails.
*/
FLStatus flCreateMutex 
    (
    FLMutex * mutex	/* pointer to mutex */
    )
    {
    /* Io requests should be processed exactly in the same */
    /* sequence they are received                          */
    *mutex = semMCreate (SEM_DELETE_SAFE | SEM_INVERSION_SAFE | SEM_Q_PRIORITY);
    return ((*mutex != NULL) ? flOK : flNotEnoughMemory);
    }
/*******************************************************************************
*
* flTakeMutex - take a mutex semaphore
*
* This routine translates a mutex take call from TFFS to vxWorks.
*
* RETURNS: 0 if mutex not available otherwise returns 1.
*/
int flTakeMutex 
    (
    FLMutex * mutex,	/* pointer to mutex */
    int mode		/* 0 - nowait */
    )
    {
    STATUS status;
    status = semTake (*mutex, (mode == 0 ? NO_WAIT : WAIT_FOREVER));
    if (status == ERROR)
	return (0);
    else
        return (1);
    }
/*******************************************************************************
*
* flFreeMutex - release a mutex semaphore
*
* This routine translates a mutex release call from TFFS to vxWorks.
*
* RETURNS: N/A
*/
void flFreeMutex
    (
    FLMutex * mutex     /* pointer to mutex */
    )
    {
    semGive (*mutex);
    }
#ifdef EXIT
/*******************************************************************************
*
* flDeleteMutex - delete a mutex semaphore
*
* This routine translates a deletes mutex semaphore call from TFFS to vxWorks.
*
* RETURNS: N/A
*/
void flDeleteMutex
    (
    FLMutex * mutex     /* pointer to mutex */
    )
    {
    semDelete (*mutex);
    *mutex = NULL;
    }
#endif /* EXIT */
/*******************************************************************************
*
* flSysfunInit - initialize all the OS bindings
*
* This routine initializes all the OS bindings.
*
* RETURNS: N/A
*/
void flSysfunInit (void)
    {
    flTimerInit ();
    }
/*******************************************************************************
*
* flTimerInit - initialize timer for socket polling
*
* This routine initializes timer for socket polling.
*
* RETURNS: N/A
*/
static void flTimerInit (void)
    {
    flSysClkRate = sysClkRateGet ();
    }
#if	(POLLING_INTERVAL > 0)
/*******************************************************************************
*
* flPollTask - interval polling task
*
* This routine waits on the polling semaphore and invokes the interval
* timer work routine when the semaphore becomes available. The function 
* is not local so the task list on the shell can display the entry point.
*
* RETURNS: 
*/
void flPollTask (void)
    {
    int delay;
    semTake (flPollSemId, WAIT_FOREVER);
    delay = (flPollInterval * flSysClkRate )/1000;
    if (delay == 0)
        delay = 1;
    /* remove the polling semaphore */
    semDelete (flPollSemId);
    FOREVER
	{
	taskDelay (delay);
	(*flSocketPollingRoutine)();
	}
    }
/*******************************************************************************
*
* flInstallTimer - install the timer for socket polling
*
* This routine installs the timer used for socket polling.
*
* RETURNS: flOK, or flNotEnoughMemory if wdCreate() failed.
*/
FLStatus flInstallTimer 
    (
    void (*routine)(void),
    unsigned int intervalMsec
    )
    {
    flPollInterval         = intervalMsec;
    flSocketPollingRoutine = routine;
    /* Spawn the polling task */
    if ((flPollTaskId = taskSpawn ("tTffsPTask",
				  FL_POLL_TASK_PRIORITY,
				  FL_POLL_TASK_OPT,
				  FL_POLL_TASK_STACK_SIZE,
				  (FUNCPTR) flPollTask,0,0,0,0,0,0,0,0,0,0)) == ERROR)
        return (flNotEnoughMemory);
    return (flOK);
    }
#ifdef EXIT
/*******************************************************************************
*
* flRemoveTimer - cancel socket polling
*
* This routine cancels socket polling.
*
* RETURNS: N/A
*/
void flRemoveTimer (void)
    {
    /* Call it twice to shut down everything */
    (*flSocketPollingRoutine)();
    (*flSocketPollingRoutine)();
    /* remove socket polling */
    flSocketPollingRoutine = NULL;
    /* remove the polling task */
    taskDelete (flPollTaskId);
    }
#endif	/* EXIT */
#endif	/* POLLING_INTERVAL */
/*******************************************************************************
*
* flRandByte - return a random number from 0 to 255
*
* This routine returns a random number from 0 to 255.
*
* RETURNS: random number
*/
unsigned flRandByte (void)
    {
    /* XXX return (tickGet () & 0xff); */
    return (rand () & 0xff);
    }
/*******************************************************************************
*
* flCurrentTime - returns current time of day
*
* This routine Returns current time of day in the format described below.
*      bits  4 ..  0  - seconds
*      bits 10 ..  5  - minutes
*      bits 15 .. 11  - hours
*
* RETURNS: current time
*/
unsigned flCurrentTime (void)
    {
    unsigned char hour, minute, second;
    time_t        flAnsiTime;
    struct tm    *flLocalTimePtr;
    time (&flAnsiTime);
    flLocalTimePtr = localtime (&flAnsiTime);
    hour   = (unsigned char) flLocalTimePtr->tm_hour;
    minute = (unsigned char) flLocalTimePtr->tm_min;
    second = (unsigned char) flLocalTimePtr->tm_sec;
    return ((hour << 11) | (minute << 5) | second);
    }
/*******************************************************************************
*
* flCurrentDate - returns current date
*
* This routine Returns current date in the format described below.
*      bits  4 .. 0  - day
*      bits  8 .. 5  - month
*      bits 15 .. 9  - year (0 for 1980)
*
* RETURNS: current date
*/
unsigned flCurrentDate (void)
    {
    short int  year;
    char       month, day;
    struct tm *flLocalTimePtr;
    time_t     flAnsiTime;
    time (&flAnsiTime);
    flLocalTimePtr = localtime (&flAnsiTime);
    year  = (short int) (flLocalTimePtr->tm_year - 80);
    month = (char)       flLocalTimePtr->tm_mon + 1;
    day   = (char)       flLocalTimePtr->tm_mday;
    return ((year << 9) | (month << 5) | day);
    }
/*******************************************************************************
*
* flAddLongToFarPointer - add unsigned long offset to the far pointer
*
* This routine adds an unsigned long offset to a far pointer.
*
* RETURNS: far pointer
*/
void FAR0*  flAddLongToFarPointer
    (
    void FAR0 *ptr, 
    unsigned long offset
    )
    {
    return (physicalToPointer( pointerToPhysical(ptr) + offset, 0,0));
    }
#if	FALSE	/* moved to the BSP/sysTffs.c */
/*******************************************************************************
*
* flDelayMsecs - wait for specified number of milliseconds
*
* This routine waits for a specified number of milliseconds doing nothing.
*
* RETURNS: N/A
*/
void flDelayMsecs 
    (
    unsigned milliseconds	/* milliseconds to wait */
    )
    {
    unsigned long stop, ticksToWait;
    ticksToWait = (milliseconds * flSysClkRate) / 500;
    if (ticksToWait == 0x0l)
        ticksToWait++;
    stop = tickGet () + ticksToWait;
    while (tickGet () <= stop)
	;
    }
/*----------------------------------------------------------------------*/
/*                        f l D e l a y L o o p                         */
/*									*/
/* Short delay.                                                         */
/*                                                                      */
/* Parameters:                                                          */
/*      cycles          : wait loop cycles to perform                   */
/*----------------------------------------------------------------------*/
void flDelayLoop (int  cycles)     /* HOOK for VME-177 */
{
  while(--cycles) ; 
}
#endif	/* FLASE */

						