namespc.c

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

		/* LEAVE CRITICAL SECTION */
		critsectLeave ( Manager->CriticalSectionHandle, &NestedContext );
		goto	namespaceCreateExit1;
	}

	/* find the ID relative to the type of object we are looking for */
	for ( ObjectIdx = 0 ; ; ObjectIdx++ )
	{
		Bool	IDFound = False;

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

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


				/* a different type of object */
				if ( NameSpaceObjectType != Object->ControlObjectType )
					continue;

				
				/* same type of object with a different ID */
				if ( ObjectIdx != Object->ControlObjectIndex )
					continue;

				/* name space conflict */
				if ( strCmp ( NameSpaceName, 
					(Pointer)Object->ControlName ) == 0 )
				{
					DPF(0,("tmman:namespaceCreate:NameSpace[%s]:CONFLICT:FAIL\n",
						NameSpaceName ));

					/* this name already exists for this object so stop */
					Status = statusNameSpaceNameConflict;
					/* LEAVE CRITICAL SECTION */
					critsectLeave ( Manager->CriticalSectionHandle, &NestedContext );
					goto	namespaceCreateExit1;
				}

				/* Id exists - so increment ObjectIdx and start search again */
				break;
			}
		}

		/* check if have reached the end without colliding with the ID */
		if ( Idx >= Manager->NameSpaceCount ) 
		{
			/* we have found an ObjectIdx that is not present */
			IDFound = True;
			break;
		}

		/* otherwise increment and try the search again */
	}
	
	/* this loop always exists with some Object Idx that is not already present */

	/* copy the shared control data */
	halAccessEnable( Manager->HalHandle );

	Manager->Control[SlotIdx].ObjectType = 
		halAccess32 ( Manager->HalHandle, NameSpaceObjectType );
	Manager->Control[SlotIdx].ObjectIndex = 
		halAccess32 ( Manager->HalHandle, ObjectIdx );

	halAccessDisable( Manager->HalHandle );


	halAccessEnable( Manager->HalHandle );
	strCopy( (Pointer)Manager->Control[SlotIdx].Name, NameSpaceName );
	halAccessDisable( Manager->HalHandle );


	
#else	/* TMMAN_TARGET */


	for ( SlotIdx = 0 ; SlotIdx < Manager->NameSpaceCount ; SlotIdx ++ )
	{
		UInt32	StrCmpResult, ObjectType, ObjectIndex;
		UInt8	ObjectName[constTMManNameSpaceNameLength];


		halAccessEnable( Manager->HalHandle );

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

		strCopy( (Pointer)ObjectName, (Pointer) Manager->Control[SlotIdx].Name );

		halAccessDisable( Manager->HalHandle );

		if ( ObjectType != 	constTMManNameSpaceObjectInvalid )
		{
			DPF(0,("tmman:TARGET:namespaceCreate:Slot#[%x]:Type[%x]:Idx[%x]:Name[%s]\n",
				SlotIdx, 
				ObjectType,
				ObjectIndex,
				ObjectName ));
		}
		else
		{
			continue;
		}


		if ( ObjectType  != NameSpaceObjectType )
			continue;
		
		/* BUGCHECK : Strcmp performs bytes accesses over the PCI bus */
		halAccessEnable( Manager->HalHandle );

		StrCmpResult = strCmp ((Pointer)Manager->Control[SlotIdx].Name, 
			NameSpaceName );

		halAccessDisable( Manager->HalHandle );

		if ( StrCmpResult == 0 )
		{
			break;
		}
	}


	if ( SlotIdx >= Manager->NameSpaceCount )
	{
		DPF(0,("tmman:namespaceCreate:Name[%s]:NON EXISTENT:FAIL\n",
			NameSpaceName ));
		Status = statusNameSpaceNameNonExistent;
		goto	namespaceCreateExit1;
	}

#endif

	if ( ( NameSpace = objectAllocate (
		sizeof ( NameSpaceObject ), NameSpaceFourCC ) ) == Null )
	{
		DPF(0,("tmman:namespaceCreate:objectAllocate:FAIL\n"));
		Status = statusObjectAllocFail;
		goto namespaceCreateExit2;	
	}

	if ( objectlistInsert ( 
		&Manager->List, 
		NameSpace,
		SlotIdx ) != True )
	{
		DPF(0,("tmman:namespaceCreate:objectlistInsert:FAIL\n"));
		Status = statusObjectInsertFail;
		goto namespaceCreateExit3;	
	}

	NameSpace->NameSpaceManager = Manager;
	NameSpace->NameSpaceNumber = SlotIdx;

