osslib.c

VxWorks下USB驱动的源代码！

/* ossLib.c - O/S-independent services for vxWorks */

/* Copyright 2000-2002 Wind River Systems, Inc. */

/*
Modification history
--------------------
01f,22jan02,wef  All USB memory now comes from a cacheDmaMalloc'd partition.  
		 Instrument routines to get partition information.
01e,25oct01,wef  changed ossMalloc to call memalign instead of malloc - it now
		 returns buffers that are a multiple of a cache line size 
		 aligned on a cache line boundary
01d,18sep01,wef  merge from wrs.tor2_0.usb1_1-f for veloce
01c,01aug01,rcb  fixed manpage generation in comments
01b,07mar00,rcb  Cast handles as necessary to reflect change in handle
		 definition from UINT32 to pVOID.
01a,07jun99,rcb  First.
*/

/*
DESCRIPTION

Implements functions defined by ossLib.h.  See ossLib.h for
a complete description of these functions.
*/


/* includes */

#include "vxWorks.h"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"

#include "errnoLib.h"           /* errno */
#include "sysLib.h"             /* sysClkRateGet(), etc. */
#include "taskLib.h"            /* taskSpawn(), etc. */
#include "semLib.h"             /* semCreate(), etc. */
#include "objLib.h"             /* S_objLib_OBJ_xxxx errors */
#include "tickLib.h"            /* tickGet(), etc. */
#include "cacheLib.h"           /* cacheDmaMalloc, Free */

#include "usb/usbPlatform.h"
#include "usb/ossLib.h"         /* Our API */


/* Defines */

                                /* #define  FILL_MEMORY *//* for debugging */


/* Definitions related to the creation of new threads. */

#define DEFAULT_OPTIONS     0   /* task options */
#define DEFAULT_STACK	    0x4000  /* Default stack size */


/* 
 * TIMEOUT() calculates the number of ticks for a timeout from a blockFlag
 * parameter to one of the ossLib functions.
 */

#define TIMEOUT(bf) (((bf) == OSS_BLOCK) ? \
    WAIT_FOREVER : ((bf) + msecsPerTick - 1) / msecsPerTick)

#define USB_MEM_PART_DEF_SIZE 0x10000   /* 0x10000  Default 
                                         * partition size - 64k 
                                         */

/* typedefs */

/* globals */

/* Default to using the partition method of malloc / free. */

FUNCPTR ossMallocFuncPtr;
FUNCPTR ossFreeFuncPtr;

/* locals */

LOCAL int msecsPerTick = 55;    /* milliseconds per system tick */

                    /* value updated by ossInitialize() */

LOCAL BOOL ossPartInitFlag = TRUE;

LOCAL char *pUsbMemSpace;

LOCAL PART_ID usbMemPartId;

LOCAL UINT32 usbMemPartSize = USB_MEM_PART_DEF_SIZE;

LOCAL UINT32 usbMemCount = 0;

LOCAL UINT32 ossOldInstallFlag = FALSE;

/* Functions */

/***************************************************************************
*
* translateError - translates vxWorks error to S_ossLib_xxxx
*
* Translates certain vxWorks errno values to an appropriate S_ossLib_xxxx.
* This function should only be invoked when the caller has already
* ascertained that a vxWorks function has returned an error.
*
* RETURNS: S_ossLib_xxxx
*
* ERRNO:
*  S_ossLib_BAD_HANDLE
*  S_ossLib_TIMEOUT
*  S_ossLib_GENERAL_FAULT
*/

LOCAL int
translateError (void)
{
    switch (errno) {
    case S_objLib_OBJ_ID_ERROR:
        return S_ossLib_BAD_HANDLE;
    case S_objLib_OBJ_TIMEOUT:
        return S_ossLib_TIMEOUT;
    default:
        return S_ossLib_GENERAL_FAULT;
    }
}


/***************************************************************************
*
* translatePriority - translates OSS_PRIORITY_xxx to vxWorks priority
*
* RETURNS: vxWorks task priority
*/

LOCAL int translatePriority (UINT16 priority)
{
    int curPriority;

    switch (priority) {
    case OSS_PRIORITY_LOW:
    case OSS_PRIORITY_TYPICAL:
    case OSS_PRIORITY_HIGH:
    case OSS_PRIORITY_INTERRUPT:

        return priority;

    case OSS_PRIORITY_INHERIT:
    default:

        taskPriorityGet (0, &curPriority);
        return curPriority;
    }
}


