pcihal.cpp

wince host 和 target PCI驱动程序

/*
COPYRIGHT (c) 1996 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.
*/

/*
	Copyright (c) 1996 Philips Semiconductors - TriMedia. All rights reserved.

FILE pcihal.c

HISTORY
	#define TR	Tilakraj Roy
	9502118	TR	Created	(Tilakraj Roy )

COMMENTS
	All addresses passed to the hal functions are Physical TriMedia SDRAM
	addresses. i.e Addresses where they are mapped into PCI address space.
	
*/


#include "stdafx.h"
#include "tmman32.h"
#include "pcihal.h"


BOOL	halValidateAddress ( PTM_HW pTMHW, DWORD dwAddress, BOOL *pfSDRAM )
{
	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	PTMSTD_MEMORY_BLOCK	pMMIO = &pTMHW->DSPCaps.MMIO;
	#else
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	PTMSTD_MEMORY_BLOCK	pMMIO = &pTMHW->Config.MMIO;
	#endif

	if( ( dwAddress >= pSDRAM->dwPhysical ) &&
		( dwAddress <= ( pSDRAM->dwPhysical + pSDRAM->dwSize - 1) ) )
	{
		*pfSDRAM = TRUE;
		return TRUE;
	}
	if( ( dwAddress >= pMMIO->dwPhysical ) &&
		( dwAddress <= (pMMIO->dwPhysical + pMMIO->dwSize - 1)  ) )
	{
		*pfSDRAM = FALSE;
		return TRUE;
	}
	return FALSE;

}


BOOL	halValidateLength ( PTM_HW pTMHW, DWORD dwAddress, DWORD dwLength )
{
	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	PTMSTD_MEMORY_BLOCK	pMMIO = &pTMHW->DSPCaps.MMIO;
	#else
	PTMMAN_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	PTMMAN_MEMORY_BLOCK	pMMIO = &pTMHW->Config.MMIO;
	#endif

	// assumes that MMIO and SDRAM are not contigious.
	if ( ( dwAddress >= pSDRAM->dwPhysical ) &&
		( dwAddress < (pSDRAM->dwPhysical + pSDRAM->dwSize - 1)  ) )
	{
		if ( ( dwAddress + dwLength ) <= (pSDRAM->dwPhysical + pSDRAM->dwSize - 1)  )
			return TRUE;
		else
			return FALSE;
	}

	if ( ( dwAddress >= pMMIO->dwPhysical ) &&
		( dwAddress <= (pMMIO->dwPhysical + pMMIO->dwSize -1) ) )
	{
		if ( ( dwAddress + dwLength ) <= 
			(pMMIO->dwPhysical + pMMIO->dwSize -1) )
			return TRUE;
		else
			return FALSE;
	}
	return FALSE;

}

BOOL	halInit ( PTM_HW pTMHW ) // TR960406 DWORD dwSDRAMLength, BOOL fTriMedia )
{
	#ifdef USE_TMMAN
	extern DWORD dwDSPNumber;
	STATUS	Status;

	if ( ( Status = tmDSPOpen (dwDSPNumber, &pTMHW->DSPHandle ) ) != TMOK )
	{
		goto halInit_exit1;

	}

	if ( ( Status = tmDSPGetCaps ( pTMHW->DSPHandle,
		&pTMHW->DSPCaps ) ) != TMOK )
	{
		goto halInit_exit1;
	}


	#else

	DWORD	dwBytesReturned;


	pTMHW->hDevice = CreateFile ( "\\\\.\\vtmman.vxd",0,0,0,
		CREATE_NEW ,  FILE_FLAG_DELETE_ON_CLOSE, 0 );

	if ( pTMHW->hDevice == INVALID_HANDLE_VALUE )
	{
		return FALSE;
	}

	if ( DeviceIoControl ( pTMHW->hDevice, DIOC_GETCONFIG,
		NULL, 0,
		(PVOID)&pTMHW->Config, sizeof( TMMAN_CONFIG_INFO),
		&dwBytesReturned, NULL ) != TRUE )
	{
		return FALSE;
	}
	#endif

	return TRUE;

halInit_exit1 :
	return FALSE;
	

}

VOID	halExit ( PTM_HW pTMHW )
{
	#ifdef USE_TMMAN
	tmDSPClose ( pTMHW->DSPHandle );
	#else
	CloseHandle ( pTMHW->hDevice );
	#endif
}

BYTE	halMemoryReadB ( PTM_HW pTMHW, DWORD dwAddress )
{
	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	#else
	PTMMAN_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	#endif

	return *((PBYTE)((dwAddress - pSDRAM->dwPhysical ) +
		pSDRAM->dwLinear ));
}

