namespc.c

PNX系列设备驱动 PNX系列设备驱动

/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1997 by Philips Semiconductors

THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED AND COPIED IN 
ACCORDANCE WITH THE TERMS AND CONDITIONS OF SUCH A LICENSE AND WITH THE 
INCLUSION OF THE THIS COPY RIGHT NOTICE. THIS SOFTWARE OR ANY OTHER COPIES 
OF THIS SOFTWARE MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY OTHER
PERSON. THE OWNERSHIP AND TITLE OF THIS SOFTWARE IS NOT TRANSFERRED. 

THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT ANY PRIOR NOTICE
AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY Philips Semiconductor. 

PHILIPS ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF THIS SOFTWARE
ON PLATFORMS OTHER THAN THE ONE ON WHICH THIS SOFTWARE IS FURNISHED.
----------------------------------------------------------------------------*/
/*
	namespace.c

	Pvides a mechanism for the operating system running on one processor
	to signal the operating system running on another processor.

	HISTORY
	#define	TR	Tilakraj Roy
	960530	TR 	Created
	960905	TR	Pulled in from host channel sources
	960907	TR	Moved packet queuing to higher layer
	960924	TR	Pulled in mailbox sources from IPC 
	961019	TR	Enabled in the new interface stuff.
	970520	TR	Generic Host-Communication for Apple
	970707	TR	Pulled in form the Channel and VIntr sources.
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/

/*----------------------------------------------------------------------------
          DRIVER SPECIFIC INCLUDE FILES
----------------------------------------------------------------------------*/
#include "tmmanapi.h"
#include "tmmanlib.h"


/*	CONSTANTS */

#define		NameSpaceManagerFourCC		tmmanOBJECTID ( 'N', 'M', 'S', 'M' )
#define		NameSpaceFourCC				tmmanOBJECTID ( 'N', 'M', 'S', 'O' )

/* TYPDEFS */


typedef struct tagNameSpaceControl
{
	UInt32	volatile	ObjectType;
	UInt32	volatile	ObjectIndex;
	UInt8	volatile	Name[constTMManNameSpaceNameLength];
}	NameSpaceControl;

typedef struct tagNameSpaceObject
{
	GenericObject		Object;
	Pointer				NameSpaceManager;
	UInt32				NameSpaceNumber;
	UInt32				ObjectId;
	UInt32				ControlObjectType;
	UInt32				ControlObjectIndex;
	UInt8				ControlName[constTMManNameSpaceNameLength];
}	NameSpaceObject;

typedef struct tagNameSpaceManagerObject
{
	GenericObject			Object;
	ObjectList				List;
	UInt32					NameSpaceCount;
	UInt8*					SharedData;
	NameSpaceControl*		Control;
	UInt32					HalHandle;
	UInt32					CriticalSectionHandle;
}	NameSpaceManagerObject;


/* GLOBAL DATA STRUCTURES */
/* NONE - key to object oriented programming */


/* FUNCTIONS */
void namespaceDump ( UInt32 NameSpaceHandle );

UInt32	namespaceSharedDataSize ( 
	UInt32 NameSpaceCount )
{
	return  ( ( sizeof ( NameSpaceControl ) * NameSpaceCount ) );
}

TMStatus	namespaceManagerCreate ( 
	namespaceManagerParameters* Parameters,
	UInt32* NameSpaceManagerHandle )
{
	TMStatus		StatusCode;

	NameSpaceManagerObject*	NameSpaceManager;

	if ( ( NameSpaceManager = objectAllocate ( 
		sizeof ( NameSpaceManagerObject ),
		NameSpaceManagerFourCC ) ) == Null )
	{
		DPF(0,("tmman:namespaceManagerCreate:objectAllocate:FAIL\n"));
		StatusCode = statusObjectAllocFail; 
		goto namespaceManagerCreateExit1;
	}
	
	NameSpaceManager->NameSpaceCount			= Parameters->NameSpaceCount;
	NameSpaceManager->SharedData			= (UInt8*)Parameters->SharedData;
	NameSpaceManager->HalHandle				= Parameters->HalHandle;
	


	NameSpaceManager->Control = (NameSpaceControl*)NameSpaceManager->SharedData; 
	
	if ( objectlistCreate ( &NameSpaceManager->List,  
		NameSpaceManager->NameSpaceCount ) != True )
	{
		DPF(0,("tmman:namespaceManagerCreate:objectlistCreate:FAIL\n"));
 
		StatusCode = statusObjectListAllocFail;
		goto	namespaceManagerCreateExit2;
	}

	
	if ( critsectCreate ( &NameSpaceManager->CriticalSectionHandle ) == False )
	{
		DPF(0,("tmman:namespaceManagerCreate:critsectCreate:FAIL\n"));
		StatusCode = statusCriticalSectionCreateFail;
		goto namespaceManagerCreateExit3;
	}

#ifdef TMMAN_HOST
/*	namespaceManagerReset ( (UInt32)NameSpaceManager ); */
#endif


	*NameSpaceManagerHandle  = (UInt32)NameSpaceManager;

	return statusSuccess;
/*
namespaceManagerCreateExit4:
	critsectDestroy ( Manager->CriticalSectionHandle );
*/

namespaceManagerCreateExit3:
	objectlistDestroy ( &NameSpaceManager->List );

namespaceManagerCreateExit2:
	objectFree ( NameSpaceManager );

namespaceManagerCreateExit1:
	return StatusCode;
}