/***************************************************************************
*
* threadHead - vxWorks taskSpawn() compatible thread entry point
*
* ossThreadCreate() uses this intermediary function to spawn threads.  The
* vxWorks taskSpawn() function passes 10 int parameters to the task entry
* point.  By convention, ossThreadCreate passes the function's real entry
* point in <arg1> and the thread's <param> in <arg2>..
*/

LOCAL int threadHead (int arg1, /* <func> in this parameter */
                      int arg2, /* <param> in this parameter */
                      int arg3,
                      int arg4, int arg5, int arg6, int arg7, int arg8, int arg9, int arg10)
{
    THREAD_PROTOTYPE func = (THREAD_PROTOTYPE) arg1;
    pVOID param = (pVOID) arg2;

    (*func) (param);

    return 0;
}


/***************************************************************************
*
* ossStatus - Returns OK or ERROR and sets errno based on status
*
* If <status> & 0xffff is not equal to zero, then sets errno to the
* indicated <status> and returns ERROR.  Otherwise, does not set errno
* and returns OK.
*
* RETURNS: OK or ERROR
*/

STATUS ossStatus (int status)
{
    if ((status & 0xffff) != 0) {
        errnoSet (status);
        return ERROR;
    }

    return OK;
}



/***************************************************************************
*
* ossShutdown - Shuts down ossLib
*
* This function should be called once at system shutdown if an only if
* the corresponding call to ossInitialize() was successful.
*
* RETURNS: OK or ERROR
*/

STATUS
ossShutdown (void)
{
    return OK;
}


/***************************************************************************
*
* ossThreadCreate - Spawns a new thread
*
* The ossThreadCreate() function creates a new thread which begins execution 
* with the specified <func>.  The <param> argument will be passed to <func>.  
* The ossThreadCreate() function creates the new thread with a stack of a 
* default size and with no security restrictions - that is, there are no 
* restrictions on the use of the returned <pThreadHandle> by other threads.  
* The newly created thread will execute in the same address space as the 
* calling thread.  <priority> specifies the thread's desired priority - in
* systems which implement thread priorities, as OSS_PRIORITY_xxxx.  
*
* RETURNS: OK or ERROR
*
* ERRNO:
*  S_ossLib_BAD_PARAMETER
*  S_ossLib_GENERAL_FAULT
*/

STATUS ossThreadCreate (THREAD_PROTOTYPE func,  /* function to spawn as new thread */
                        pVOID param,    /* Parameter to be passed to new thread */
                        UINT16 priority,    /* OSS_PRIORITY_xxxx */
                        pCHAR name, /* thread name or NULL */
                        pTHREAD_HANDLE pThreadHandle    /* Handle of newly spawned thread */
    )
{
    /* validate params */

    if (pThreadHandle == NULL)
        return ossStatus (S_ossLib_BAD_PARAMETER);


    /* Use vxWorks to spawn a new thread (task in vxWorks parlance). */

    if ((*pThreadHandle = (THREAD_HANDLE) taskSpawn (name,
                                                     translatePriority (priority), DEFAULT_OPTIONS,
                                                     DEFAULT_STACK, threadHead, (int) func,
                                                     (int) param, 0, 0, 0, 0, 0, 0, 0,
                                                     0)) == (THREAD_HANDLE) ERROR)
        return ossStatus (S_ossLib_GENERAL_FAULT);

    return OK;
}


/***************************************************************************
*
* ossThreadDestroy - Attempts to destroy a thread
*
* This function attempts to destroy the thread specified by <threadHandle>.
*
* NOTE: Generally, this function should be called only after the given
* thread has terminated normally.  Destroying a running thread may result
* in a failure to release resources allocated by the thread.
*
* RETURNS: OK or ERROR
*
* ERRNO:
*  S_ossLib_GENERAL_FAULT
*/

STATUS ossThreadDestroy (THREAD_HANDLE threadHandle /* handle of thread to be destroyed */
    )
{
    if (taskDelete ((int) threadHandle) == ERROR)
        return ossStatus (S_ossLib_GENERAL_FAULT);

    return OK;
}


/***************************************************************************
*
* ossThreadSleep - Voluntarily relinquishes the CPU
*
* Threads may call ossThreadSleeph() to voluntarily release the CPU to
* another thread/process.  If the <msec> argument is 0, then the thread will
* be reschuled for execution as soon as possible.  If the <msec> argument is
* greater than 0, then the current thread will sleep for at least the number
* of milliseconds specified.
*
* RETURNS: OK or ERROR
*/

