pNext = pPrev->mb_pNext;
	
	for(; pNext!=MK_NULL && (ULONG)pNext<(ULONG)pAddr; pPrev=pNext,pNext=pNext->mb_pNext) 
	{
		; 
	}
	Top = pPrev->mb_Size + (ULONG)pPrev;
	

	if(Top > (ULONG)pAddr || (pNext != MK_NULL && 
		( (ULONG)pAddr - sizeof(MK_MBLOCK_DUMMY) + AllocSize ) > (ULONG)pNext) )
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_FreeMemoryInternal() - Memory address get out of range ! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		MK_InterruptRestore(Flags);
		return MK_ERROR;
	}

	pMBlock = (MK_MBLOCK *)( (ULONG)pAddr - sizeof(MK_MBLOCK_DUMMY) );
	pMBlock->mb_Size = AllocSize;
	pMBlock->mb_pNext = pNext;
	pMBlock->mb_Magic = (ULONG)pHeap;

	if( (ULONG)(pMBlock->mb_Size + (ULONG)pMBlock) == (ULONG)pNext)
	{
		pMBlock->mb_Size += pNext->mb_Size;
		*pMergedSize = pMBlock->mb_Size;
		pMBlock->mb_pNext = pNext->mb_pNext;
		//pNext->mb_Magic = 0;		/* for Error Detect */
	}

	if( Top == (ULONG)pAddr - sizeof(MK_MBLOCK_DUMMY) )
	{
		/* Merge with Previos Memory Block */
		pPrev->mb_Size += pMBlock->mb_Size;
		pPrev->mb_pNext = pMBlock->mb_pNext;
		*pMergedSize += pPrev->mb_Size;
	}
	else
	{
		pPrev->mb_pNext = pMBlock;
		*pMergedSize = pMBlock->mb_Size;
	}

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}


