📄 msgqf.c

📁 samsung 9908DVD源代码,
💻 C
字号:
/**********************************************************************************
 * msgQF.c
 * coded by hspark@ce.cnu.ac.kr
 * date : 2001/06/23
 * modified by hjahn@ce.cnu.ac.kr
 * date : 2003/03/03
 **********************************************************************************/

#include "kernel\\mk_sys.h"
#include "kernel\\mk_sem.h"
#include "kernel\\mk_mem.h"
#include "kernel\\mk_msgQF.h"
#include "kernel\\mk_task.h"
#include "util\\mk_lib.h"

#ifdef _MK_MSGQUEUE

VOID
MK_FixedMsgQueueInitialze(VOID)
{
}

STATUS
MK_CreateFixedMsgQueue(MK_FIXED_QUEUE *pQueue, CHAR *pName, VOID *pAddr, INT Count,
					   ULONG Size, BOOLEAN Options)
{	
	STATUS	Status;
	INT		Flags;

	if(pQueue->fq_Magic == MK_MSGQF_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_CreateFixedMsgQueue() - Magic error!\n");
#endif
		return MK_ERROR;
	}
	
	Flags = MK_InterruptDisable();

	pQueue->fq_pMsgListHead = MK_NULL;
	pQueue->fq_pMsgListTail = MK_NULL;

	Status = MK_CreateBufferPool(&pQueue->fq_Pool, MK_NULL, pAddr, Count, Size+sizeof(MK_FIXED_QUEUE_MSG), Options);
	if(Status < 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_CreateFixedMsgQueue() - BufferPool is not created! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		MK_InterruptRestore( Flags );
		return Status;
	}

	Status = MK_CreateSemaphore(&pQueue->fq_ReceiveSemaphore, MK_NULL, 0, Options);
	if(Status < 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_CreateFixedMsgQueue() - Receive semaphore is not created! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		MK_InterruptRestore( Flags );
		return Status;
	}

	pQueue->fq_Magic = MK_MSGQF_MAGIC;

	MK_InterruptRestore( Flags );
	return MK_NO_ERROR;
}

ULONG
MK_GetFixedMsgQueueNeededSize(ULONG	MsgCount, ULONG Size)
{
	return MK_GetPoolNeededSize(MsgCount, (ULONG)(Size + sizeof(MK_FIXED_QUEUE_MSG)) );
}

ULONG 
MK_GetFixedMsgQueueAvailableBufferSize(MK_FIXED_QUEUE *pQueue)
{
	if(pQueue->fq_Magic != MK_MSGQF_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_GetFixedMsgQueueAvailableBufferSize() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return 0;
	}


	return MK_GetPoolBufferSize(&pQueue->fq_Pool) - sizeof(MK_FIXED_QUEUE_MSG);
}

INT 
MK_GetFixedMsgQueueMsgCount(MK_FIXED_QUEUE *pQueue)
{
	if(pQueue->fq_Magic != MK_MSGQF_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_GetFixedMsgQueueNsgCount() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return 0;
	}

	return MK_GetSemaphoreCount(&pQueue->fq_ReceiveSemaphore);
	
}

STATUS
MK_DeleteFixedMsgQueue(MK_FIXED_QUEUE *pQueue)
{
	INT Flags;

	if(pQueue->fq_Magic != MK_MSGQF_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_DeleteFixedMsgQueue() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}

	Flags = MK_InterruptDisable();

	MK_DeleteBufferPool(&pQueue->fq_Pool);
	MK_DeleteSemaphore(&pQueue->fq_ReceiveSemaphore);
	pQueue->fq_Magic = 0;

	MK_InterruptRestore( Flags );
	return MK_NO_ERROR;
}