STATUS ossThreadSleep (UINT32 msec  /* Number of msec to sleep */
    )
{
    /* Delay for a number of ticks at least as long as the number of
       milliseconds requested by the caller. */

    taskDelay ((msec == 0) ? 0 : ((msec + msecsPerTick - 1) / msecsPerTick) + 1);

    return OK;
}


/***************************************************************************
*
* ossSemCreate - Creates a new semaphore
*
* This function creates a new semaphore and returns the handle of that
* semaphore in <pSemHandle>.  The semaphore's initial count is set to
* <curCount> and has a maximum count as specified by <maxCount>.
*
* RETURNS: OK or ERROR
* 
* ERRNO:
*  S_ossLib_BAD_PARAMETER
*  S_ossLib_GENERAL_FAULT
*/

STATUS ossSemCreate (UINT32 maxCount,   /* Max count allowed for semaphore */
                     UINT32 curCount,   /* initial count for semaphore */
                     pSEM_HANDLE pSemHandle /* newly created semaphore handle */
    )
{
    /* Validate parameters */

    if (pSemHandle == NULL)
        return ossStatus (S_ossLib_BAD_PARAMETER);

    if ((*pSemHandle = (SEM_HANDLE) semCCreate (SEM_Q_FIFO, curCount)) == NULL)
        return ossStatus (S_ossLib_GENERAL_FAULT);

    return OK;
}


/***************************************************************************
*
* ossSemDestroy - Destroys a semaphore
*
* Destroys the semaphore <semHandle> created by ossSemCreate().
*
* RETURNS: OK or ERROR
*
* ERRNO:
*  S_ossLib_GENERAL_FAULT
*/

STATUS ossSemDestroy (SEM_HANDLE semHandle  /* Handle of semaphore to destroy */
    )
{
    if (semDelete ((SEM_ID) semHandle) != OK)
        return ossStatus (S_ossLib_GENERAL_FAULT);

    return OK;
}


/***************************************************************************
*
* ossSemGive - Signals a semaphore
*
* This function signals the sepcified semaphore.  A semaphore may have more
* than one outstanding signal, as specified by the maxCount parameter when
* the semaphore was created by ossSemCreate().	While the semaphore is at its
* maximum count, additional calls to ossSemSignal for that semaphore have no
* effect.
*
* RETURNS: OK or ERROR
*
* ERRNO:
*  S_ossLib_BAD_HANDLE
*/

STATUS ossSemGive (SEM_HANDLE semHandle /* semaphore to signal */
    )
{
    if (semGive ((SEM_ID) semHandle) != OK)
        return ossStatus (S_ossLib_BAD_HANDLE);

    return OK;
}



/***************************************************************************
*
* ossSemTake - Attempts to take a semaphore
*
* ossSemTake() attempts to "take" the semaphore specified by <semHandle>.
* <blockFlag> specifies the blocking behavior.	OSS_BLOCK blocks indefinitely
* waiting for the semaphore to be signalled.  OSS_DONT_BLOCK does not block
* and returns an error if the semaphore is not in the signalled state.	Other
* values of <blockFlag> are interpreted as a count of milliseconds to wait
* for the semaphore to enter the signalled state before declaring an error.
*
* RETURNS: OK or ERROR
*/

STATUS ossSemTake (SEM_HANDLE semHandle,    /* semaphore to take */
                   UINT32 blockFlag /* specifies blocking action */
    )
{
    if (semTake ((SEM_ID) semHandle, TIMEOUT (blockFlag)) != OK)
        return ossStatus (translateError ());

    return OK;
}


/***************************************************************************
*
* ossMutexCreate - Creates a new mutex
*
* This function creates a new mutex and returns the handle of that
* mutex in <pMutexHandle>.  The mutex is created in the "untaken" state.
*
* RETURNS: OK or STATUS
*
* ERRNO:
*  S_ossLib_BAD_PARAMETER
*  S_ossLib_GENERAL_FAULT
*/

STATUS ossMutexCreate (pMUTEX_HANDLE pMutexHandle   /* Handle of newly created mutex */
    )
{

    /* Validate parameters */

    if (pMutexHandle == NULL)
        return ossStatus (S_ossLib_BAD_PARAMETER);

    if ((*pMutexHandle = (MUTEX_HANDLE) semMCreate (SEM_Q_FIFO)) == NULL)
        return ossStatus (S_ossLib_GENERAL_FAULT);

    return OK;
}


/***************************************************************************
*
* ossMutexDestroy - Destroys a mutex
*
* Destroys the mutex <mutexHandle> created by ossMutexCreate().
*
* RETURNS: OK or ERROR