osal.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.
----------------------------------------------------------------------------*/
/*
	HISTORY
	#define	TR	Tilakraj Roy
	960510	TR 	Created
	961019	TR	Moved the CTC 1.1 bug fix in IRQGen from IRQAck.
	970521	TR	Rewrote for Generic Target TMMan

    Following SCCS macros added by Nadeem:
    
    Module name              : osal.c    1.5 
 
    Last update              : 09:23:06 - 99/02/09
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/
#define WANTVXDWRAPS
#include <basedef.h>
#include <vmm.h>
#include <vmmreg.h>
#include <vxdwraps.h>
#include <vpicd.h>
#include <configmg.h>
#include <vwin32.h>

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

#pragma VxD_LOCKED_CODE_SEG
#pragma	VxD_LOCKED_DATA_SEG

void halAdjustOffset(UInt32	HalHandle,UInt32 *address);

/* Synchronization Object Abstraction Functions */
typedef	struct	tagSynchronizationObject
{
	UInt32	UserModeHandle;
	UInt32	KernelModeHandle;	
	UInt32	SynchronizationFlags;
}	SynchronizationObject;

Bool	syncobjCreate ( 
	UInt32 SynchronizationFlags,
	UInt32	OSSynchronizationHandle,
	UInt32 *SynchronizationHandlePointer,
	Int8* SynchronizationObjectName )
{
	SynchronizationObject* SyncObj;

	if ( ( SyncObj = memAllocate ( 
		sizeof ( SynchronizationObject ) ) ) == NULL )
	{
		goto syncobjCreateExit1;
	}

	SyncObj->SynchronizationFlags =  SynchronizationFlags;

	if ( SynchronizationFlags == constTMManModuleHostUser )
	{
		SyncObj->UserModeHandle =  OSSynchronizationHandle;
	}
	else 
	{
		// assume that it is constTMManModuleHostKernel
		SyncObj->KernelModeHandle = OSSynchronizationHandle;
	}

	*SynchronizationHandlePointer = (UInt32)SyncObj;
	return True;

syncobjCreateExit2:
	memFree ( SyncObj );

syncobjCreateExit1:
	return False;
}

Bool	syncobjSignal ( 
	UInt32 SynchronizationHandle )
{
	SynchronizationObject* SyncObj = (SynchronizationObject*)SynchronizationHandle;

	if ( SyncObj->SynchronizationFlags == constTMManModuleHostUser )
	{
		winVWIN32_SetWin32Event ( 
			SyncObj->UserModeHandle );
	}

	return True;
}

/* user will do his own blokcing 
	we don't provide any blocking functionality 

Bool	syncobjBlock ( 
	UInt32 SynchronizationObject )
{
	WaitForSingleObject ( (HANDLE)SynchronizationObject, INFINITE );
	return True;
}
*/

Bool	syncobjDestroy ( 
	UInt32 SynchronizationHandle )
{
	SynchronizationObject* SyncObj = (SynchronizationObject*)SynchronizationHandle;

	if ( SyncObj->SynchronizationFlags == constTMManModuleHostUser )
	{
		winVWIN32_CloseVxDHandle (SyncObj->UserModeHandle);
	}
	memFree ( SyncObj );

	return True;
}


Bool	critsectCreate ( 
	UInt32* CriticalSectionObjectPointer )
{
	*CriticalSectionObjectPointer = (UInt32)Null;

	return True;
}

Bool	critsectDestroy ( 
	UInt32 CriticalSectionObject )
{
	return True;
}

/* Note that the caller has to allocate storage 
	sizeof (UInt32) for nested context and pass the address
	of that parameter to this function.
*/
Bool	critsectEnter ( 
	UInt32 CriticalSectionObject, Pointer NestedContext )
{
	vxdEnterCritical(NestedContext);
	return True;
}

Bool	critsectLeave ( 
	UInt32 CriticalSectionObject, Pointer NestedContext )
{
	vxdLeaveCritical(*(UInt32*)NestedContext);
	return True;
}

