コード例 #1
0
IPC_ReturnCode_T IPC_SendBuffer(IPC_Buffer Buffer, IPC_Priority_T Priority)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);

	IPC_TRACE(IPC_Channel_Buffer, "IPC_SendBuffer",
		  "Buffer %d (%08X), Priority %d", BufferPtr->BufferId, Buffer,
		  Priority, 0);

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_SendBuffer",
			  "Invalid Buffer %08X", Buffer, 0, 0, 0);
		return IPC_ERROR;
	}

	BufferPtr->TimeStampSend = TIMER_GetValue();
	BufferPtr->StatusCode = IPC_BUFFER_STATUS_SENT;

	IPC_PoolAddBytesSent(BufferPtr->Pool,
			     BufferPtr->DataSize + BufferPtr->HeaderSize);

#ifdef IPC_BUFFER_STATS
	/* Debug output - turned off by default for performance */
	if (BufferPtr->BufferId == 0 && 0 == LISR_Active)
		IPC_PoolDumpStats(BufferPtr->Pool);
#endif

	IPC_SmSendBuffer(Buffer);

	return IPC_OK;
}
コード例 #2
0
/* Only called by the SM HISR, so no critical reigon */
static IPC_Buffer IPC_SmFifoRead(IPC_Fifo Fifo)
{
	IPC_Buffer Buffer;
	IPC_U32 ReadIndex;

	ReadIndex = Fifo->ReadIndex;

	IPC_TRACE(IPC_Channel_Debug, "IPC_SmFifoRead",
		  "Fifo %08X, %d entries, read: %d, Write %d", Fifo,
		  IPC_FIFOCOUNT(Fifo), ReadIndex, Fifo->WriteIndex);

	if (ReadIndex == Fifo->WriteIndex) {
		IPC_TRACE(IPC_Channel_Sm, "IPC_SmFifoRead", "Fifo %08X, Empty",
			  Fifo, 0, 0, 0);
		return (IPC_Buffer) 0;
	}

	Buffer = Fifo->Buffer[ReadIndex];

	Fifo->ReadIndex = IPC_FIFOINCREMENT(ReadIndex);

	IPC_TRACE(IPC_Channel_Sm, "IPC_SmFifoRead",
		  "Fifo %08X, Read  %08X, %d entries", Fifo, Buffer,
		  IPC_FIFOCOUNT(Fifo), 0);

	return Buffer;
}
コード例 #3
0
void IPC_PoolDumpStats(IPC_BufferPool Pool)
{
	IPC_BufferPool_T *PoolPtr = IPC_PoolToPtr(Pool);

	if (!PoolPtr) {
		IPC_TRACE(IPC_Channel_General, "IPC_Stats", "Pool %08X Invalid",
			  Pool, 0, 0, 0);
		return;
	};

	IPC_TRACE(IPC_Channel_General, "IPC_Stats",
		  "Pool %08X: UserP %08X, BufSize %d, BufCount %d", Pool,
		  PoolPtr->UserParameter, PoolPtr->MaxDataSize,
		  PoolPtr->MaxBuffers);

	IPC_TRACE(IPC_Channel_General, "         ",
		  "Alloc %d, Fail %d, FcStart %d, FcStop %d",
		  PoolPtr->Allocations, PoolPtr->AllocationFailures,
		  PoolPtr->FlowStartCalls, PoolPtr->FlowStopCalls);

	IPC_TRACE(IPC_Channel_General, "         ",
		  "Sent %d, FreeBufs %d, LowWaterMark %d, FcState %d",
		  PoolPtr->BytesSent, PoolPtr->FreeBuffers,
		  PoolPtr->LowWaterMark, PoolPtr->FlowControlState);
}
コード例 #4
0
void IPC_FreeBuffer(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);
	IPC_CPU_ID_T OwningCpu;

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_FreeBuffer",
			  "Invalid Buffer %08X", Buffer, 0, 0, 0);
		return;
	}

	if (BufferPtr->StatusCode == IPC_BUFFER_STATUS_FREE) {
		IPC_TRACE(IPC_Channel_Error, "IPC_FreeBuffer",
			  "Repeated Free Buffer %08X", Buffer, 0, 0, 0);
		return;
	}

	OwningCpu = IPC_PoolOwningCpu(BufferPtr->Pool);
	BufferPtr->TimeStampFree = TIMER_GetValue();
	BufferPtr->StatusCode = IPC_BUFFER_STATUS_FREE;

	if (OwningCpu == IPC_SM_CURRENT_CPU) {
		IPC_TRACE(IPC_Channel_Buffer, "IPC_FreeBuffer",
			  "Buffer %08X, ID %d Same CPU ", Buffer,
			  BufferPtr->BufferId, 0, 0);
		IPC_BufferReturn(Buffer, BufferPtr->Pool);
	} else {
		IPC_TRACE(IPC_Channel_Buffer, "IPC_FreeBuffer",
			  "Buffer %08X, ID %d Other CPU", Buffer,
			  BufferPtr->BufferId, 0, 0);
		IPC_SmFreeBuffer(Buffer, OwningCpu);
	}
}
コード例 #5
0
void *IPC_BufferHeaderRemove(IPC_Buffer Buffer, IPC_U32 HeaderSize)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferHeaderRemove",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return 0;
	}

	if (HeaderSize > BufferPtr->HeaderSize) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferHeaderRemove",
			  "Buffer %08X, HeaderSize %d too big", Buffer,
			  HeaderSize, 0, 0);
		return 0;
	} else {

		IPC_TRACE(IPC_Channel_Data, "IPC_BufferHeaderRemove",
			  "Buffer %08X, HeaderSize %d", Buffer, HeaderSize, 0,
			  0);
		BufferPtr->HeaderSize -= HeaderSize;
		return IPC_SmAddress(BufferPtr->DataOffset -
				     BufferPtr->HeaderSize);
	}
}
コード例 #6
0
void IPC_DecrementBufferDataPointer(IPC_Buffer Buffer, IPC_U32 offset)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);
	IPC_SmPtr DataOffset = 0;

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_MoveBufferDataPointer ",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return;
	}
	DataOffset = BufferPtr->DataOffset - offset;

	IPC_TRACE(IPC_Channel_Data, "IPC_MoveBufferDataPointer ",
		  "Buffer %08X, Ptr %08X", Buffer, DataOffset, 0, 0);

	if (DataOffset <
	    (BufferPtr->DataBufferStart) + IPC_BufferHeaderSizeGet(Buffer)) {
		IPC_TRACE(IPC_Channel_Error, "IPC_MoveBufferDataPointer ",
			  "Invalid Pointer %08X", BufferPtr->DataOffset, 0, 0,
			  0);
		return;
	}
	BufferPtr->DataOffset = DataOffset;
	BufferPtr->DataSize += offset;
	BufferPtr->HeaderSize -= offset;
}
コード例 #7
0
IPC_U32 IPC_BufferSetDataSize(IPC_Buffer Buffer, IPC_U32 Length)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);
	IPC_U32 MaxDataSize;

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferSetDataSize",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return 0;
	}

	MaxDataSize = IPC_PoolMaxDataSize(BufferPtr->Pool);

	if (Length > MaxDataSize) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferSetDataSize",
			  "Buffer %08X, Length %d too big", Buffer, Length, 0,
			  0);
		return 0;
	} else {
		IPC_TRACE(IPC_Channel_Data, "IPC_BufferSetDataSize",
			  "Buffer %08X, Length %d", Buffer, Length, 0, 0);
		BufferPtr->DataSize = Length;
		return Length;
	}
}
コード例 #8
0
IPC_SmPtr IPC_SmPoolAlloc(IPC_U32 PoolOverhead,
			IPC_U32 HeaderSize,
			IPC_U32 DataSize,
			IPC_U32 BufferCount)
{
	IPC_SmPtr Pool;

	if (SmLocalControl.SmControl->
	    CurrentBuffers[IPC_CPU_ID_INDEX(IPC_SM_CURRENT_CPU)] +
	    BufferCount >= IPC_SM_MAX_BUFFERS) {
		IPC_TRACE(IPC_Channel_Error, "IPC_SmPoolAlloc",
			  "Too Many Buffers", 0, 0, 0, 0);
		return 0;
	}

	Pool = IPC_SmAlloc(PoolOverhead
			   + (IPC_BufferOverhead() + HeaderSize +
			      DataSize) * BufferCount);

	if (Pool == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_SmPoolAlloc",
			  "Failed to Allocate Sm", 0, 0, 0, 0);
		return 0;
	}

	SmLocalControl.SmControl->
	    CurrentBuffers[IPC_CPU_ID_INDEX(IPC_SM_CURRENT_CPU)] += BufferCount;

	IPC_SmAddPool(Pool);

	return Pool;
}
コード例 #9
0
void *IPC_BufferFill(IPC_Buffer Buffer, void *SourcePtr, IPC_U32 SourceLength)
{
	IPC_Buffer_T *BufferPtr;
	IPC_U32 MaxDataSize;

	if (SourceLength == 0)
		return NULL;

	BufferPtr = IPC_BufferToPtr(Buffer);
	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferFill",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return NULL;
	}

	MaxDataSize = IPC_PoolMaxDataSize(BufferPtr->Pool);

	if (MaxDataSize < SourceLength) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferFill",
			  "Buffer %08X, Length %d too big", Buffer,
			  SourceLength, 0, 0);
		return NULL;
	}

	IPC_TRACE(IPC_Channel_Data, "IPC_BufferFill",
		  "Buffer %08X, From %08P, Length %d", Buffer, SourcePtr,
		  SourceLength, 0);

	BufferPtr->DataSize = SourceLength;

	return memcpy(IPC_SmAddress(BufferPtr->DataOffset), SourcePtr,
		      SourceLength);
}
コード例 #10
0
void IPC_SmFifoWrite(IPC_Fifo Fifo, IPC_Buffer Message)
{
	CRITICAL_REIGON_SETUP IPC_U32 OriginalWritePointer;

	IPC_TRACE(IPC_Channel_Sm, "IPC_SmFifoWrite", "Fifo %08X, Buffer %08X",
		  Fifo, Message, 0, 0);

	IPC_TRACE(IPC_Channel_Debug, "IPC_SmFifoWrite",
		  "Fifo %08X,  %d entries, read: %d, Write %d", Fifo,
		  IPC_FIFOCOUNT(Fifo), Fifo->ReadIndex, Fifo->WriteIndex);

	CRITICAL_REIGON_ENTER OriginalWritePointer = Fifo->WriteIndex;

	Fifo->Buffer[OriginalWritePointer] = Message;
	Fifo->WriteIndex = IPC_FIFOINCREMENT(OriginalWritePointer);
	Fifo->WriteCount++;

	if (IPC_FIFOCOUNT(Fifo) > Fifo->HighWaterMark)
		Fifo->HighWaterMark = IPC_FIFOCOUNT(Fifo);

	CRITICAL_REIGON_LEAVE if (OriginalWritePointer == 0) {
		IPC_TRACE(IPC_Channel_Debug, "IPC_SmFifoWrite",
			  "Fifo %08X, Count %d, HighWaterMark %d", Fifo,
			  Fifo->WriteCount, Fifo->HighWaterMark, 0);
	}

	if (Fifo->ReadIndex == OriginalWritePointer) {
		/* Remote end is not currently reading FIFO */
		IPC_TRACE(IPC_Channel_Sm, "IPC_SmFifoWrite",
			  "Interrupting other Cpu", 0, 0, 0, 0);
		RAISE_INTERRUPT;
	}
}
コード例 #11
0
IPC_SmPtr IPC_SmAlloc(IPC_U32 Size)
{
	IPC_CPU_ID_T Cpu = IPC_SM_CURRENT_CPU;
	volatile IPC_U32 *ApAllocated =
	    &SmLocalControl.SmControl->Allocated[IPC_CPU_ID_INDEX(IPC_AP_CPU)];
	volatile IPC_U32 *CpAllocated =
	    &SmLocalControl.SmControl->Allocated[IPC_CPU_ID_INDEX(IPC_CP_CPU)];
	IPC_SmPtr Allocated;

	if ((*CpAllocated - *ApAllocated) < Size) {
		IPC_TRACE(IPC_Channel_Error, "IPC_SmAlloc", "Not Enough Space",
			  0, 0, 0, 0);
		return 0;
	} else {
		switch (Cpu) {
		case IPC_AP_CPU:
			{
				/* Allocate from the bottom up for AP */
				Allocated = *ApAllocated;
				*ApAllocated += Size;
			}
			break;

		case IPC_CP_CPU:
			{
				/* Allocate from the top down for CP */
				*CpAllocated -= Size;
				Allocated = *CpAllocated;
			}
			break;

		default:
			{
				IPC_TRACE(IPC_Channel_Error, "IPC_SmAlloc",
					  "Unknown CPU %d", Cpu, 0, 0, 0);
				return 0;
			}
		}

		if (*CpAllocated < *ApAllocated) {
			IPC_TRACE(IPC_Channel_Error, "IPC_SmAlloc",
				  "Memory overallocated", 0, 0, 0, 0);
			return 0;
		}

		IPC_TRACE(IPC_Channel_Sm, "IPC_SmAlloc",
			  "%d Bytes Allocated at %08X", Size, Allocated, 0, 0);
		return Allocated;
	}
}
コード例 #12
0
IPC_U32 IPC_BufferDataSize(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferDataSize",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return 0;
	}

	IPC_TRACE(IPC_Channel_Data, "IPC_BufferDataSize",
		  "Buffer %08X, Size %d", Buffer, BufferPtr->DataSize, 0, 0);

	return BufferPtr->DataSize;
}
コード例 #13
0
void *IPC_BufferHeaderPointer(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferHeaderPointer",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return 0;
	}

	IPC_TRACE(IPC_Channel_Data, "IPC_BufferHeaderPointer", "Buffer %08X",
		  Buffer, 0, 0, 0);

	return IPC_SmAddress(BufferPtr->DataOffset - BufferPtr->HeaderSize);
}
コード例 #14
0
ファイル: ipc_buffer.c プロジェクト: dhinesh77/Xkernel
void *IPC_BufferFillByLinkList(IPC_Buffer Buffer,
				IPC_LinkList_T *LinkListPtr,
				IPC_U32 LinkListLength)
{
	IPC_Buffer_T *BufferPtr;
	IPC_U32 MaxDataSize;
	IPC_U32 SourceLength;
	IPC_U32 i;
	unsigned char *p;
	unsigned char *q;

	SourceLength = 0;
	for (i = 0; i < LinkListLength; i++)
		SourceLength += LinkListPtr[i].size;

	if (SourceLength == 0)
		return NULL;

	BufferPtr = IPC_BufferToPtr(Buffer);
	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferFillByLinkList",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return NULL;
	}

	MaxDataSize = IPC_PoolMaxDataSize(BufferPtr->Pool);

	if (MaxDataSize < SourceLength) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferFillByLinkList",
			  "Buffer %08X, Length %d too big", Buffer,
			  SourceLength, 0, 0);
		return NULL;
	}

	IPC_TRACE(IPC_Channel_Data, "IPC_BufferFillByLinkList",
		  "Buffer %08X, LinkListPtr %08X, Length %d", Buffer,
		  LinkListPtr, SourceLength, 0);

	BufferPtr->DataSize = SourceLength;

	p = q = IPC_SmAddress(BufferPtr->DataOffset);
	for (i = 0; i < LinkListLength; i++) {
		memcpy(p, LinkListPtr[i].byte_array, LinkListPtr[i].size);
		p += LinkListPtr[i].size;
	}
	return (void *)q;
}
コード例 #15
0
void IPC_SmSendBuffer(IPC_Buffer Buffer)
{
	IPC_EndpointId_T DestinationEpId;
	IPC_Endpoint DestinationEpPtr;
	IPC_CPU_ID_T DestinationCpu;

	DestinationEpId = IPC_BufferDestinationEndpointId(Buffer);

#ifdef IPC_DEBUG
	if (DestinationEpId == IPC_EP_None) {
		IPC_TRACE(IPC_Channel_Error,
			  "IPC_SmSendBuffer",
			  "Invalid Destination Endpoint %08X for Buffer %08X",
			  DestinationEpId, Buffer, 0, 0);
		return;
	}
#endif

#ifdef FUSE_IPC_CRASH_SUPPORT
	if (g_bCpCrashed == IPC_TRUE) {
		IPC_TRACE(IPC_Channel_Error,
			  "IPC_SmSendBuffer",
			  "Trying to send after CP has crashed for Buffer %08X",
			  Buffer, 0, 0, 0);
		return;
	}
#endif

	DestinationEpPtr = IPC_SmEndpointInfo(DestinationEpId);
	DestinationCpu = DestinationEpPtr->Cpu;

	IPC_TRACE(IPC_Channel_Sm,
		  "IPC_SmSendBuffer",
		  "DestinationCpu %02X, Buffer %08X",
		  DestinationCpu, Buffer, 0, 0);

	if (DestinationCpu == IPC_SM_CURRENT_CPU) {
		(*DestinationEpPtr->DeliveryFunction) (Buffer);
	} else {
		IPC_Fifo SendFifo =
		    &SmLocalControl.SmControl->
		    Fifos[IPC_CPU_ID_INDEX(DestinationCpu)].SendFifo;
		IPC_SmFifoWrite(SendFifo, Buffer);
	}
}
コード例 #16
0
IPC_U32 IPC_BufferHeaderSizeGet(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);
	IPC_U32 HeaderSize;

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferHeaderSizeGet",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return 0;
	}

	HeaderSize = BufferPtr->HeaderSize;

	IPC_TRACE(IPC_Channel_Data, "IPC_BufferHeaderSizeGet",
		  "Buffer %08X, HeaderSize %d", Buffer, HeaderSize, 0, 0);

	return HeaderSize;
}
コード例 #17
0
void IPC_BufferReturnToPool(IPC_Buffer Buffer, IPC_BufferPool Pool)
{
	IPC_BufferPool_T *PoolPtr = IPC_PoolToPtr(Pool);
	IPC_U32 BufferCount;
	IPC_Boolean FlowControlCallNeeded = IPC_FALSE;

	CRITICAL_REIGON_SETUP
	    IPC_TRACE(IPC_Channel_Buffer, "IPC_BufferReturnToPool",
		      "Buffer %d (%08X), now %d in pool", IPC_BufferId(Buffer),
		      Buffer, PoolPtr->FreeBuffers + 1, 0);

	CRITICAL_REIGON_ENTER(PoolPtr->Lock);

	BufferCount = ++PoolPtr->FreeBuffers;

#ifdef IPC_DEBUG
	IPC_QRemove(IPC_BufferQueue(Buffer));
#endif
	IPC_QAddBack(IPC_BufferQueue(Buffer),
		     IPC_POOLFreeQ(IPC_SmOffset(PoolPtr)));

	/* Flow Control Check */
	if (BufferCount == PoolPtr->FlowStartLimit)
		CHECK_FLOW_STATE(PoolPtr, IPC_FLOW_START, FlowControlCallNeeded)

		    CRITICAL_REIGON_LEAVE(PoolPtr->Lock);

	if (FlowControlCallNeeded)
		IPC_ReportFlowControlEvent(PoolPtr, IPC_FLOW_START);

	/* Last ditch check - should never happen */
	if (PoolPtr->FlowControlState == IPC_FLOW_STOP
	    && !PoolPtr->FlowControlCallPending
	    && PoolPtr->FlowStartLimit < BufferCount) {
		IPC_TRACE(IPC_Channel_FlowControl, "IPC_BufferReturnToPool",
			  "Retry Flow Start", 0, 0, 0, 0);
		IPC_ReportFlowControlEvent(PoolPtr, IPC_FLOW_START);
	}

	/* For IPC_AllocateBufferWait () */
	if ((BufferCount == 1) && (PoolPtr->EmptyEvent))
		IPC_EVENT_SET(PoolPtr->EmptyEvent);
}
コード例 #18
0
IPC_U32 IPC_PoolFreeBuffers(IPC_BufferPool Pool)
{
	IPC_BufferPool_T *PoolPtr = IPC_PoolToPtr(Pool);
	if (!PoolPtr) {
		IPC_TRACE(IPC_Channel_Error, "IPC_PoolFreeBuffers",
			  "Invalid Pool %d", Pool, 0, 0, 0);
		return 0;
	}
	return PoolPtr->FreeBuffers;
}
コード例 #19
0
void IPC_BufferReturn(IPC_Buffer Buffer, IPC_BufferPool Pool)
{
	IPC_BufferPool_T *PoolPtr = IPC_PoolToPtr(Pool);

	if (PoolPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferReturn",
			  "Invalid Pool for Buffer %08X", Buffer, 0, 0, 0);
		return;
	}

	if (PoolPtr->BufferFreeFunction) {
		IPC_TRACE(IPC_Channel_Buffer, "IPC_BufferReturn",
			  "User Function %08X called for Buffer %08X",
			  PoolPtr->BufferFreeFunction, Buffer, 0, 0);
		(PoolPtr->BufferFreeFunction) (Pool, Buffer);
	} else {
		IPC_BufferReturnToPool(Buffer, Pool);
	}
}
コード例 #20
0
IPC_EndpointId_T IPC_BufferDestinationEndpointId(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);
	IPC_EndpointId_T DestinationEndpointId;

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferDestinationEndpoint",
			  "Invalid Buffer %08X", Buffer, 0, 0, 0);
		return IPC_EP_None;
	}

	DestinationEndpointId = IPC_PoolDestinationEndpointId(BufferPtr->Pool);

	IPC_TRACE(IPC_Channel_Data, "IPC_BufferDestinationEndpoint",
		  "Buffer %08X, EpId %08X", Buffer, DestinationEndpointId, 0,
		  0);

	return DestinationEndpointId;

}
コード例 #21
0
void IPC_SmFreeBuffer(IPC_Buffer Buffer, IPC_CPU_ID_T OwningCpu)
{
	IPC_Fifo FreeFifo =
	    &SmLocalControl.SmControl->Fifos[IPC_CPU_ID_INDEX(OwningCpu)].
	    FreeFifo;

	IPC_TRACE(IPC_Channel_Sm,
		  "IPC_SmFreeBuffer", "Buffer %08X", Buffer, (IPC_U32) 0, 0, 0);

	IPC_SmFifoWrite(FreeFifo, Buffer);
}
コード例 #22
0
IPC_EndpointId_T IPC_BufferSourceEndpointId(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferSourceEndpoint",
			  "Invalid Buffer %08X", Buffer, 0, 0, 0);
		return IPC_EP_None;
	}

	return IPC_PoolSourceEndpointId(BufferPtr->Pool);
}
コード例 #23
0
IPC_U32 IPC_BufferUserParameterGet(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferUserParameterGet",
			  "Invalid Buffer %d", Buffer, 0, 0, 0);
		return 0;
	}

	return BufferPtr->UserParameter;
}
コード例 #24
0
IPC_U32 IPC_BufferPoolUserParameter(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);
	IPC_U32 Parameter;

	Parameter = IPC_PoolUserParameterGet(BufferPtr->Pool);

	IPC_TRACE(IPC_Channel_Data, "IPC_BufferPoolUserParameter",
		  "Buffer %08X, Parameter %08X", Buffer, Parameter, 0, 0);

	return Parameter;
}
コード例 #25
0
//**************************************************
void IPC_PoolAddBytesSent (IPC_BufferPool Pool, IPC_U32 Bytes)
{
	IPC_BufferPool_T *	PoolPtr	= IPC_PoolToPtr (Pool);

	if (!PoolPtr)
	{
		IPC_TRACE (IPC_Channel_Error, "IPC_PoolAddBytesSent", "Invalid Pool %d", Pool, 0, 0, 0);
		return;
	}

	PoolPtr->BytesSent += Bytes;
}
コード例 #26
0
//**************************************************
void  IPC_PoolSetFreeCallback (IPC_BufferPool Pool, IPC_BufferFreeFPtr_T	BufferFreeFunction)
{
	IPC_BufferPool_T *	PoolPtr	= IPC_PoolToPtr (Pool);

	if (!PoolPtr)
	{
		IPC_TRACE (IPC_Channel_Error, "IPC_PoolSetFreeCallback", "Invalid Pool %d", Pool, 0, 0, 0);
		return;
	}

	PoolPtr->BufferFreeFunction = BufferFreeFunction;
}
コード例 #27
0
//**************************************************
IPC_U32 IPC_PoolUserParameterGet (IPC_BufferPool Pool)
{
	IPC_BufferPool_T *	PoolPtr	= IPC_PoolToPtr (Pool);

	if (!Pool)
	{
		IPC_TRACE (IPC_Channel_Error, "IPC_PoolUserParameterGet", "Invalid Pool %d", Pool, 0, 0, 0);
		return 0;
	}

	return PoolPtr->UserParameter;
}
コード例 #28
0
IPC_SmQ IPC_QCreate(void)
{
	IPC_SmQ Queue = IPC_SmAlloc(sizeof(IPC_QHead_T));

	if (Queue == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_QCreate",
			  "IPC_SmAlloc failed", 0, 0, 0, 0);
		return 0;
	}

	return IPC_QInitialise(Queue, Queue);
}
コード例 #29
0
IPC_BufferPool IPC_BufferOwningPool(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferOwningPool",
			  "Invalid Buffer %08X", Buffer, 0, 0, 0);
		return 0;
	}

	return BufferPtr->Pool;
}
コード例 #30
0
void *IPC_BufferLocalDescriptor(IPC_Buffer Buffer)
{
	IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer);

	if (BufferPtr == 0) {
		IPC_TRACE(IPC_Channel_Error, "IPC_BufferLocalDescriptorl",
			  "Invalid Buffer %08X", Buffer, 0, 0, 0);
		return 0;
	}

	return (void *)BufferPtr->LocalData;
}