STATUS
MK_FreeMemory(VOID *pAddr)
{
	MK_HEAP	*pHeap;
	MK_MBLOCK_DUMMY *pInfo;
	MK_TASK	*pTask;
	ULONG	AllocSize;
	ULONG	MergedSize;
	STATUS	Status;
	INT		Flags;

	if(pAddr == MK_NULL)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_ERROR, "MK_FreeMemory() - You must not be free memory because memory is not allocated! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_ERROR;
	}


	pInfo = (MK_MBLOCK_DUMMY *)( (ULONG)pAddr - sizeof(MK_MBLOCK_DUMMY) );
	pHeap = (MK_HEAP *)pInfo->md_pHeap;
	AllocSize = pInfo->md_Size;

	if(pHeap->h_Magic != MK_HEAP_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_FreeMemory() - Magic Error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}

	if((ULONG)pAddr < pHeap->h_StartofHeap || 
		(ULONG)pAddr >= pHeap->h_StartofHeap + pHeap->h_HeapSize)
	{
#if MK_DEBUG_PRINT
		MK_InfoPrintf(MK_TASK_WARNING, "MK_FreeMemory() - Memory address get out of range ! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_ERROR;
	}

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

	MergedSize = 0;		/* This Variable is effective in VariableMsgQPost */
	Status =  MK_FreeMemoryInternal(pHeap, pAddr, AllocSize, &MergedSize);
	if( Status < 0)
	{
		MK_InterruptRestore(Flags);
		return Status;
	}

	pTask = MK_GetFirstPendingTask(&pHeap->h_PendingList);
	if(pTask != MK_NULL)
	{
		if(MergedSize >= (ULONG)pTask->t_pendingMemSize)
		{
			MK_DeleteTaskFromPendingList(&pHeap->h_PendingList, pTask);
			if(pTask->t_Status & MK_TASK_DELAYED)
			{
				MK_DeleteTaskFromDelayedList(pTask);
			}
			MK_InsertTaskToReadyList(pTask);
			MK_Schedule();
		}
	}
	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

STATUS
MK_CreateBufferPool(MK_POOL *pPool, CHAR *pName, VOID *pAddr, INT Count, 
						 ULONG Size, BOOLEAN Options)
{
	LONG i;
	STATUS Status;
	VOID *pTemp;
	ULONG Convert;
	INT	Flags;

	if(pPool->bp_Magic == MK_POOL_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_CreateBufferPool() - Magic error!\n");
#endif
		return MK_ERROR;
	}
	
	Flags = MK_InterruptDisable();		/* Critical Region */

	pPool->bp_pName = pName;

	pPool->bp_Size = Size + sizeof(ULONG);
	pPool->bp_StartofBufferPool = (ULONG)pAddr;
	pPool->bp_InitCount = Count;

	pPool->bp_NextBuffer = (ULONG)pAddr;

	for(i=0, pTemp=pAddr; i<Count-1; i++)
	{
		*(ULONG *)pTemp = (ULONG)pTemp + pPool->bp_Size;	/* Save Next Pointer */
		Convert = (ULONG)pTemp;
		Convert += pPool->bp_Size;
		pTemp = (ULONG *)Convert;
	}
	*(ULONG *)pTemp = 0;			/* End Buffer */

	Status = MK_CreateSemaphore(&pPool->bp_Semaphore, pName, Count, Options);
	if( Status < 0)
	{
		if( Status == MK_ERROR)
		{
#if MK_DEBUG_PRINT
			MK_InfoPrintf(MK_TASK_WARNING, "MK_CreateBufferPool() - CreateSemaphore is not completed! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		}
		return Status;
	}

	pPool->bp_Magic = MK_POOL_MAGIC;

	pPool->bp_pNext = MK_NULL;
	pPool->bp_pPrev = MK_NULL;
	if(MK_pBufferPoolListHead == MK_NULL)
	{
		MK_pBufferPoolListHead = pPool;
		MK_pBufferPoolListTail = pPool;
	}
	else
	{
		pPool->bp_pPrev = MK_pBufferPoolListTail;
		MK_pBufferPoolListTail->bp_pNext = pPool;
		MK_pBufferPoolListTail = pPool;
	}

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

STATUS
MK_DeleteBufferPool(MK_POOL *pPool)
{
	INT Flags;

	if(pPool->bp_Magic != MK_POOL_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_DeleteBufferPool() - Magic Error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}

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

	MK_DeleteSemaphore(&pPool->bp_Semaphore);
	if(MK_pBufferPoolListHead == MK_pBufferPoolListTail)
	{
		MK_pBufferPoolListHead = MK_NULL;
		MK_pBufferPoolListTail = MK_NULL;
	}
	else
	{
		if(pPool == MK_pBufferPoolListHead)
		{
			MK_pBufferPoolListHead = pPool->bp_pNext;
			MK_pBufferPoolListHead->bp_pPrev = MK_NULL;
		}
		else if(pPool == MK_pBufferPoolListTail)
		{
			MK_pBufferPoolListTail = pPool->bp_pPrev;
			MK_pBufferPoolListTail->bp_pNext = MK_NULL;
		}
		else
		{
			pPool->bp_pPrev->bp_pNext = pPool->bp_pNext;
			pPool->bp_pNext->bp_pPrev = pPool->bp_pPrev;
		}
	}
	pPool->bp_pNext = MK_NULL;
	pPool->bp_pPrev = MK_NULL;
	
	MK_FreeMemory((void *)pPool->bp_StartofBufferPool);
	
	pPool->bp_Magic = 0;

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

STATUS
MK_ResetBufferPool(MK_POOL *pPool)
{
	STATUS	status;
	VOID	*pTemp;
	ULONG	Convert;
	INT		i;
	INT		Flags;

	if(pPool->bp_Magic != MK_POOL_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_ResetBufferPool() - Magic error!\n");
#endif
		return MK_RESOURCE_ERROR;
	}
	
	Flags = MK_InterruptDisable();		/* Critical Region */

	pPool->bp_NextBuffer = pPool->bp_StartofBufferPool;
	
	for(i=0, pTemp=(VOID *)pPool->bp_StartofBufferPool; i<pPool->bp_InitCount -1; i++)
	{
		*(ULONG *)pTemp = (ULONG)pTemp + pPool->bp_Size;	/* Save Next Pointer */
		Convert = (ULONG)pTemp;
		Convert += pPool->bp_Size;
		pTemp = (ULONG *)Convert;
	}
	*(ULONG *)pTemp = 0;			/* End Buffer */

	status = MK_SemaphoreReset(&pPool->bp_Semaphore, pPool->bp_InitCount);

	MK_InterruptRestore(Flags);
	return status;
}

ULONG
MK_GetPoolNeededSize(ULONG	Count, ULONG Size)
{
	return Count * (Size + sizeof(ULONG));
}

/* return available bufer size */
ULONG
MK_GetPoolBufferSize(MK_POOL *pPool)
{
	if(pPool->bp_Magic != MK_POOL_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_GetPoolBufferSize() - Magic Error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return 0;
	}

	return pPool->bp_Size - sizeof(ULONG);
}

/* # of available buffer */
UINT 
MK_GetPoolBufferCount(MK_POOL *pPool)
{
	if(pPool->bp_Magic != MK_POOL_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_GetPoolBufferFreeCount() - Magic Error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return 0;
	}

	return MK_GetSemaphoreCount(&pPool->bp_Semaphore);
}

STATUS
MK_GetBuf(MK_POOL *pPool, VOID **pAddr, LONG Ticks)
{
	INT Flags;
	STATUS Status;
	VOID *pTemp;
	ULONG	Convert;

	if(pPool->bp_Magic != MK_POOL_MAGIC)
	{
#if MK_DEBUG_PRINT
		MK_Panic("MK_GetBuf() - Magic Error! Task(%s)\n", MK_GetCurrentTask()->t_pName);
#endif
		return MK_RESOURCE_ERROR;
	}
	Flags = MK_InterruptDisable();			/* Critical Region */

	Status = MK_SemaphorePend(&pPool->bp_Semaphore, Ticks);
	if( Status < 0)
	{
		*pAddr = 0;
		if ( Status == MK_RESOURCE_ERROR )
			MK_KernelInfoPrintf((MK_TASK_WARNING, "MK_GetBuf() - Buffer pool is deleted or reset! Task(%s)\n",
						MK_GetCurrentTask()->t_pName));
		else if ( Status == MK_TIMEOUT )
			MK_KernelInfoPrintf((MK_TASK_WARNING, "MK_GetBuf() - Timeout! Task(%s)\n", MK_GetCurrentTask()->t_pName));

		MK_InterruptRestore( Flags );
		return Status;
	}

	pTemp = (VOID *)pPool->bp_NextBuffer;
	pPool->bp_NextBuffer = *(ULONG *)pPool->bp_NextBuffer;
	*(ULONG *)pTemp = (ULONG)pPool;
	Convert = (ULONG)pTemp;
	Convert += sizeof(ULONG);
	pTemp = (ULONG *)Convert;
	*pAddr = pTemp;

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

STATUS
MK_FreeBuf(VOID *pAddr)
{
	ULONG *pTemp;
	ULONG	Convert;
	INT Flags;
	MK_POOL *pPool;

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

	Convert = (ULONG)pAddr;
	Convert -= sizeof(ULONG);
	pTemp = (ULONG *)Convert;
	Convert = *(ULONG *)Convert;
	pPool = (MK_POOL *)Convert;

	if(pPool->bp_Magic != MK_POOL_MAGIC)
	{
		MK_KernelPanic(("MK_FreeBuf() - Magic error! Task(%s)\n", MK_GetCurrentTask()->t_pName));
		MK_InterruptRestore(Flags);
		return MK_RESOURCE_ERROR;
	}

	*pTemp = pPool->bp_NextBuffer;
	pPool->bp_NextBuffer = (ULONG)pTemp;

	MK_SemaphorePost(&pPool->bp_Semaphore);

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}

#if _MK_DDI
STATUS
MK_HeapMemoryInformation(struct mk_ddi_struct *pDDI)
{
	MK_HEAP *pHeap;
	INT		Flags;

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

	for(pHeap = MK_pHeapListHead; pHeap != MK_NULL; pHeap = pHeap->h_pNext)
	{
		MK_Fprintf(pDDI, "%s ", pHeap->h_pName);
	}

	MK_Fprintf(pDDI,"\n");

	MK_InterruptRestore(Flags);

	return MK_NO_ERROR;
}

STATUS
MK_FixedBufferInformation(struct mk_ddi_struct *pDDI)
{
	MK_POOL *pPool;
	int Flags;

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

	for(pPool = MK_pBufferPoolListHead; pPool != MK_NULL; pPool = pPool->bp_pNext)
	{
		MK_Fprintf(pDDI, "%s ", pPool->bp_pName);
	}

	MK_Fprintf(pDDI,"\n");

	MK_InterruptRestore(Flags);
	return MK_NO_ERROR;
}
#endif	/* #if _MK_DDI */