oslessoam.cpp

来自「SAMSUNG S3C6410 CPU BSP for winmobile6」· C++ 代码 · 共 746 行 · 第 1/3 页

OAM_Memset(VOID *pDst, UINT8 nV, UINT32 nLen)
{
#if defined(OAM_USE_STDLIB)
	memset(pDst, nV, nLen);
#else /* OAM_USE_STDLIB */

#if defined(OAM_32BIT_MEMCPY_OK)
	register UINT8	*pD8;
	register UINT32	*pD32;
	register UINT8	nV8 = nV;
	register UINT32	nV32 = (UINT32)( nV << 24 | nV << 16 | nV << 8 | nV ); 
	register INT32	nL = (INT32)nLen;
	register UINT32 nCnt;

	pD8 = (UINT8*)pDst;
	
	while ( (INT32)pDst % sizeof(UINT32) )
	{
		*pD8++ = nV8;
		nL--;

		if( nL <= 0 )
		    return;
	}
	
	pD32 = (UINT32*)pD8;
	for (nCnt = 0; nCnt <(INT32)(nL / sizeof(UINT32)); nCnt++)
		*pD32++ = nV32;

	pD8 = (UINT8*)pD32;	
	while( nL % sizeof(UINT32) )
	{
		*pD8++ = nV8;
		nL--;
	}
#else
	register UINT8	*pD8;
	register UINT16	*pD16;
	register UINT8	nV8 = nV;
	register UINT32	nV16 = (UINT16)( nV << 8 | nV ); 
	register INT32	nL = (INT32)nLen;
	register UINT32 nCnt;

	pD8 = (UINT8*)pDst;

	while ( (INT16)pDst % sizeof(UINT16) )
	{
		*pD8++ = nV8;
		nL--;

		if( nL <= 0 )
		    return;
	}

	pD16 = (UINT16*)pD8;
	for (nCnt = 0; nCnt <(INT32)(nL / sizeof(UINT16)); nCnt++)
		*pD16++ = nV16;

	pD8 = (UINT8*)pD16;	
	while( nL % sizeof(UINT16) )
	{
		*pD8++ = nV8;
		nL--;
	}
#endif	

#endif /* OAM_USE_STDLIB */
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*  OAM_Memcmp                                                               */
/* DESCRIPTION                                                               */
/*      This function compare data of two buffer.                            */
/*                                                                           */
/* PARAMETERS                                                                */
/*  pSrc        Source data allocated Pointer                                */
/*  pDst        Destination array Pointer to be compared                     */
/*  nLen        length to be compared                                        */
/*                                                                           */
/* RETURN VALUES                                                             */
/*      none                                                                 */
/*                                                                           */
/* NOTES                                                                     */
/*      This function is called by function that wants to compare source     */
/*  buffer and destination buffer.                                           */
/*                                                                           */
/*****************************************************************************/
INT32
OAM_Memcmp(VOID  *pSrc, VOID  *pDst, UINT32 nLen)
{
#if defined(OAM_USE_STDLIB)
	return memcmp(pSrc, pDst, nLen);
#else /* OAM_USE_STDLIB */
	UINT8 *pS1 = (UINT8 *)pSrc;
	UINT8 *pD1 = (UINT8 *)pDst;

	while (nLen--)
	{
		if (*pS1 != *pD1)
			return (*pS1 - *pD1);
        pS1++;
        pD1++;
	}

	return 0;
#endif /* OAM_USE_STDLIB */
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*  OAM_CreateSM                                                             */
/* DESCRIPTION                                                               */
/*      This function creates semaphore.                                     */
/*                                                                           */
/* PARAMETERS                                                                */
/*  pHandle        Handle of semaphore                                       */
/*                                                                           */
/* RETURN VALUES                                                             */
/*      If this function creates semaphore successfully, it returns TRUE32.  */
/*      else it returns FALSE32.                                             */
/* NOTES                                                                     */
/*      This function is called by function that wants to create semaphore   */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/
BOOL32
OAM_CreateSM(SM32 *pHandle)
{
	return TRUE32;
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*  OAM_DestroySM                                                            */
/* DESCRIPTION                                                               */
/*      This function destroys semaphore.                                    */
/*                                                                           */
/* PARAMETERS                                                                */
/*  nHandle        Handle of semaphore to be destroyed                       */
/*                                                                           */
/* RETURN VALUES                                                             */
/*      If this function destroys semaphore successfully, it returns TRUE32. */
/*      else it returns FALSE32.                                             */
/* NOTES                                                                     */
/*      This function is called by function that wants to destroy semaphore  */
/*                                                                           */
/*****************************************************************************/
BOOL32
OAM_DestroySM(SM32 nHandle)
{
	return TRUE32;
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*  OAM_AcquireSM                                                            */
/* DESCRIPTION                                                               */
/*      This function acquires semaphore.                                    */
/*                                                                           */
/* PARAMETERS                                                                */
/*  nHandle        Handle of semaphore to be acquired                        */
/*                                                                           */
/* RETURN VALUES                                                             */
/*      If this function acquires semaphore successfully, it returns TRUE32. */
/*      else it returns FALSE32.                                             */
/* NOTES                                                                     */
/*      This function is called by function that wants to acquire semaphore  */
/*                                                                           */
/*****************************************************************************/
BOOL32
OAM_AcquireSM(SM32 nHandle)
{
	return TRUE32;
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*  OAM_ReleaseSM                                                            */
/* DESCRIPTION                                                               */
/*      This function releases semaphore.                                    */
/*                                                                           */
/* PARAMETERS                                                                */
/*      nHandle    [IN]                                                      */
/*            Handle of semaphore to be released                             */
/*                                                                           */
/* RETURN VALUES                                                             */
/*      If this function releases semaphore successfully, it returns TRUE32. */
/*      else it returns FALSE32.                                             */
/* NOTES                                                                     */
/*      This function is called by function that wants to release semaphore  */
/*                                                                           */
/*****************************************************************************/
BOOL32
OAM_ReleaseSM(SM32 nHandle)
{
	return TRUE32;
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*  OAM_Pa2Va                                                                */
/* DESCRIPTION                                                               */
/*      This function gets virtual address for NAND device physical address  */
/*                                                                           */
/* PARAMETERS                                                                */
/*  nPAddr        physical address of NAND device                            */
/*                                                                           */
/* RETURN VALUES                                                             */
/*      Virtual address of NAND device that Symbian OS using                 */
/*                                                                           */
/* NOTES                                                                     */
/*      This function makes virtual address for NAND device when system      */
/*  initialized                                                              */
/*                                                                           */
/*****************************************************************************/
UINT32
OAM_Pa2Va(UINT32 nPAddr)
{
    return (nPAddr);
}

/*****************************************************************************/
/*                                                                           */
/* NAME                                                                      */
/*  OAM_InitInt                                                              */
/* DESCRIPTION                                                               */
/*      This function initialize interrupt for NAND device                   */
/*                                                                           */
/* PARAMETERS                                                                */
/*  Caller        Class that this function called                            */
/*                                                                           */
/* RETURN VALUES                                                             */
/*      none                                                                 */
/*                                                                           */
/* NOTES                                                                     */
/*      This function is called in Media driver interface layer              */
/*                                                                           */
/*                                                                           */
/*****************************************************************************/

VOID
OAM_InitInt(VOID *Caller)