#ifdef TMMAN_HOST

	/* LEAVE CRITICAL SECTION */
	critsectLeave ( Manager->CriticalSectionHandle, &NestedContext );

	NameSpace->ObjectId = ObjectIdx;
	/*
	save the shared (control) data in our local object  for 
	using it at the time of reset, when endianess is known
	*/
	NameSpace->ControlObjectType = NameSpaceObjectType;
	NameSpace->ControlObjectIndex = ObjectIdx;
	strCopy( (Pointer)NameSpace->ControlName, NameSpaceName );

#else

	halAccessEnable( Manager->HalHandle );

	NameSpace->ObjectId = 
		halAccess32 ( Manager->HalHandle, 
		Manager->Control[SlotIdx].ObjectIndex );

	halAccessDisable( Manager->HalHandle );

#endif

	DPF(9,("tmman:namespaceCreate:Slot#[%x]:Type[%x]:Idx[%x]:Name[%s]\n",
		SlotIdx, 
		NameSpaceObjectType,
		NameSpace->ObjectId,
		NameSpaceName ));

	*NameSpaceHandlePointer = (UInt32)NameSpace;
	*ObjectIdPointer = NameSpace->ObjectId;

	return statusSuccess;
/*
namespaceCreateExit4 :
	objectlistDelete ( 
		&Manager->List, 
		NameSpace,
		SlotIdx );
*/

namespaceCreateExit3 :
	objectFree ( NameSpace );

namespaceCreateExit2 :

#ifdef TMMAN_HOST
	halAccessEnable( Manager->HalHandle );

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

	halAccessDisable( Manager->HalHandle );

#endif

namespaceCreateExit1 :
	return Status;
}

TMStatus	namespaceDestroy ( 
	UInt32 NameSpaceHandle )
{
	NameSpaceManagerObject*	NameSpaceManager;
	NameSpaceObject*	NameSpace =
		(NameSpaceObject*) NameSpaceHandle;
	UInt32				SlotIdx;
	UInt32				NestedContext;


	if ( objectValidate ( NameSpace, NameSpaceFourCC ) != True )
	{
		DPF(0,("tmman:namespaceDestroy:objectValidate:FAIL\n"));
		return statusInvalidHandle;
	}

	DPF(9,("tmman:namespaceDestroy:Slot#[%x]:Type[%x]:Idx[%x]:Name[%s]\n",
		NameSpace->NameSpaceNumber,
		NameSpace->ControlObjectType,
		NameSpace->ControlObjectIndex,
		NameSpace->ControlName ));

	NameSpaceManager = (NameSpaceManagerObject* )NameSpace->NameSpaceManager;

	SlotIdx = NameSpace->NameSpaceNumber;

	objectlistDelete ( 
		&NameSpaceManager->List, 
		NameSpace,
		NameSpace->NameSpaceNumber );

	objectFree ( NameSpace );

#ifdef TMMAN_HOST
	
	/* ENTER CRITICAL SECTION */
	critsectEnter ( NameSpaceManager->CriticalSectionHandle, &NestedContext );
	
	halAccessEnable( NameSpaceManager->HalHandle );
				
	NameSpaceManager->Control[SlotIdx].ObjectType = 
		halAccess32 ( NameSpaceManager->HalHandle, constTMManNameSpaceObjectInvalid );
	NameSpaceManager->Control[SlotIdx].ObjectIndex = 
		halAccess32 ( NameSpaceManager->HalHandle, 0 );

	halAccessDisable( NameSpaceManager->HalHandle );
			
	/* LEAVE CRITICAL SECTION */
	critsectLeave ( NameSpaceManager->CriticalSectionHandle, &NestedContext );

#endif

	return statusSuccess;
}



void namespaceDump ( UInt32 NameSpaceHandle )
{
	NameSpaceObject*	Object =
		(NameSpaceObject*) NameSpaceHandle;

	DPF(9,("namespaceDump:MAN[%x]:NUM[%x]:OID[%x]:COT[%x]:COI[%x]\n",
		Object->NameSpaceManager,
		Object->NameSpaceNumber,
		Object->ObjectId,
		Object->ControlObjectType,
		Object->ControlObjectIndex ));
}