/*---------------------------------------------------------------------------- 
COPYRIGHT (c) 1998 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
	960510	Tilakraj Roy 	Created
	961019	Tilakraj Roy	Moved the CTC 1.1 bug fix in IRQGen from IRQAck.
	970521	Tilakraj Roy	Rewrote for Generic Target TMMan
	010828	Wim de Haan		Changed code to prevent crash of tmmanSGBufferCreate
							and tmmanSGBuferDestroy. Source: Eric N.							
			Functions pagetableCreate() and pagetableDestroy().  In the creation 
			function is a call to IoMapTransfer(), with a NULL parameter for the 
			DMA adapter object.  While a few older bits of documentation say you 
			can do this for bus-mastering cards that have their own 
			scatter/gather hardware, it is apparently not permissible in WDM.  
			You must pass in the valid adapter object (of which a copy is kept in 
			the HalObject from TMHAL.C).  The same applies to the 
			IoFlushAdapterBuffers() call during destruction.
*/

/*----------------------------------------------------------------------------
          SYSTEM INCLUDE FILES
----------------------------------------------------------------------------*/
#include "stddef.h"
#include "wdm.h"

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

/* 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;
	NTSTATUS	NTStatus;

	if ( ( SyncObj = ExAllocatePool ( 
		NonPagedPool, 
		sizeof ( SynchronizationObject ) ) ) == NULL )
	{
		goto syncobjCreateExit1;
	}

	SyncObj->SynchronizationFlags = SynchronizationFlags;

	if ( SynchronizationFlags == constTMManModuleHostUser )
	{
		SyncObj->UserModeHandle =  OSSynchronizationHandle;
		NTStatus = ObReferenceObjectByHandle (
				(HANDLE)SyncObj->UserModeHandle, 
				STANDARD_RIGHTS_ALL,
				NULL,
				KernelMode,
				(PVOID*)&SyncObj->KernelModeHandle, 
				NULL );
		if ( ! NT_SUCCESS (NTStatus) )
		{
			goto syncobjCreateExit2;
			
		}
	}
	else 
	{
		// assume that it is constTMManModuleHostKernel
		SyncObj->KernelModeHandle = OSSynchronizationHandle;
	}

	*SynchronizationHandlePointer = (UInt32)SyncObj;
	return True;

syncobjCreateExit2:
	ExFreePool ( SyncObj );

syncobjCreateExit1:
	return False;
}

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

	if ( KeSetEvent ( 
		(PKEVENT)SyncObj->KernelModeHandle,
		(KPRIORITY)0,
		 FALSE) == FALSE )
	{
		return False;
	}
	else
	{
		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 )
	{
		ObDereferenceObject ( (PVOID)SyncObj->KernelModeHandle );
	}
	ExFreePool ( SyncObj );

	return True;
}


Bool	critsectCreate ( 
	UInt32* CriticalSectionObjectPointer )
{
	PKSPIN_LOCK SpinLock;

	SpinLock = ExAllocatePool(NonPagedPool , sizeof(KSPIN_LOCK) );

	if ( ! SpinLock  )
		return False;

	KeInitializeSpinLock ( (PKSPIN_LOCK)SpinLock );

	*CriticalSectionObjectPointer = (UInt32)SpinLock;

	return True;
}

Bool	critsectDestroy ( 
	UInt32 CriticalSectionObject )
{
	ExFreePool ( (Pointer) 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 )
{
	KeAcquireSpinLock ( (PKSPIN_LOCK)CriticalSectionObject, 
		(PKIRQL)NestedContext );
	return True;
}

Bool	critsectLeave ( 
	UInt32 CriticalSectionObject, Pointer NestedContext )
{
	KeReleaseSpinLock ( (PKSPIN_LOCK)CriticalSectionObject, 
		*((PKIRQL)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 != 
			(PEPROCESS)Process )
			continue;
		break;
	}

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

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

// Page Table Routines

typedef	struct	tagPageTableObject
{
	KEVENT	Event;
	PMDL	Mdl;
	Pointer	MapRegisterBase;
	UInt32	MapRegisterCount;
	UInt32	HalHandle;
	BOOLEAN	WriteToDevice;
}	PageTableObject;

IO_ALLOCATION_ACTION
pageTableCallbackRoutine(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID MapRegisterBase,
    IN PVOID Context );

UInt32	pagetableGetTempBufferSize ( 
	UInt32 BufferAddress, UInt32 BufferSize )
{
	return ADDRESS_AND_SIZE_TO_SPAN_PAGES ( BufferAddress, BufferSize ) * sizeof(PageTableEntry);
}

Bool	pagetableCreate ( 
	UInt32 BufferAddress,
	UInt32 BufferSize,
	Pointer TempBuffer,
	UInt32	HalHandle,
	PageTableEntry	**PageTablePointer,
	UInt32 *PageTableEntryCountPointer,
	UInt32 *PageTableHandlePointer )
{
	PageTableObject	*PageTableObj;
	UInt32	SizeOfMdl, BytesMapped, Length;
	PUCHAR	CurrentVa;

	SizeOfMdl = MmSizeOfMdl ( (PVOID)BufferAddress, BufferSize );

	if ( ( PageTableObj = 
		memAllocate ( SizeOfMdl + sizeof ( PageTableObject ) ) ) == NULL )
	{
		goto pagetableCreateExit1;
	}
	
	PageTableObj->Mdl = (PMDL)((UInt8*)PageTableObj) + sizeof ( PageTableObject );

	MmInitializeMdl ( PageTableObj->Mdl, BufferAddress, BufferSize );

	PageTableObj->HalHandle = HalHandle;
	PageTableObj->WriteToDevice = TRUE; // BUGCHECK - we have to get this from above.

	__try	{
		MmProbeAndLockPages (
			PageTableObj->Mdl,			// 
			KernelMode,		// KPROCESSOR_MODE
			IoModifyAccess );	// LOCK_OPERATION

	} __except (EXCEPTION_EXECUTE_HANDLER) {
		goto pagetableCreateExit2; 
	}

	KeInitializeEvent(
        &PageTableObj->Event,
        NotificationEvent,
        FALSE );

    KeResetEvent(&PageTableObj->Event);

	// this function waits for the adapter channel to become free
	if ( halAllocateBusMasterChannel ( 
		PageTableObj->HalHandle,
		PageTableObj,
		pageTableCallbackRoutine ) != True )
	{
		goto pagetableCreateExit3; 
	}

    KeWaitForSingleObject(
		&PageTableObj->Event,
		Executive, 
		KernelMode, 
		FALSE, 
		NULL);

	CurrentVa = MmGetMdlVirtualAddress ( PageTableObj->Mdl );

	BytesMapped = Length = MmGetMdlByteCount ( PageTableObj->Mdl );

	for ( PageTableObj->MapRegisterCount = 0 ; 
		Length ; 
		PageTableObj->MapRegisterCount++ )
	{
		PHYSICAL_ADDRESS	PhysicalAddress;
		
		PhysicalAddress = IoMapTransfer (
			((HalObject*)(PageTableObj->HalHandle))->AdapterObject,
			PageTableObj->Mdl,
			PageTableObj->MapRegisterBase,
			CurrentVa,
			&BytesMapped,
			PageTableObj->WriteToDevice );
		((PageTableEntry*)TempBuffer)[PageTableObj->MapRegisterCount].PhysicalAddress = 
			PhysicalAddress.LowPart;
		((PageTableEntry*)TempBuffer)[PageTableObj->MapRegisterCount].RunLength = 
			BytesMapped;

		CurrentVa += BytesMapped;
		Length -= BytesMapped;
		BytesMapped = Length;
	}

	*PageTablePointer = TempBuffer,
	*PageTableEntryCountPointer = PageTableObj->MapRegisterCount,
	*PageTableHandlePointer  = (UInt32)PageTableObj;

	return True;
/*
pagetableExit4:
	halFreeBusMasterChannel (
		PageTableObj->HalHandle, 
		PageTableObj->MapRegisterBase, 
		PageTableObj->MapRegisterCount );
*/
pagetableCreateExit3:
	MmUnlockPages ( PageTableObj->Mdl );