Pointer	clientGetObjectFromProcess ( UInt32 Process )
{
	UInt32 ClientIdx;

	for ( ClientIdx = 0 ; ClientIdx < TMManGlobal->MaximumClients ; ClientIdx ++ )
	{
		if ( !TMManGlobal->ClientList[ClientIdx] )
			continue;

		if ( ((ClientObject*)TMManGlobal->ClientList[ClientIdx])->Process != Process )
			continue;
		break;
	}

	if ( ClientIdx == TMManGlobal->MaximumClients )
	{
		return Null;
	}

	return (Pointer)TMManGlobal->ClientList[ClientIdx];
}

Pointer clientGetDeviceObjectFromClient ( Pointer Client, UInt32 DSPNumber )
{

}

/*
	Page Table Routines
*/

typedef struct _EDDS
{
    DWORD   dwSize;
    DWORD   dwLinear;
    WORD    wSegment;
    WORD    wReserved;
    WORD    wAvailable;
    WORD    wUsed;
    PageTableEntry     PageTable[1];
}   EDDS, *PEDDS;

UInt32	pagetableGetTempBufferSize ( 
	UInt32 BufferAddress, UInt32 BufferSize )
{
	// ADDRESS_AND_SIZE_TO_SPAN_PAGES
	return ( ( ( BufferSize >> 12 ) + 2 ) * sizeof(PageTableEntry) ) + sizeof ( EDDS );
}

Bool	pagetableCreate ( 
	UInt32 BufferAddress,
	UInt32 BufferSize,
	Pointer TempBuffer,
	UInt32	HalHandle,
	PageTableEntry	**PageTablePointer,
	UInt32 *PageTableEntryCountPointer,
	UInt32 *PageTableHandlePointer )
{
    WORD    i;
	PEDDS	EddsPtr = TempBuffer;

	EddsPtr->dwSize		= BufferSize;
	EddsPtr->dwLinear	= (DWORD)BufferAddress;
	EddsPtr->wSegment	= 0;
/*	EddsPtr->wAvailable	= ( ( ( BufferSize >> 12 ) + 2 ) * sizeof(PageTableEntry) ); */
	EddsPtr->wAvailable	= ( ( BufferSize >> 12 ) + 2 ) ;

	//lock the applications buffer
	if ( winVDMAD_Scatter_Lock ( winGet_Sys_VM_Handle(), 0, EddsPtr ) !=
		STATUS_SUCCESS )
	{
		DPF(0,("pagetableCreate:VDMAD_Scatter_Lock:Buffer:FAIL\n"));
		goto pagetableCreateExit1;
	}	


	*PageTablePointer = &EddsPtr->PageTable[0];
	*PageTableEntryCountPointer = EddsPtr->wUsed;

    for(i=0;i<EddsPtr->wUsed;i++)
        halAdjustOffset(HalHandle,&(EddsPtr->PageTable[i].PhysicalAddress));
	*PageTableHandlePointer  = (UInt32)EddsPtr;

	return True;

pagetableCreateExit1:
	return False;
}

Bool	pagetableDestroy ( 
	UInt32 PageTableHandle )
{
	PEDDS	EddsPtr = (PEDDS)PageTableHandle;

	if ( winVDMAD_Scatter_Unlock ( winGet_Sys_VM_Handle(), 0, EddsPtr ) !=
		STATUS_SUCCESS )
	{
		DPF(0,("sgBufferUnlock:VDMAD_Scatter_Unlock:Buffer:FAIL\n"));
		return False;
	}

	return True;
}



Pointer	sectionMapPhysicalAddress ( 
	UInt32 Address, 
	UInt32 Length,
	UInt32 *SectionHandlePointer )
{
	*SectionHandlePointer = Address;
	return Address;
}

void	sectionUnmapPhysicalAddress ( 
	Pointer UserModeVirtualAddress, 
	UInt32 SectionHandle )
{
}