/*
* osapi.cpp
*
* Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
* All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 or BSD License which accompanies
* this distribution. The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name Texas Instruments nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/** \file osapi.cpp
* \brief Interface between the generic os abstration to symbian OSA
*
* \see
*/
#include "TIWhaDef.h"
#include "timerclient.h"
extern "C"
{
#include "tidef.h"
#include "cdebugoutput.h"
#include "osApi.h"
#define __FILE_ID__ FILE_ID_138
/****************************************************************************************
* OS Print API *
****************************************************************************************/
/**
* \fn os_setDebugMode
* \brief not in use
*
* \note
* \param
* \return
* \sa
*/
void os_setDebugMode (TI_BOOL enable)
{
}
/**
* \fn os_printf
* \brief Print formatted output
*
* \note
* \param format - Specifies the string, to be printed
* \return
* \sa
*/
#include <libc/stdarg.h>
extern "C" {void wlanPrintf(const char* const pPrefix, const char* const pFormat, va_list args);}
void os_printf (const char *format ,...)
{
#if _DEBUG
VA_LIST args;
VA_START(args, format);
wlanPrintf("TI_TRC: ", format, args);
VA_END(args);
#endif
}
/**
* \fn os_InterruptServiced
* \brief inform that interrupt was serviced (i.e. enable WLAN IRQ in LEVEL_IRQ)
*
* \param OsContext
* \return
* \sa
*/
void os_InterruptServiced (TI_HANDLE OsContext)
{
/* Mark that interrupt was serviced */
GET_HPA(OsContext)->InterruptServiced();
}
/****************************************************************************************
* OS Memory API *
****************************************************************************************/
/**
* \fn os_memoryAlloc
* \brief Allocates resident (nonpaged) system-space memory
*
* \note
* \param OsContext - os context.
* \param Size - Specifies the size, in bytes, to be allocated
* \return Pointer to the allocated memory.
NULL if there is insufficient memory available
* \sa
*/
void *os_memoryAlloc (TI_HANDLE OsContext,TI_UINT32 Size,TI_BOOL MemoryType)
{
#if defined DMA_CAPABLE_BUFFERS
MWlanOsa::TOsaMemoryType iOsMemType;
if (MemoryType == MemoryNormal)
{
iOsMemType = MWlanOsa::ENormalMemory;
}
else
{
iOsMemType = MWlanOsa::EInterconnectMemory;
}
return GET_OSA(OsContext)->Alloc(iOsMemType,Size,0);
#else
MWlanOsa::TOsaMemoryType iOsMemType = MWlanOsa::ENormalMemory;
return GET_OSA(OsContext)->Alloc(iOsMemType,Size,0);
#endif
}
/**
* \fn os_memorySet
* \brief This function fills a block of memory with given value
*
* \note
* \param OsContext - os context.
* \param pMemPtr - Specifies the base address of a block of memory
* \param Value - Specifies the value to set
* \param Length - Specifies the size, in bytes, to copy.
* \return
* \sa
*/
void os_memorySet (TI_HANDLE OsContext, void *pMemPtr, TI_INT32 Value, TI_UINT32 Length)
{
MWlanOsa::MemSet(pMemPtr,Value,Length);
}
/**
* \fn os_memoryZero
* \brief This function fills a block of memory with 0s.
*
* \note
* \param OsContext - os context.
* \param pMemPtr - Specifies the base address of a block of memory
* \param Length - Specifies how many bytes to fill with 0s.
* \return
* \sa
*/
void os_memoryZero (TI_HANDLE OsContext, void *pMemPtr, TI_UINT32 Length)
{
MWlanOsa::MemClr(pMemPtr,Length);
}
/**
* \fn os_memoryCopy
* \brief This function copies a specified number of bytes from one caller-supplied
location to another.
*
* \note
* \param OsContext - os context.
* \param pDstPtr - Destination buffer
* \param pSrcPtr - Source buffer
* \param Size - Specifies the size, in bytes, to copy.
* \return
* \sa
*/
void os_memoryCopy (TI_HANDLE pOsContext, void *pDestination, void *pSource, TI_UINT32 Size)
{
MWlanOsa::MemCpy(pDestination,(const void *)pSource,Size);
}
/**
* \fn os_memoryFree
* \brief This function releases a block of memory previously allocated with the
os_memoryAlloc function.
*
* \note
* \param OsContext - os context.
* \param pMemPtr - Pointer to the base virtual address of the allocated memory.
This address was returned by the os_memoryAlloc function.
* \param Size - Specifies the size, in bytes, of the memory block to be released.
This parameter must be identical to the Length that was passed to
os_memoryAlloc.
* \return
* \sa
*/
void os_memoryFree (TI_HANDLE pOsContext, void *pMemPtr, TI_UINT32 Size)
{
GET_OSA(pOsContext)->Free(pMemPtr);
}
/**
* \fn os_memoryCompare
*
* \note
* \return
* \sa
*/
TI_INT32 os_memoryCompare (TI_HANDLE OsContext, TI_UINT8* Buf1, TI_UINT8* Buf2, TI_INT32 Count)
{
return (TI_INT32)(MWlanOsa::MemCmp( Buf1, Buf2, Count ));
}
/**
* \fn os_timeStampMs
* \brief This function returns the number of milliseconds that have elapsed since
the system was booted.
*
* \note
* \param OsContext - os context.
* \return
* \sa
*/
TI_INT32 os_timeStampMs (TI_HANDLE OsContext)
{
TInt64 iTime;
iTime = MWlanOsa::Time() / 1000;
/* return only LSB */
return ((TUint32*)&iTime)[0];
}
/**
* \fn os_StalluSec
* \brief This function make delay in microseconds.
*
* \note
* \param OsContext - os context.
* \param uSec - delay time in microseconds
* \return
* \sa
*/
void os_StalluSec (TI_HANDLE OsContext, TI_UINT32 uSec)
{
MWlanOsa::BusyWait(uSec);
}
/*****************************************************************************************
* Timer functions *
*****************************************************************************************/
/**
* \fn os_timerCreate
* \brief Create timer client
*
* \param OsContext - os context.
* \param pRoutine - CB function
* \param hFuncHandle - CB handle
*
* \note
* \return Timer client handle
* \sa
*/
TI_HANDLE os_timerCreate (TI_HANDLE OsContext, fTimerFunction pRoutine, TI_HANDLE hFuncHandle)
{
return (TI_HANDLE)(new TimerClient (OsContext, pRoutine, hFuncHandle));
}
/**
* \fn os_timerDestroy
* \brief Destroy timer client
*
* \param OsContext - os context.
* \param TimerHandle - timer client handle
* \note
* \return
* \sa
*/
void os_timerDestroy (TI_HANDLE OsContext, TI_HANDLE TimerHandle)
{
if (TimerHandle)
{
delete (TimerClient *)TimerHandle;
}
}
/**
* \fn os_timerStart
* \brief start timer
*
* \param OsContext - os context.
* \param TimerHandle - timer client handle
* \param DelayMs
*
* \note
* \return
* \sa
*/
void os_timerStart (TI_HANDLE OsContext, TI_HANDLE TimerHandle, TI_UINT32 DelayMs)
{
((TimerClient *)TimerHandle)->Start(DelayMs);
}
/**
* \fn os_timerStop
* \brief stop timer
*
* \param OsContext - os context.
* \param TimerHandle - timer client handle
* \note
* \return
* \sa
*/
void os_timerStop (TI_HANDLE OsContext, TI_HANDLE TimerHandle)
{
((TimerClient *)TimerHandle)->Stop();
}
/****************************************************************************************
* Protection services API *
****************************************************************************************/
/**
* \fn os_protectCreate
* \brief
*
* \note
* \param OsContext - os context.
* \return A handle of the created mutex/spinlock.
TI_HANDLE_INVALID if there is insufficient memory available or problems
initializing the mutex
* \sa
*/
TI_HANDLE os_protectCreate (TI_HANDLE OsContext) { return TI_OK;}
/**
* \fn os_protectDestroy
* \brief the WVSS dose not use protection
*
* \note
* \param OsContext - os context.
* \return
* \sa
*/
void os_protectDestroy (TI_HANDLE OsContext, TI_HANDLE ProtectContext) {}
} //extern "C"