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; } }
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); } }
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; }
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); }
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; }
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); } }
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; }
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; }
void IPC_PoolDump(IPC_BufferPool Pool) { IPC_BufferPool_T *PoolPtr = IPC_PoolToPtr(Pool); IPC_U32 Id; IPC_SmPtr Buffer; IPC_U32 BufferSize; IPC_Buffer_T *BufferPtr; IPC_TRACE(IPC_Channel_General, "----- IPC_PoolDump -----", "", 0, 0, 0, 0); if (!PoolPtr) { IPC_TRACE(IPC_Channel_General, "IPC_PoolDump", "Pool %08X Invalid", Pool, 0, 0, 0); return; }; IPC_TRACE(IPC_Channel_General, "IPC_PoolDump", "Pool %08X, CPU %s, SrcEp %02X, DestEp %02X", Pool, (IPC_U32)IPC_GetCpuName(PoolPtr->Cpu), PoolPtr->SourceEndpointId, PoolPtr->DestinationEndpointId); IPC_TRACE(IPC_Channel_General, " ", "SrcEp Id=%02X Name=%s, DestEp Id=%02X Name=%s", PoolPtr->SourceEndpointId, (IPC_U32)IPC_GetEndPointName(PoolPtr->SourceEndpointId), PoolPtr->DestinationEndpointId, (IPC_U32)IPC_GetEndPointName(PoolPtr->DestinationEndpointId)); IPC_TRACE(IPC_Channel_General, " ", "BufCount %d, Free %d, FlowState %01d, Param %08X", PoolPtr->MaxBuffers, PoolPtr->FreeBuffers, PoolPtr->FlowControlState, PoolPtr->UserParameter); IPC_PoolDumpStats(Pool); /* Dump IPC buffer not consumed by receiver to debug IPC memory depletion issue */ if (PoolPtr->MaxBuffers == PoolPtr->FreeBuffers) return; Buffer = Pool + sizeof(IPC_BufferPool_T); BufferSize = IPC_BufferOverhead() + PoolPtr->MaxHeaderSize + PoolPtr->MaxDataSize; IPC_TRACE(IPC_Channel_General, "IPC_PoolDump", "Allocated Buffers:", 0, 0, 0, 0); for (Id = 0; Id < PoolPtr->MaxBuffers; Id++) { BufferPtr = IPC_BufferToPtr(Buffer); if (BufferPtr->StatusCode != IPC_BUFFER_STATUS_FREE) IPC_BufferDump(Buffer); Buffer += BufferSize; } }
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); }
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; }
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; }
IPC_Boolean IPC_BufferUserParameterSet(IPC_Buffer Buffer, IPC_U32 Value) { IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer); if (BufferPtr == 0) { IPC_TRACE(IPC_Channel_Error, "IPC_BufferUserParameterSet", "Invalid Buffer %d", Buffer, 0, 0, 0); return IPC_FALSE; } BufferPtr->UserParameter = Value; return IPC_TRUE; }
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); }
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; }
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; }
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; }
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; }
void *IPC_BufferDataPointer(IPC_Buffer Buffer) { IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer); IPC_SmPtr DataOffset = 0; if (BufferPtr == 0) { IPC_TRACE(IPC_Channel_Error, "IPC_BufferDataPointer", "Invalid Buffer %d", Buffer, 0, 0, 0); return 0; } DataOffset = BufferPtr->DataOffset; IPC_TRACE(IPC_Channel_Data, "IPC_BufferDataPointer", "Buffer %08X, Ptr %08X", Buffer, DataOffset, 0, 0); if (DataOffset >= ((IPC_SmControl) SmBase)->Size) { IPC_TRACE(IPC_Channel_Error, "IPC_BufferDataPointer", "Invalid Pointer %08X", DataOffset, 0, 0, 0); return 0; } return IPC_SmAddress(DataOffset); }
void IPC_BufferDump(IPC_Buffer Buffer) { IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer); /** * DataPtr is used to dump the contents of the first 4 U32s * of the memory location * * coverity[returned_pointer] */ IPC_U32 *DataPtr = IPC_BufferDataPointer(Buffer); IPC_BufferPool_T *PoolPtr = IPC_PoolToPtr(BufferPtr->Pool); if (BufferPtr == 0) { IPC_TRACE(IPC_Channel_General, "IPC_BufferDump", "Invalid Buffer %08X", Buffer, 0, 0, 0); return; } IPC_TRACE(IPC_Channel_General, "IPC_BufferDump", "Id %d, Pool %08X, Next %08X, Prev %08X", BufferPtr->BufferId, BufferPtr->Pool, BufferPtr->Q.Next, BufferPtr->Q.Previous); IPC_TRACE(IPC_Channel_General, " ", "Buffer %08X, DataOffset %08X, DataSize %d, HeaderSize %d", BufferPtr->DataBufferStart, BufferPtr->DataOffset, BufferPtr->DataSize, BufferPtr->HeaderSize); if (BufferPtr->StatusCode == IPC_BUFFER_STATUS_FREE) { IPC_TRACE(IPC_Channel_General, " ", "Free FreeTime %d, prevAllocTime %d, prevSendTime %d", BufferPtr->TimeStampFree, BufferPtr->TimeStampAlloc, BufferPtr->TimeStampSend, 0); } else if (BufferPtr->StatusCode == IPC_BUFFER_STATUS_ALLOC) { IPC_TRACE(IPC_Channel_General, " ", "Alloc AllocTime %d, prevSendTime %d, prevFreeTime %d", BufferPtr->TimeStampAlloc, BufferPtr->TimeStampSend, BufferPtr->TimeStampFree, 0); } else if (BufferPtr->StatusCode == IPC_BUFFER_STATUS_SENT) { IPC_TRACE(IPC_Channel_General, " ", "Sent SendTime %d, AllocTime %d, prevFreeTime %d", BufferPtr->TimeStampSend, BufferPtr->TimeStampAlloc, BufferPtr->TimeStampFree, 0); } else { IPC_TRACE(IPC_Channel_General, " ", "Invalid Status", 0, 0, 0, 0); } IPC_TRACE(IPC_Channel_General, " ", "Data 0..3 %08X %08X %08X %08X", DataPtr[0], DataPtr[1], DataPtr[2], DataPtr[3]); IPC_TRACE(IPC_Channel_General, " ", "Data 4..7 %08X %08X %08X %08X", DataPtr[4], DataPtr[5], DataPtr[6], DataPtr[7]); /* Print RPC message ID located at byte 18-19 of IPC buffer */ if (PoolPtr->SourceEndpointId == IPC_EP_Capi2Cp || PoolPtr->DestinationEndpointId == IPC_EP_Capi2Cp) { UInt8 *rpcDataPtr = (UInt8 *)DataPtr; UInt32 rpcMsgId; rpcMsgId = ((UInt32)(rpcDataPtr[19])) | ((UInt32)(rpcDataPtr[18]) << 8); IPC_TRACE(IPC_Channel_General, " ", "RPC message ID %08X", rpcMsgId, 0, 0, 0); } }
//************************************************** IPC_BufferPool IPC_CreateBufferPoolWithDescriptor ( IPC_EndpointId_T SourceEndpointId, IPC_EndpointId_T DestinationEndpointId, IPC_U32 NumberOfBuffers, IPC_U32 BufferSize, IPC_U32 FlowStartLimit, IPC_U32 FlowStopLimit, IPC_U32 LocalDescriptorSize ) { IPC_U32 MaxDataSize = ALIGN4 (BufferSize); IPC_BufferPool Pool; IPC_BufferPool_T * PoolPtr; IPC_Endpoint DestinationEpPtr; IPC_SmPtr Buffer; IPC_U32 Id; char * LocalData; IPC_TRACE (IPC_Channel_Pool, "IPC_CreateBufferPool", "Source %02X, Destination %02X, Buffer Count %d, Buffer Size %d", SourceEndpointId, DestinationEndpointId, NumberOfBuffers, BufferSize); // Sanity Checks if (NumberOfBuffers == 0) { IPC_TRACE (IPC_Channel_Error, "IPC_CreateBufferPool", "Invalid NumberOfBuffers %d", NumberOfBuffers, 0, 0, 0); return 0; } if (!IPC_SmEndpointInfo (SourceEndpointId)) { IPC_TRACE (IPC_Channel_Error, "IPC_CreateBufferPool", "Invalid Source Endpoint %d", SourceEndpointId, 0, 0, 0); return 0; } if (0 == (DestinationEpPtr = IPC_SmEndpointInfo (DestinationEndpointId))) { IPC_TRACE (IPC_Channel_Error, "IPC_CreateBufferPool", "Invalid Destination Endpoint %d", DestinationEndpointId, 0, 0, 0); return 0; } if (FlowStartLimit > NumberOfBuffers) { IPC_TRACE (IPC_Channel_Error, "IPC_CreateBufferPool", "Invalid FlowStartLimit %d", FlowStartLimit, 0, 0, 0); return 0; } if (FlowStopLimit >= NumberOfBuffers) { IPC_TRACE (IPC_Channel_Error, "IPC_CreateBufferPool", "Invalid FlowStopLimit %d", FlowStopLimit, 0, 0, 0); return 0; } // Allocate Sm For Pool Pool = IPC_SmPoolAlloc (sizeof (IPC_BufferPool_T), DestinationEpPtr->MaxHeaderSize, MaxDataSize, NumberOfBuffers); if (!Pool) { IPC_TRACE (IPC_Channel_Error, "IPC_CreateBufferPool", "IPC_SmPoolAlloc Failed", 0, 0, 0, 0); return 0; } if (LocalDescriptorSize != 0) { #ifdef UNDER_LINUX // Use kmalloc instead of OSHEAP_Alloc in Linux platform LocalData = kmalloc ((LocalDescriptorSize * NumberOfBuffers), GFP_KERNEL); #else LocalData = (char *) OSHEAP_Alloc (LocalDescriptorSize * NumberOfBuffers); #endif // UNDER_LINUX if (!LocalData) { IPC_TRACE (IPC_Channel_Error, "IPC_CreateBufferPool", "LocalData OSHEAP_Alloc Failed", 0, 0, 0, 0); return 0; } } else { LocalData = 0; } // Initialise Pool PoolPtr = IPC_PoolPtr(Pool); PoolPtr->Cpu = IPC_SM_CURRENT_CPU; PoolPtr->SourceEndpointId = SourceEndpointId; PoolPtr->DestinationEndpointId = DestinationEndpointId; PoolPtr->MaxDataSize = MaxDataSize; PoolPtr->MaxHeaderSize = DestinationEpPtr->MaxHeaderSize; PoolPtr->FlowStartLimit = FlowStartLimit; PoolPtr->FlowStopLimit = FlowStopLimit; PoolPtr->FlowControlState = IPC_FLOW_START; PoolPtr->FlowControlCallPending = IPC_FALSE; PoolPtr->FreeBuffers = NumberOfBuffers; PoolPtr->MaxBuffers = NumberOfBuffers; PoolPtr->LowWaterMark = NumberOfBuffers; PoolPtr->NextPool = 0; PoolPtr->BufferFreeFunction = NULL; PoolPtr->AllocationFailures = 0; PoolPtr->Allocations = 0; PoolPtr->BytesSent = 0; PoolPtr->FlowStopCalls = 0; PoolPtr->FlowStartCalls = 0; PoolPtr->EmptyEvent = IPC_EVENT_CREATE; IPC_QInitialise (IPC_SmOffset(&PoolPtr->FreeBufferQ), Pool); IPC_QInitialise (IPC_SmOffset(&PoolPtr->AllocatedBufferQ), Pool); // Initialise Buffers in pool Buffer = Pool + sizeof (IPC_BufferPool_T); for (Id = 0; Id < NumberOfBuffers; Id++) { IPC_BufferToPtr (Buffer)->LocalData = LocalData; LocalData += LocalDescriptorSize; IPC_QAddBack (Buffer, IPC_POOLFreeQ(Pool)); Buffer = IPC_BufferInitialise (Pool, Buffer, Id, PoolPtr->MaxHeaderSize, MaxDataSize); } // For Debug { IPC_PoolList_T * EpPools = &PoolList [PoolPtr->SourceEndpointId]; if (EpPools->Count < IPC_POOLLIST_LENGTH) { EpPools->Pool [EpPools->Count++] = PoolPtr; } } IPC_TRACE (IPC_Channel_Pool, "IPC_CreateBufferPool", "Pool %08X", Pool, 0, 0, 0); return Pool; }
void IPC_BufferDone(IPC_Buffer Buffer) { IPC_Buffer_T *BufferPtr = IPC_BufferToPtr(Buffer); IPC_BufferReturnToPool(Buffer, BufferPtr->Pool); }