STATUS
MK_FixedMsgQueuePend(MK_FIXED_QUEUE *pQueue, VOID *pMsg, ULONG BufSize,
					 ULONG *pLength, LONG Ticks)
{
	MK_FIXED_QUEUE_MSG *pQueueMsg;
	STATUS Status;
	INT Flags;

	if(pQueue->fq_Magic != MK_MSGQF_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_FixedMsgQueuePend() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}
	
	Flags = MK_InterruptDisable();			/* Critical Region */

	if((pQueue->fq_pMsgListHead == MK_NULL) && (pQueue->fq_ReceiveSemaphore.s_Count>0))
	*pLength = 0;
	Status = MK_SemaphorePend(&pQueue->fq_ReceiveSemaphore, Ticks);

	if( Status < 0)
	{
		*(CHAR *)(pMsg) = 0;
		*pLength = 0;
		
#if MK_DEBUG_PRINT
		//MK_InfoPrintf(MK_TASK_WARNING, "MK_FixedMsgQueuePend() - SemaphorePend result is timeout! Queue(%s)\n", pQueue->fq_Pool.bp_pName);
#endif
		MK_InterruptRestore(Flags);
		return Status;
	}

	if(pQueue->fq_pMsgListHead == MK_NULL)
	*pLength = 0;
	if(pQueue->fq_pMsgListHead == pQueue->fq_pMsgListTail)
	{
		pQueueMsg = pQueue->fq_pMsgListHead;
		pQueue->fq_pMsgListHead = MK_NULL;
		pQueue->fq_pMsgListTail = MK_NULL;
		pQueueMsg->fm_pNext = MK_NULL;
	}
	else
	{
		pQueueMsg = pQueue->fq_pMsgListHead;
		pQueue->fq_pMsgListHead = pQueueMsg->fm_pNext;
		pQueueMsg->fm_pNext = MK_NULL;
	}

	*pLength = (pQueueMsg->fm_Length <= BufSize) ? pQueueMsg->fm_Length : BufSize;
	MK_BlockCopy((CHAR *)(pMsg), (CHAR *)pQueueMsg->fm_StartOfMsg, *pLength);
	
	Status = MK_FreeBuf((VOID *)pQueueMsg);

	MK_InterruptRestore(Flags);
	return Status;
}

STATUS
MK_FixedMsgQueuePost(MK_FIXED_QUEUE *pQueue, VOID *pMsg, ULONG Length, LONG Ticks)
{
	MK_FIXED_QUEUE_MSG *pQueueMsg;
	STATUS Status;
	VOID	*pAddr;
	ULONG	MaxLength;
	ULONG	PoolLength;
	INT		Flags;

	if(pQueue->fq_Magic != MK_MSGQF_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_FixedMsgQueuePost() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}

	if(Length ==0 )
	{
#if MK_DEBUG_PRINT
		//MK_InfoPrintf(MK_TASK_WARNING, "MK_FixedMsgQueuePost() - Length must be great than zero! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_ERROR;
	}

	Flags = MK_InterruptDisable();		/* Critical Region */

	Status = MK_GetBuf(&pQueue->fq_Pool, &pAddr, Ticks);

	if( Status < 0)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_FixedMsgQueuePost() - MsgQueue is not allocated buffer in buffer pool! Queue(%s)\n", pQueue->fq_Pool.bp_pName);
#endif
		MK_InterruptRestore(Flags);
		return MK_QUEUE_FULL;
	}

	pQueueMsg = (MK_FIXED_QUEUE_MSG *)pAddr;
	pQueueMsg->fm_StartOfMsg = (ULONG)pQueueMsg + sizeof(MK_FIXED_QUEUE_MSG);
	
	PoolLength = MK_GetPoolBufferSize(&pQueue->fq_Pool) - sizeof(MK_FIXED_QUEUE_MSG);
	MaxLength = ( Length <= PoolLength ) ? Length : PoolLength;
	
	MK_BlockCopy((CHAR *)pQueueMsg->fm_StartOfMsg, (CHAR *)pMsg, MaxLength);

	pQueueMsg->fm_Length = MaxLength;
	pQueueMsg->fm_pNext = MK_NULL;

	if(pQueue->fq_pMsgListHead == MK_NULL)
	{
		pQueue->fq_pMsgListHead = pQueueMsg;
		pQueue->fq_pMsgListTail = pQueueMsg;
		
	}
	else
	{
		pQueue->fq_pMsgListTail->fm_pNext = pQueueMsg;
		pQueue->fq_pMsgListTail = pQueueMsg;
		pQueueMsg->fm_pNext = MK_NULL;
	}

	Status = MK_SemaphorePost(&pQueue->fq_ReceiveSemaphore); 

	MK_InterruptRestore(Flags);
	return Status;
}