TMStatus	namespaceManagerDestroy ( 
	UInt32 NameSpaceManagerHandle )
{
	NameSpaceManagerObject* NameSpaceManager = 
		( NameSpaceManagerObject* )NameSpaceManagerHandle;

	if ( objectValidate ( NameSpaceManager, NameSpaceManagerFourCC ) != True )
	{
		DPF(0,("tmman:namespaceManagerDestroy:objectValidate:FAIL\n"));
		return statusInvalidHandle;
	}

	objectlistDestroy ( &NameSpaceManager->List );

	objectFree ( NameSpaceManager );

	return statusSuccess;
}

TMStatus	namespaceManagerReset ( 
	UInt32 NameSpaceManagerHandle  )
{
	NameSpaceManagerObject	*Manager = 
		( NameSpaceManagerObject* )NameSpaceManagerHandle;
	NameSpaceObject *Object;

	UInt32 Idx;
	UInt32	NestedContext;

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

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

        Manager->Control[Idx].ObjectType =
            halAccess32 ( Manager->HalHandle, constTMManNameSpaceObjectInvalid );
        Manager->Control[Idx].ObjectIndex =
            halAccess32 ( Manager->HalHandle, 0 );

		halAccessDisable( Manager->HalHandle );
	}

	for ( Idx = 0 ; Idx < Manager->NameSpaceCount ; Idx ++ )
	{
		if ( ( Object = objectlistGetObject (
			&Manager->List, 
			Idx ) ) != Null )
		{
			halAccessEnable(Manager->HalHandle);

			Manager->Control[Idx].ObjectType = 
				halAccess32 ( Manager->HalHandle, Object->ControlObjectType );

			Manager->Control[Idx].ObjectIndex = 
				halAccess32 ( Manager->HalHandle, Object->ControlObjectIndex );
			

			strCopy( (Pointer)Manager->Control[Idx].Name, 
				(Pointer)Object->ControlName );

			halAccessDisable(Manager->HalHandle);
		}
	}
	
	return statusSuccess;
}




TMStatus	namespaceCreate (
	UInt32	NameSpaceManagerHandle,						
	UInt32	NameSpaceObjectType,
	Int8*	NameSpaceName,
	UInt32*	ObjectIdPointer,
	UInt32* NameSpaceHandlePointer )
{
	NameSpaceManagerObject* Manager = 
		( NameSpaceManagerObject* )NameSpaceManagerHandle;
	NameSpaceObject*	NameSpace;
	TMStatus			Status;
	UInt32				SlotIdx, ObjectIdx, Idx;
	UInt32				NestedContext;


	DPF(9,("tmman:namespaceCreate:Type[%x]:Name[%s]\n",
			NameSpaceObjectType,
			NameSpaceName ));

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

	/*
	for ( Idx = 0 ; Idx < Manager->NameSpaceCount ; Idx ++ )
	{
		NameSpaceObject *Object;

		if ( ( Object = objectlistGetObject (
			&Manager->List, 
			Idx ) ) != Null )
		{
			namespaceDump(Object);

		}
	}
	*/

#ifdef TMMAN_HOST

	/* ENTER CRITICAL SECTION */
	critsectEnter ( Manager->CriticalSectionHandle, &NestedContext );

	/* 
		find a slot (empty local name space object) that we can use 
		this should be the same as the shared slot index
	*/	
	for ( SlotIdx = 0 ; SlotIdx < Manager->NameSpaceCount ; SlotIdx ++ )
	{

		if ( objectlistGetObject (
			&Manager->List, 
			SlotIdx ) == Null )
			break;
	}

	/* we couldn't find empty slots so bail out */
	if ( SlotIdx >= Manager->NameSpaceCount )
	{
		DPF(0,("tmman:namespaceCreate:SlotIdx[%x]:OUT OF EMPTY SLOTS:FAIL\n",
			SlotIdx ));
		Status = statusNameSpaceNoMoreSlots;