pagetableCreateExit2:
	memFree ( PageTableObj );

pagetableCreateExit1:
	return False;
}

Bool	pagetableDestroy ( 
	UInt32 PageTableHandle )
{
	PageTableObject	*PageTableObj = (PageTableObject*)PageTableHandle;

	IoFlushAdapterBuffers (
		((HalObject*)(PageTableObj->HalHandle))->AdapterObject,
		PageTableObj->Mdl,
		PageTableObj->MapRegisterBase,
		MmGetMdlVirtualAddress ( PageTableObj->Mdl ),
		MmGetMdlByteCount ( PageTableObj->Mdl ),
		PageTableObj->WriteToDevice );

	MmUnlockPages ( PageTableObj->Mdl );

	halFreeBusMasterChannel ( 
		PageTableObj->HalHandle, 
		PageTableObj->MapRegisterBase, 
		PageTableObj->MapRegisterCount );

	memFree ( PageTableObj );

	return True;
}

IO_ALLOCATION_ACTION
pageTableCallbackRoutine(
    IN PDEVICE_OBJECT DeviceObject,
    IN PIRP Irp,
    IN PVOID MapRegisterBase,
    IN PVOID Context
    )
{
	PageTableObject	*PageTableObj = (PageTableObject*)Context;

    UNREFERENCED_PARAMETER( DeviceObject );
    UNREFERENCED_PARAMETER( Irp );

    PageTableObj->MapRegisterBase = MapRegisterBase;

    KeSetEvent(
        &PageTableObj->Event,
        0L,
        FALSE );

    return DeallocateObjectKeepRegisters;
}

Pointer	sectionMapPhysicalAddress ( 
	UInt32 Address, 
	UInt32 Length,
	UInt32 *SectionHandlePointer )
{
	PMDL	Mdl;
	PVOID	UserModeVirtualAddress;

	if ( ( Mdl = IoAllocateMdl (
		(PVOID)Address,
		Length,
		FALSE,
		FALSE,
		NULL ) ) == NULL )
	{
        DPF(0,("tmman:sectionMapPhysicalAddress:IoAllocateMdl:FAIL\n"));
		goto sectionMapPhysicalAddressExit1;
	}

	MmBuildMdlForNonPagedPool ( Mdl );

	if ( ( UserModeVirtualAddress = MmMapLockedPages (
		Mdl,
		UserMode ) ) == NULL )
	{
		DPF(0,("tmman:sectionMapPhysicalAddress:MmMapLockedPages:FAIL\n"));
		goto sectionMapPhysicalAddressExit2;
	}

	*SectionHandlePointer = (UInt32)Mdl;
	return UserModeVirtualAddress;


sectionMapPhysicalAddressExit2:
	IoFreeMdl ( Mdl );

sectionMapPhysicalAddressExit1:
	return NULL;
}


void	sectionUnmapPhysicalAddress ( 
	Pointer UserModeVirtualAddress, 
	UInt32 SectionHandle )
{
	MmUnmapLockedPages ( UserModeVirtualAddress, (Pointer)SectionHandle );

	IoFreeMdl ( (Pointer)SectionHandle );
}