STATUS
MK_FixedMsgQueueFrontPost(MK_FIXED_QUEUE *pQueue, VOID *pMsg, ULONG Length, LONG Ticks)
{
	MK_FIXED_QUEUE_MSG *pQueueMsg;
	STATUS	Status;
	VOID	*pAddr;
	ULONG	MaxLength;
	ULONG	PoolLength;
	INT Flags;

	if(pQueue->fq_Magic != MK_MSGQF_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_FixedMsgQueuePost() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}
	if(Length ==0 )
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_FixedMsgQueuePost() - Length must be great than zero! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_ERROR;
	}

	Flags = MK_InterruptDisable();		/* Critical Region */

	Status = MK_GetBuf(&pQueue->fq_Pool, &pAddr, Ticks);
	if( Status < 0)
	{
		MK_InterruptRestore(Flags);

#if MK_DEBUG_PRINT		
		MK_InfoPrintf(MK_TASK_WARNING, "MK_FixedMsgQueuePost() - MsgQueue is not allocated buffer in buffer pool! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_QUEUE_FULL;
	}

	pQueueMsg = (MK_FIXED_QUEUE_MSG *)pAddr;
	pQueueMsg->fm_StartOfMsg = (ULONG)pQueueMsg + sizeof(MK_FIXED_QUEUE_MSG);
	
	PoolLength = MK_GetPoolBufferSize(&pQueue->fq_Pool);
	MaxLength = ( Length <= PoolLength ) ? Length : PoolLength;
	

	MK_BlockCopy((CHAR *)pQueueMsg->fm_StartOfMsg, (CHAR *)pMsg, MaxLength);
	
	pQueueMsg->fm_Length = MaxLength;
	pQueueMsg->fm_pNext = MK_NULL;

	if(pQueue->fq_pMsgListHead == MK_NULL)
	{
		pQueue->fq_pMsgListHead = pQueueMsg;
		pQueue->fq_pMsgListTail = pQueueMsg;
		
	}
	else
	{
		pQueueMsg->fm_pNext = pQueue->fq_pMsgListHead;
		pQueue->fq_pMsgListHead = pQueueMsg;
	}

	Status = MK_SemaphorePost(&pQueue->fq_ReceiveSemaphore); 

	MK_InterruptRestore(Flags);
	return Status;
}

/* not implemented - only MK_FixedMsgQueuePost */
STATUS
MK_FixedMsgQueueBroadcastPost(MK_FIXED_QUEUE *pQueue, VOID *pMsg, ULONG Length, LONG Ticks)
{
	MK_FIXED_QUEUE_MSG *pQueueMsg;
	STATUS	Status;
	VOID	*pAddr;
	ULONG	MaxLength;
	ULONG	PoolLength;
	INT		SuspendTasks;
	INT		Flags;

	if(pQueue->fq_Magic != MK_MSGQF_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_FixedMsgQueuePost() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}

	if(Length ==0 )
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_FixedMsgQueuePost() - Length must be great than zero! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_ERROR;
	}

	Flags = MK_InterruptDisable();		/* Critical Region */

	SuspendTasks = MK_GetFixedMsgQueueMsgCount(pQueue);
	if( SuspendTasks  >= 0)
	{
		Status = MK_GetBuf(&pQueue->fq_Pool, &pAddr, Ticks);
		if( Status < 0)
		{
			MK_InterruptRestore(Flags);
		
#if MK_DEBUG_PRINT
			MK_InfoPrintf(MK_TASK_WARNING, "MK_FixedMsgQueuePost() - MsgQueue is not allocated buffer in buffer pool! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
			return MK_QUEUE_FULL;
		}

		pQueueMsg = (MK_FIXED_QUEUE_MSG *)pAddr;
		pQueueMsg->fm_StartOfMsg = (ULONG)pQueueMsg + sizeof(MK_FIXED_QUEUE_MSG);
		
		PoolLength = MK_GetPoolBufferSize(&pQueue->fq_Pool);
		MaxLength = ( Length <= PoolLength ) ? Length : PoolLength;
		

		MK_BlockCopy((CHAR *)pQueueMsg->fm_StartOfMsg, (CHAR *)pMsg, MaxLength);
		
		pQueueMsg->fm_Length = MaxLength;
		pQueueMsg->fm_pNext = MK_NULL;

		if(pQueue->fq_pMsgListHead == MK_NULL)
		{
			pQueue->fq_pMsgListHead = pQueueMsg;
			pQueue->fq_pMsgListTail = pQueueMsg;
			
		}
		else
		{
			pQueueMsg->fm_pNext = pQueue->fq_pMsgListHead;
			pQueue->fq_pMsgListHead = pQueueMsg;
		}

		Status = MK_SemaphorePost(&pQueue->fq_ReceiveSemaphore);
		MK_InterruptRestore(Flags);
		return Status;
	}
	else
	{
		do {
			MK_FixedMsgQueuePost(pQueue, pMsg, Length, Ticks);
		} while( SuspendTasks++ < 0);
		
		MK_InterruptRestore(Flags);
		return MK_NO_ERROR;
	}
}

STATUS
MK_FixedMsgQueueReset(MK_FIXED_QUEUE *pQueue)
{
	STATUS status;
	INT		Flags;

	Flags = MK_InterruptDisable();

	pQueue->fq_pMsgListHead = MK_NULL;
	pQueue->fq_pMsgListTail = MK_NULL;
	status = MK_ResetBufferPool(&pQueue->fq_Pool);
	status = MK_SemaphoreReset(&pQueue->fq_ReceiveSemaphore, 0);

	MK_Schedule();

	MK_InterruptRestore( Flags );

	return status;
}

#endif	/* #ifdef _MK_MSGQUEUE */
💿 文件大小 3046 K
👤 上传用户 koalalee
📂 所属分类微处理器开发
🏷️ 相关标签

#samsung #9908 #DVD #源代码
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -