sgbufferCreateExit4 :
	objectlistDelete ( 
		&Manager->List, 
		SGBuffer,
		SGBuffer->SGBufferNumber );


sgbufferCreateExit3 :
	namespaceDestroy ( SGBuffer->NameSpaceHandle );

sgbufferCreateExit2 :
	objectFree ( SGBuffer );

sgbufferCreateExit1 :
	return StatusCode;
}

TMStatus	sgbufferDestroy ( 
	UInt32 SGBufferHandle )
{
	SGBufferManagerObject*	SGBufferManager;
	SGBufferObject*	SGBuffer =
		(SGBufferObject*) SGBufferHandle;
	UInt32	NameSpaceHandle;

	if ( objectValidate ( SGBuffer, SGBufferFourCC ) != True )
	{
		DPF(0,("tmman:sgbufferDestroy:objectValidate:FAIL\n"));
		return statusInvalidHandle;
	}

	SGBufferManager = (SGBufferManagerObject* )SGBuffer->SGBufferManager;
	NameSpaceHandle = SGBuffer->NameSpaceHandle;


	memoryDestroy ( SGBuffer->MemoryHandle );

	pagetableDestroy ( SGBuffer->PageTableHandle );

	memFree ( SGBuffer->PageTableBuffer );

	objectlistDelete ( 
		&SGBufferManager->List, 
		SGBuffer,
		SGBuffer->SGBufferNumber );

	namespaceDestroy ( NameSpaceHandle );

	objectFree ( SGBuffer );

	return statusSuccess;
}

	
#else /* TARGET */

TMStatus	sgbufferOpen ( 
	UInt32	SGBufferManagerHandle, 
	Pointer	ListHead,
	Int8*	Name,
	UInt32*	EntryCountPointer,
	UInt32* SizePointer,
	UInt32*	SGBufferHandlePointer )
{
	SGBufferManagerObject*	Manager = (SGBufferManagerObject*)SGBufferManagerHandle;
	SGBufferObject*			Object;
	UInt8			MemoryName[constTMManNameSpaceNameLength];
	UInt32			Dummy, Idx;
	TMStatus		StatusCode;

	if ( objectValidate ( Manager, SGBufferManagerFourCC ) != True )
	{
		DPF(0,("tmman:sgbufferOpen:objectValidate:FAIL\n"));
		return statusInvalidHandle;
	}

	if ( ( Object = objectAllocate (
		sizeof ( SGBufferObject ), SGBufferFourCC ) ) == Null )
	{
		DPF(0,("tmman:sgbufferOpen:objectAllocate:FAIL\n" ));
		StatusCode = statusObjectAllocFail;
		goto sgbufferOpenExit2;	
	}

	if ( ( StatusCode = namespaceCreate  (
		Manager->NameSpaceManagerHandle,
		constTMManNameSpaceObjectSGBuffer,
		Name,
		&Object->SGBufferNumber,
		&Object->NameSpaceHandle ) ) != statusSuccess )
	{
		DPF(0,("tmman:sgbufferOpen:namespaceCreate:FAIL[%x]\n", 
			StatusCode ));
		goto sgbufferOpenExit1;	
	}

	if ( objectlistInsert ( 
		&Manager->List, 
		Object,
		Object->SGBufferNumber ) != True )
	{
		DPF(0,("tmman:sgbufferOpen:objectlistInsert:FAIL\n" ));
		StatusCode = statusObjectInsertFail;
		goto sgbufferOpenExit3;	
	}

	strSprintf ( MemoryName, "%d\\%s", 
		constTMManNameSpaceObjectSGBuffer, Name );

	if ( ( StatusCode = memoryOpen (
		Manager->MemoryManagerHandle,
		ListHead,
		MemoryName, 
		&Dummy,
		(Pointer *)&Object->Control,
		&Object->MemoryHandle ) ) != statusSuccess )
	{
		DPF(0,("tmman:sgbufferOpen:memoryOpen:FAIL[%x]\n",StatusCode ));
		goto sgbufferOpenExit4;
	}

	/* 
		the first entry contains the length of the entire buffer 
		and the number of PTEs 
	*/

	halAccessEnable( Manager->HalHandle );

	Object->BufferSize = halAccess32 ( Manager->HalHandle, 
		Object->Control->RunLength );

	Object->EntryCount = halAccess32 ( Manager->HalHandle,
		Object->Control->PhysicalAddress );

	halAccessDisable( Manager->HalHandle );

	Object->CurrentEntry = 0;
	Object->CurrentOffset = 0;
	Object->SGBufferManager = Manager;
	Object->Entries = Object->Control + 1;

	DPF(0,("tmman:sgbufferOpen:EntryCount[%x]:BufferSize[%x]\n", Object->EntryCount, Object->BufferSize ));

	for ( Idx = 0 ; Idx < Object->EntryCount ; Idx++ )
	{
		halAccessEnable( Manager->HalHandle );

		DPF(0,("tmman:sgbufferOpen:Entry[%x]:PhysicalAddress[%x]:RunLength[%x]\n", 
			Idx, Object->Entries[Idx].PhysicalAddress, Object->Entries[Idx].RunLength ));

		halAccessDisable( Manager->HalHandle );


	}


	*EntryCountPointer		= Object->EntryCount;
	*SizePointer			= Object->BufferSize;
	*SGBufferHandlePointer = (UInt32)Object;

	return statusSuccess;

/*
sgbufferOpenExit5 :
	memoryClose ( Object->MemoryHandle );
*/

sgbufferOpenExit4 :
	objectlistDelete ( 
		&Manager->List, 
		Object,
		Object->SGBufferNumber );

sgbufferOpenExit3 :
	namespaceDestroy ( Object->NameSpaceHandle );

sgbufferOpenExit2 :
	objectFree ( Object );

sgbufferOpenExit1 :
	return StatusCode;
}

TMStatus	sgbufferClose (
	UInt32	SGBufferHandle )
{
	SGBufferObject*	Object =	(SGBufferObject*)SGBufferHandle;
	SGBufferManagerObject *Manager;

	if ( objectValidate ( Object, SGBufferFourCC ) != True )
	{
		DPF(0,("tmman:sgbufferClose:objectValidate:FAIL\n"));
		return statusInvalidHandle;
	}

	Manager = (SGBufferManagerObject* )Object->SGBufferManager;

	memoryClose ( Object->MemoryHandle );

	objectlistDelete ( 
		&Manager->List, 
		Object,
		Object->SGBufferNumber );

	namespaceDestroy ( Object->NameSpaceHandle );

	objectFree ( Object );


	return statusSuccess;
}


TMStatus	sgbufferFirstBlock ( 
	UInt32	SGBufferHandle,
	UInt32* OffsetPointer, 
	UInt32* AddressPointer, 
	UInt32* SizePointer )
{
	/* remote object - this object exists on the host */
	SGBufferObject*	Object = (SGBufferObject*)SGBufferHandle;

	if ( objectValidate ( Object, SGBufferFourCC ) != True )
	{
		DPF(0,("tmman:sgbufferFirstBlock:objectValidate:FAIL\n"));
		return statusInvalidHandle;
	}

	Object->CurrentEntry = 0;
	Object->CurrentOffset = 0;

	return	sgbufferNextBlock ( 
		SGBufferHandle,
		OffsetPointer, 
		AddressPointer, 
		SizePointer );
}


TMStatus	sgbufferNextBlock ( 
	UInt32	SGBufferHandle,
	UInt32* OffsetPointer, 
	UInt32* AddressPointer, 
	UInt32* SizePointer )
{
	/* remote object - this object exists on the host */
	SGBufferObject*	Object = (SGBufferObject*)SGBufferHandle;
	SGBufferManagerObject*	Manager = (SGBufferManagerObject*)Object->SGBufferManager;

	if ( objectValidate ( Object, SGBufferFourCC ) != True )
	{
		DPF(0,("tmman:sgbufferNextBlock:objectValidate:FAIL\n"));
		return statusInvalidHandle;
	}

	if ( Object->EntryCount == 0 )
	{
		DPF(0,("tmman:sgbufferNextBlock:ZERO EntryCount:FAIL\n"));
		return statusSGBufferInvalidPageTable;
	}

	if ( Object->CurrentEntry >= Object->EntryCount )
	{
		DPF(0,("tmman:sgbufferNextBlock:CurrentEntry[%x] INVALID:FAIL\n",
			Object->CurrentEntry ));
		return statusSGBufferNoMoreEntries;
	}

	*OffsetPointer = Object->CurrentOffset;
	
	halAccessEnable( Manager->HalHandle );

	*AddressPointer = halAccess32( Manager->HalHandle, 
		Object->Entries[Object->CurrentEntry].PhysicalAddress );
	*SizePointer = halAccess32 ( Manager->HalHandle,
		Object->Entries[Object->CurrentEntry].RunLength );
	
	halAccessDisable( Manager->HalHandle );

	/* prepare for the call to sgbufferNextBlock */
	Object->CurrentOffset += Object->Entries[Object->CurrentEntry].RunLength;
	Object->CurrentEntry++;

	return statusSuccess;

}