WORD	halMemoryReadW ( PTM_HW pTMHW, DWORD dwAddress )
{
	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	#else
	PTMMAN_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	#endif

	return *(PWORD)((PBYTE)((dwAddress - pSDRAM->dwPhysical ) +
		pSDRAM->dwLinear ));
}

DWORD	halMemoryReadD ( PTM_HW pTMHW, DWORD dwAddress )
{
	BOOL	fSDRAM;

	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	PTMSTD_MEMORY_BLOCK	pMMIO = &pTMHW->DSPCaps.MMIO;
	#else
	PTMMAN_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	PTMMAN_MEMORY_BLOCK	pMMIO = &pTMHW->Config.MMIO;
	#endif


	halValidateAddress ( pTMHW, dwAddress, &fSDRAM );

	if ( fSDRAM )
	{
		return *(PDWORD)((PBYTE)((dwAddress - pSDRAM->dwPhysical ) +
			pSDRAM->dwLinear));
		
	}
	else
	{
		return *(PDWORD)((PBYTE)((dwAddress - pMMIO->dwPhysical ) +
			pMMIO->dwLinear ));
	}
}

VOID	halMemoryWriteB ( PTM_HW pTMHW, DWORD dwAddress, BYTE bValue )
{
	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	#else
	PTMMAN_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	#endif


	*((PBYTE)((dwAddress - pSDRAM->dwPhysical ) +
		pSDRAM->dwLinear )) = bValue;
}

VOID	halMemoryWriteW ( PTM_HW pTMHW, DWORD dwAddress, WORD wValue )
{
	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	#else
	PTMMAN_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	#endif


	*(PWORD)((PBYTE)((dwAddress - pSDRAM->dwPhysical ) +
		pSDRAM->dwLinear )) = wValue;
}

VOID	halMemoryWriteD ( PTM_HW pTMHW, DWORD dwAddress, DWORD dwValue )
{
	BOOL	fSDRAM;
	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	PTMSTD_MEMORY_BLOCK	pMMIO = &pTMHW->DSPCaps.MMIO;
	#else
	PTMMAN_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	PTMMAN_MEMORY_BLOCK	pMMIO = &pTMHW->Config.MMIO;
	#endif

	if ( halValidateAddress ( pTMHW, dwAddress, &fSDRAM ) != TRUE )
		 return;

	if ( fSDRAM )
	{
		*(PDWORD)((PBYTE)((dwAddress - pSDRAM->dwPhysical ) +
			pSDRAM->dwLinear)) = dwValue;
		
	}
	else
	{
		*(PDWORD)((PBYTE)((dwAddress - pMMIO->dwPhysical ) +
			pMMIO->dwLinear)) = dwValue;
	}
}


BOOL	halSDRAMMemCopy ( PTM_HW pTMHW, PVOID pvSource, DWORD dwDestAddress,
	DWORD dwLength )
{
	PDWORD	pdwDestination;
	BOOL	fSDRAM;
	#ifdef USE_TMMAN
	PTMSTD_MEMORY_BLOCK	pSDRAM = &pTMHW->DSPCaps.SDRAM;
	#else
	PTMMAN_MEMORY_BLOCK	pSDRAM = &pTMHW->Config.SDRAM;
	#endif

	
	if ( halValidateAddress ( pTMHW, dwDestAddress, &fSDRAM ) != TRUE )
		 return FALSE;

	if ( !fSDRAM ) 
		return FALSE;

	pdwDestination =
		(PDWORD)((PBYTE)((dwDestAddress - pSDRAM->dwPhysical ) +
			pSDRAM->dwLinear));
	
	memcpy ( pdwDestination, pvSource, dwLength );
	return TRUE;			/// ??????????????	
}

#ifndef USE_TMMAN
BOOL	halGetVersion ( PTM_HW pTMHW, PVOID pVersion )
{
	DWORD	dwBytesReturned;
	if ( DeviceIoControl ( pTMHW->hDevice, DIOC_VXDVERSION,
		(PVOID)NULL, 0 ,
		(PVOID)pVersion, sizeof ( TMSTD_VERSION_INFO ),
		&dwBytesReturned, NULL ) != TRUE )
	{
		return FALSE;
	}

	if ( dwBytesReturned  != sizeof ( TMSTD_VERSION_INFO ) )
		return FALSE;

		
	return TRUE;
}


BOOL	halExecutableStart ( PTM_HW pTMHW )
{
	DWORD	dwBytesReturned;
	DWORD	dwStartAddress = pTMHW->Config.SDRAM.dwPhysical;
	if ( DeviceIoControl ( pTMHW->hDevice, TMIF_DIOC_DSPEXECUTABLERUN,
		(PVOID)&dwStartAddress, sizeof ( DWORD ),
		(PVOID)NULL, 0 ,
		&dwBytesReturned, NULL ) != TRUE )
	{
		return FALSE;
	}
	return TRUE;
}
#endif