TMStatus	sgbufferCopy ( 
	UInt32	SGBufferHandle,
	UInt32	Offset,
	UInt32	Address, 
	UInt32	Size, 
	UInt32	Direction )
{

	UInt32	IdxPTE;
	UInt32	BlockSize;		/* size for the current memcopy */
	UInt32	BlockStart;		/* offset from the beginning of the buffer */
	UInt32	BytesCopied;	/* bytes memcopied so far */
	SGBufferObject*	Object = (SGBufferObject*)SGBufferHandle;
	SGBufferManagerObject*	Manager = (SGBufferManagerObject*)Object->SGBufferManager;

	if ( objectValidate ( Object, SGBufferFourCC ) != True )
	{
		DPF(0,("tmman:sgbufferCopy:objectValidate:FAIL\n"));
		return statusInvalidHandle;
	}

	if ( Object->EntryCount == 0 )
	{
		DPF(0,("tmman:sgbufferCopy:ZERO EntryCount:FAIL\n"));
		return statusSGBufferInvalidPageTable;
	}

	if ( Offset > Object->BufferSize )
	{
		DPF(0,("tmman:sgbufferCopy:Offset[%x] OUT OF RANGE:FAIL\n",
			Offset ));
		return statusSGBufferOffsetOutOfRange;
	}


	/* validate the size requested */
	if ( ( Offset + Size ) >  Object->BufferSize )
	{
		DPF(0,("tmman:sgbufferCopy:Size[%x] OUT OF RANGE:FAIL\n",
			Size ));
		return statusSGBufferSizeOutOfRange;
	}

	/* base linear address of the buffer */
	BlockStart = 0;
	BytesCopied = 0;

	for ( IdxPTE = 0 ; IdxPTE < Object->EntryCount ; IdxPTE ++)
	{
		UInt32		PhysicalAddress, RunLength;
		
		halAccessEnable( Manager->HalHandle );

		RunLength = halAccess32 ( Manager->HalHandle, 
			Object->Entries[IdxPTE].RunLength );

		PhysicalAddress = halAccess32 ( Manager->HalHandle, 
			Object->Entries[IdxPTE].PhysicalAddress );

		halAccessDisable( Manager->HalHandle );

		/* offset is from the begining of the entire buffer */
		if ( ( Offset >=  BlockStart  )  && 
			( Offset <= ( BlockStart + RunLength ) ) )
		{
			/* we found the first PTE encompassing the offset */
			/* Offset points to the middle of the current block */
			BlockSize = RunLength - ( Offset - BlockStart );

			halAccessEnable( Manager->HalHandle );

			/* this is the first copy so bytes copied is assumed to be 0 */
			if ( Direction ) /* host to target */
			{
				memCopy ( 
					Address, 
					PhysicalAddress + RunLength - BlockSize,
					BlockSize );
			}
			else
			{
				memCopy ( 
					PhysicalAddress + RunLength - BlockSize,
					Address,
					BlockSize );

			}

			halAccessDisable( Manager->HalHandle );

			BlockStart += RunLength;

			BytesCopied = BlockSize;

			break;
		}

		/* 
			if Offset does not fall in this range increment BlockStart by the 
			length of the current block. 
		*/
		BlockStart += RunLength; 
	}

	for ( IdxPTE++ ; IdxPTE < Object->EntryCount ; IdxPTE ++)
	{
		UInt32		PhysicalAddress, RunLength;

		halAccessEnable( Manager->HalHandle );

		RunLength = halAccess32 ( Manager->HalHandle, 
			Object->Entries[IdxPTE].RunLength );

		PhysicalAddress = halAccess32 ( Manager->HalHandle, 
			Object->Entries[IdxPTE].PhysicalAddress );

		halAccessDisable( Manager->HalHandle );

		/* 
			check if this is the last block we have to deal with,
			the last block may be partial
		*/
		if ( ( ( Offset + Size ) >=  BlockStart  )  && 
			( ( Offset + Size ) <= ( BlockStart + RunLength ) ) )
		{
			/* we found the last PTE encompassing the ( offset + size ) */
			/* ( Offset + Size ) points to the middle of the current block */
			BlockSize = ( Offset + Size ) - BlockStart ;

			halAccessEnable( Manager->HalHandle );

			if ( Direction )
			{
				memCopy ( 
					(Pointer)( Address + BytesCopied), 
					(Pointer)PhysicalAddress,
					BlockSize );
			}
			else
			{
				memCopy ( 
					(Pointer)PhysicalAddress,
					(Pointer)( Address + BytesCopied), 
					BlockSize );

			}

			halAccessDisable( Manager->HalHandle );

			BytesCopied += BlockSize;

			break;
		}
		else
		{
			/* 
				copy this block entirely , as it does not encompass the begining 
				or end of the buffer
			*/
			halAccessEnable( Manager->HalHandle );

			if ( Direction )
			{

				memCopy ( 
					(Pointer)( Address + BytesCopied ), 
					(Pointer)PhysicalAddress,
					RunLength );
			}
			else
			{
				memCopy (
					(Pointer)PhysicalAddress,
					(Pointer)( Address + BytesCopied ), 
					RunLength );
			}

			halAccessDisable( Manager->HalHandle );

			
			BytesCopied += RunLength;
		}

		BlockStart += RunLength; 
	}

	return statusSuccess;
}

#endif