haiku.git

// ****************************************************************************
//
//  	CDspCommObject.cpp
//
//		Implementation file for EchoGals generic driver DSP interface class.
//
// ----------------------------------------------------------------------------
//
// This file is part of Echo Digital Audio's generic driver library.
// Copyright Echo Digital Audio Corporation (c) 1998 - 2005
// All rights reserved
// www.echoaudio.com
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
// ****************************************************************************

#include "CEchoGals.h"

#ifdef DSP_56361
#include "LoaderDSP.c"
#endif

#define COMM_PAGE_PHYS_BYTES	((sizeof(DspCommPage)+PAGE_SIZE-1)/PAGE_SIZE)*PAGE_SIZE


/****************************************************************************

	Construction and destruction

 ****************************************************************************/

//===========================================================================
//
// Overload new & delete so memory for this object is allocated
//	from non-paged memory.
//
//===========================================================================

PVOID CDspCommObject::operator new( size_t Size )
{
	PVOID 		pMemory;
	ECHOSTATUS 	Status;
	
	Status = OsAllocateNonPaged(Size,&pMemory);
	
	if ( (ECHOSTATUS_OK != Status) || (NULL == pMemory ))
	{
		ECHO_DEBUGPRINTF(("CDspCommObject::operator new - memory allocation failed\n"));

		pMemory = NULL;
	}
	else
	{
		memset( pMemory, 0, Size );
	}

	return pMemory;
	
}	// PVOID CDspCommObject::operator new( size_t Size )


VOID  CDspCommObject::operator delete( PVOID pVoid )
{
	if ( ECHOSTATUS_OK != OsFreeNonPaged( pVoid ) )
	{
		ECHO_DEBUGPRINTF( ("CDspCommObject::operator delete memory free "
								 "failed\n") );
	}
}	// VOID  CDspCommObject::operator delete( PVOID pVoid )


//===========================================================================
//
// Constructor
//
//===========================================================================

CDspCommObject::CDspCommObject
(
	PDWORD		pdwDspRegBase,				// Virtual ptr to DSP registers
	PCOsSupport	pOsSupport
)
{
	INT32	i;

	ECHO_ASSERT(pOsSupport );
	
	//
	// Init all the basic stuff
	//
	strcpy( m_szCardName, "??????" );
	m_pOsSupport = pOsSupport;				// Ptr to OS Support methods & data
	m_pdwDspRegBase = pdwDspRegBase;		// Virtual addr DSP's register base
	m_bBadBoard = TRUE;						// Set TRUE until DSP loaded
	m_pwDspCode = NULL;						// Current DSP code not loaded
	m_byDigitalMode = DIGITAL_MODE_NONE;
	m_wInputClock = ECHO_CLOCK_INTERNAL;
	m_wOutputClock = ECHO_CLOCK_WORD;
	m_ullLastLoadAttemptTime = (ULONGLONG)(DWORD)(0L - DSP_LOAD_ATTEMPT_PERIOD);	// force first load to go

#ifdef MIDI_SUPPORT	
	m_ullNextMidiWriteTime = 0;
#endif

	//
	// Create the DSP comm page - this is the area of memory read and written by
	// the DSP via bus mastering
	//
	ECHOSTATUS Status;
	DWORD dwSegmentSize;
	PHYS_ADDR PhysAddr;
	
	Status = pOsSupport->AllocPhysPageBlock(	COMM_PAGE_PHYS_BYTES,
															m_pDspCommPageBlock);
	if (ECHOSTATUS_OK != Status)
	{
		ECHO_DEBUGPRINTF( ("CDspCommObject::CDspCommObject DSP comm page "
								 "memory allocation failed\n") );
		return;
	}
	
	m_pDspCommPage = (PDspCommPage) pOsSupport->
													GetPageBlockVirtAddress( m_pDspCommPageBlock );
	
	pOsSupport->GetPageBlockPhysSegment(m_pDspCommPageBlock,
													0,
													PhysAddr,
													dwSegmentSize);
	m_dwCommPagePhys = PhysAddr;
	
	//
	// Init the comm page
	//
	m_pDspCommPage->dwCommSize = SWAP( sizeof( DspCommPage ) );
													// Size of DSP comm page
	
	m_pDspCommPage->dwHandshake = 0xffffffff;
	m_pDspCommPage->dwMidiOutFreeCount = SWAP( (DWORD) DSP_MIDI_OUT_FIFO_SIZE );

	for ( i = 0; i < DSP_MAXAUDIOINPUTS; i++ )
		m_pDspCommPage->InLineLevel[ i ] = 0x00;
													// Set line levels so we don't blast
													// any inputs on startup
	memset( m_pDspCommPage->byMonitors,
			  GENERIC_TO_DSP(ECHOGAIN_MUTED),
			  MONITOR_ARRAY_SIZE );			// Mute all monitors

	memset( m_pDspCommPage->byVmixerLevel,
			  GENERIC_TO_DSP(ECHOGAIN_MUTED),
			  VMIXER_ARRAY_SIZE );			// Mute all virtual mixer levels
			  
#ifdef DIGITAL_INPUT_AUTO_MUTE_SUPPORT

	m_fDigitalInAutoMute = TRUE;

#endif

}	// CDspCommObject::CDspCommObject


//===========================================================================
//
// Destructor
//
//===========================================================================

CDspCommObject::~CDspCommObject()
{
	//
	// Go to sleep
	//
	GoComatose();

	//
	// Free the comm page
	//
	if ( NULL != m_pDspCommPageBlock )
	{
		m_pOsSupport->FreePhysPageBlock( COMM_PAGE_PHYS_BYTES,
													m_pDspCommPageBlock);
	}

	ECHO_DEBUGPRINTF( ( "CDspCommObject::~CDspCommObject() is toast!\n" ) );

}	// CDspCommObject::~CDspCommObject()




/****************************************************************************

	Firmware loading functions

 ****************************************************************************/

//===========================================================================
//
// ASIC status check - some cards have one or two ASICs that need to be 
// loaded.  Once that load is complete, this function is called to see if
// the load was successful. 
//
// If this load fails, it does not necessarily mean that the hardware is
// defective - the external box may be disconnected or turned off.
//
//===========================================================================

BOOL CDspCommObject::CheckAsicStatus()
{
	DWORD	dwAsicStatus;
	DWORD	dwReturn;

	//
	// Always succeed if this card doesn't have an ASIC
	//
	if ( !m_bHasASIC )
	{
		m_bASICLoaded = TRUE;
		return TRUE;
	}
			
	// Send the vector command
	m_bASICLoaded = FALSE;
	SendVector( DSP_VC_TEST_ASIC );	

	// The DSP will return a value to indicate whether or not the 
	// ASIC is currently loaded
	dwReturn = Read_DSP( &dwAsicStatus );
	if ( ECHOSTATUS_OK != dwReturn )
	{
		ECHO_DEBUGPRINTF(("CDspCommObject::CheckAsicStatus - failed on Read_DSP\n"));
		ECHO_DEBUGBREAK();
		return FALSE;
	}

#ifdef ECHO_DEBUG
	if ( (dwAsicStatus != ASIC_LOADED) && (dwAsicStatus != ASIC_NOT_LOADED) )
	{
		ECHO_DEBUGBREAK(); 
	}
#endif
	
	if ( dwAsicStatus == ASIC_LOADED )
		m_bASICLoaded = TRUE;

	return m_bASICLoaded;

}	// BOOL CDspCommObject::CheckAsicStatus()


//===========================================================================
//
//	Load ASIC code - done after the DSP is loaded
//
//===========================================================================

BOOL CDspCommObject::LoadASIC
(
	DWORD	dwCmd,
	PBYTE	pCode,
	DWORD	dwSize
)
{
	DWORD i;
#ifdef _WIN32
	DWORD dwChecksum = 0;
#endif

	ECHO_DEBUGPRINTF(("CDspCommObject::LoadASIC\n"));

	if ( !m_bHasASIC )
		return TRUE;

#ifdef _DEBUG
	ULONGLONG	ullStartTime, ullCurTime;
	m_pOsSupport->OsGetSystemTime( &ullStartTime );
#endif

	// Send the "Here comes the ASIC" command
	if ( ECHOSTATUS_OK != Write_DSP( dwCmd ) )
		return FALSE;

	// Write length of ASIC file in bytes
	if ( ECHOSTATUS_OK != Write_DSP( dwSize ) )
		return FALSE;

	for ( i = 0; i < dwSize; i++ )
	{
#ifdef _WIN32
		dwChecksum += pCode[i];
#endif	
	
		if ( ECHOSTATUS_OK != Write_DSP( pCode[ i ] ) )
		{
			ECHO_DEBUGPRINTF(("\tfailed on Write_DSP\n"));
			return FALSE;
		}
	}

#ifdef _DEBUG
	m_pOsSupport->OsGetSystemTime( &ullCurTime );
	ECHO_DEBUGPRINTF( ("CDspCommObject::LoadASIC took %ld usec.\n",
							(ULONG) ( ullCurTime - ullStartTime ) ) );
	ECHO_DEBUGPRINTF(("ASIC load OK\n"));
#endif

#if defined(_WIN32) && (DBG)
	DbgPrint("--- ASIC checksum is 0x%lx\n",dwChecksum);
#endif

	return TRUE;

}	// BOOL CDspCommObject::LoadASIC( DWORD dwCmd, PBYTE pCode, DWORD dwSize )


//===========================================================================
//
// InstallResidentLoader
//
// Install the resident loader for 56361 DSPs;  The resident loader
// is on the EPROM on the board for 56301 DSP.
//
// The resident loader is a tiny little program that is used to load
// the real DSP code.
//
//===========================================================================

#ifdef DSP_56361

ECHOSTATUS CDspCommObject::InstallResidentLoader()
{
	DWORD			dwAddress;
	DWORD			dwIndex;
	INT32			iNum;
	INT32			i;
	DWORD			dwReturn;
	PWORD			pCode;

	ECHO_DEBUGPRINTF( ("CDspCommObject::InstallResidentLoader\n") );
	
	//
	// 56361 cards only!
	//
	if (DEVICE_ID_56361 != m_pOsSupport->GetDeviceId() )
		return ECHOSTATUS_OK;

	//
	// Look to see if the resident loader is present.  If the resident loader
	// is already installed, host flag 5 will be on.
	//
	DWORD dwStatus;
	dwStatus = GetDspRegister( CHI32_STATUS_REG );
	if ( 0 != (dwStatus & CHI32_STATUS_REG_HF5 ) )
	{
		ECHO_DEBUGPRINTF(("\tResident loader already installed; status is 0x%lx\n",
								dwStatus));
		return ECHOSTATUS_OK;
	}
	//
	// Set DSP format bits for 24 bit mode
	//
	SetDspRegister( CHI32_CONTROL_REG,
						 GetDspRegister( CHI32_CONTROL_REG ) | 0x900 );

	//---------------------------------------------------------------------------
	//
	// Loader
	//
	// The DSP code is an array of 16 bit words.  The array is divided up into
	// sections.  The first word of each section is the size in words, followed
	// by the section type.
	//
	// Since DSP addresses and data are 24 bits wide, they each take up two
	// 16 bit words in the array.
	//
	// This is a lot like the other loader loop, but it's not a loop,
	// you don't write the memory type, and you don't write a zero at the end.
	//
	//---------------------------------------------------------------------------

	pCode = pwLoaderDSP;
	//
	// Skip the header section; the first word in the array is the size of 
	//	the first section, so the first real section of code is pointed to 
	//	by pCode[0].
	//
	dwIndex = pCode[ 0 ];
	//
	// Skip the section size, LRS block type, and DSP memory type
	//
	dwIndex += 3;
	//	
	// Get the number of DSP words to write
	//
	iNum = pCode[ dwIndex++ ];
	//
	// Get the DSP address for this block; 24 bits, so build from two words
	//
	dwAddress = ( pCode[ dwIndex ] << 16 ) + pCode[ dwIndex + 1 ];
	dwIndex += 2;
	//	
	// Write the count to the DSP
	//
	dwReturn = Write_DSP( (DWORD) iNum );
	if ( dwReturn != 0 )
	{
		ECHO_DEBUGPRINTF( ("CDspCommObject::InstallResidentLoader: Failed to "
								 "write word count!\n") );
		return ECHOSTATUS_DSP_DEAD;
	}

	// Write the DSP address
	dwReturn = Write_DSP( dwAddress );
	if ( dwReturn != 0 )
	{
		ECHO_DEBUGPRINTF( ("CDspCommObject::InstallResidentLoader: Failed to "
								 "write DSP address!\n") );
		return ECHOSTATUS_DSP_DEAD;
	}


	// Write out this block of code to the DSP
	for ( i = 0; i < iNum; i++) // 
	{
		DWORD	dwData;

		dwData = ( pCode[ dwIndex ] << 16 ) + pCode[ dwIndex + 1 ];
		dwReturn = Write_DSP( dwData );
		if ( dwReturn != 0 )
		{
			ECHO_DEBUGPRINTF( ("CDspCommObject::InstallResidentLoader: Failed to "
									 "write DSP code\n") );
			return ECHOSTATUS_DSP_DEAD;
		}

		dwIndex+=2;
	}
	
	//
	// Wait for flag 5 to come up
	//
	BOOL			fSuccess;
	ULONGLONG 	ullCurTime,ullTimeout;

	m_pOsSupport->OsGetSystemTime( &ullCurTime );
	ullTimeout = ullCurTime + 10000L;		// 10m.s.
	fSuccess = FALSE;
	do
	{
		m_pOsSupport->OsSnooze(50);	// Give the DSP some time;
														// no need to hog the CPU
		
		dwStatus = GetDspRegister( CHI32_STATUS_REG );
		if (0 != (dwStatus & CHI32_STATUS_REG_HF5))
		{
			fSuccess = TRUE;
			break;
		}
		
		m_pOsSupport->OsGetSystemTime( &ullCurTime );

	} while (ullCurTime < ullTimeout);
	
	if (FALSE == fSuccess)
	{
		ECHO_DEBUGPRINTF(("\tResident loader failed to set HF5\n"));
		return ECHOSTATUS_DSP_DEAD;
	}
		
	ECHO_DEBUGPRINTF(("\tResident loader successfully installed\n"));

	return ECHOSTATUS_OK;
	
}	// ECHOSTATUS CDspCommObject::InstallResidentLoader()

#endif // DSP_56361


//===========================================================================
//
// LoadDSP
//
// This loads the DSP code.
//
//===========================================================================

ECHOSTATUS CDspCommObject::LoadDSP
(
	PWORD	pCode					// Ptr to DSP object code
)
{
	DWORD			dwAddress;
	DWORD			dwIndex;
	INT32			iNum;
	INT32			i;
	DWORD			dwReturn;
	ULONGLONG	ullTimeout, ullCurTime;
	ECHOSTATUS	Status;

	ECHO_DEBUGPRINTF(("CDspCommObject::LoadDSP\n"));
	if ( m_pwDspCode == pCode )
	{
		ECHO_DEBUGPRINTF( ("\tDSP is already loaded!\n") );
		return ECHOSTATUS_FIRMWARE_LOADED;
	}
	m_bBadBoard = TRUE;		// Set TRUE until DSP loaded
	m_pwDspCode = NULL;		// Current DSP code not loaded
	m_bASICLoaded = FALSE;	// Loading the DSP code will reset the ASIC
	
	ECHO_DEBUGPRINTF(("CDspCommObject::LoadDSP  Set m_bBadBoard to TRUE\n"));
	
	//
	//	If this board requires a resident loader, install it.
	//
#ifdef DSP_56361
	InstallResidentLoader();
#endif

	// Send software reset command	
	if ( ECHOSTATUS_OK != SendVector( DSP_VC_RESET ) )
	{
		m_pOsSupport->EchoErrorMsg(
			"CDspCommObject::LoadDsp SendVector DSP_VC_RESET failed",
			"Critical Failure" );
		return ECHOSTATUS_DSP_DEAD;
	}

	// Delay 10us
	m_pOsSupport->OsSnooze( 10L );

	// Wait 10ms for HF3 to indicate that software reset is complete	
	m_pOsSupport->OsGetSystemTime( &ullCurTime );
	ullTimeout = ullCurTime + 10000L;		// 10m.s.

	// wait for HF3 to be set
wait_for_hf3:
	
	if ( GetDspRegister( CHI32_STATUS_REG ) & CHI32_STATUS_REG_HF3 )
			goto set_dsp_format_bits;
		m_pOsSupport->OsGetSystemTime( &ullCurTime );
		if ( ullCurTime > ullTimeout)
		{
			ECHO_DEBUGPRINTF( ("CDspCommObject::LoadDSP Timeout waiting for "
									 "CHI32_STATUS_REG_HF3\n") );
			m_pOsSupport->EchoErrorMsg(
				"CDspCommObject::LoadDSP SendVector DSP_VC_RESET failed",
				"Critical Failure" );
			return ECHOSTATUS_DSP_TIMEOUT;
		}
	goto wait_for_hf3;


	// Set DSP format bits for 24 bit mode now that soft reset is done
set_dsp_format_bits:
		SetDspRegister( CHI32_CONTROL_REG,
						 GetDspRegister( CHI32_CONTROL_REG ) | (DWORD) 0x900 );

	//---------------------------------------------------------------------------
	// Main loader loop
	//---------------------------------------------------------------------------

	dwIndex = pCode[ 0 ];

	for (;;)
	{
		INT32	iBlockType;
		INT32	iMemType;

		// Total Block Size
		dwIndex++;
		
		// Block Type
		iBlockType = pCode[ dwIndex ];
		if ( iBlockType == 4 )  // We're finished
			break;

		dwIndex++;

		// Memory Type  P=0,X=1,Y=2
		iMemType = pCode[ dwIndex ]; 
		dwIndex++;
		
		// Block Code Size
		iNum = pCode[ dwIndex ];
		dwIndex++;
		if ( iNum == 0 )			// We're finished
			break;
	
 		// Start Address
		dwAddress = ( (DWORD) pCode[ dwIndex ] << 16 ) + pCode[ dwIndex + 1 ];
//		ECHO_DEBUGPRINTF( ("\tdwAddress %lX\n", dwAddress) );
		dwIndex += 2;
		
		dwReturn = Write_DSP( (DWORD)iNum );
		if ( dwReturn != 0 )
		{
			ECHO_DEBUGPRINTF(("LoadDSP - failed to write number of DSP words\n"));
			return ECHOSTATUS_DSP_DEAD;
		}

		dwReturn = Write_DSP( dwAddress );
		if ( dwReturn != 0 )
		{
			ECHO_DEBUGPRINTF(("LoadDSP - failed to write DSP address\n"));
			return ECHOSTATUS_DSP_DEAD;
		}

		dwReturn = Write_DSP( (DWORD)iMemType );
		if ( dwReturn != 0 )
		{
			ECHO_DEBUGPRINTF(("LoadDSP - failed to write DSP memory type\n"));
			return ECHOSTATUS_DSP_DEAD;
		}

		// Code
		for ( i = 0; i < iNum; i++ )
		{
			DWORD	dwData;

			dwData = ( (DWORD) pCode[ dwIndex ] << 16 ) + pCode[ dwIndex + 1 ];
			dwReturn = Write_DSP( dwData );
			if ( dwReturn != 0 )
			{
				ECHO_DEBUGPRINTF(("LoadDSP - failed to write DSP data\n"));
				return ECHOSTATUS_DSP_DEAD;
			}
	
			dwIndex += 2;
		}
//		ECHO_DEBUGPRINTF( ("\tEnd Code Block\n") );
	}
	dwReturn = Write_DSP( 0 );					// We're done!!!
	if ( dwReturn != 0 )
	{
		ECHO_DEBUGPRINTF(("LoadDSP: Failed to write final zero\n"));
		return ECHOSTATUS_DSP_DEAD;
	}
		

	// Delay 10us
	m_pOsSupport->OsSnooze( 10L );

	m_pOsSupport->OsGetSystemTime( &ullCurTime );
	ullTimeout  = ullCurTime + 500000L;		// 1/2 sec. timeout

	while ( ullCurTime <= ullTimeout) 
	{
		//
		// Wait for flag 4 - indicates that the DSP loaded OK
		//
		if ( GetDspRegister( CHI32_STATUS_REG ) & CHI32_STATUS_REG_HF4 )
		{
			SetDspRegister( CHI32_CONTROL_REG,
								 GetDspRegister( CHI32_CONTROL_REG ) & ~0x1b00 );

			dwReturn = Write_DSP( DSP_FNC_SET_COMMPAGE_ADDR );
			if ( dwReturn != 0 )
			{
				ECHO_DEBUGPRINTF(("LoadDSP - Failed to write DSP_FNC_SET_COMMPAGE_ADDR\n"));
				return ECHOSTATUS_DSP_DEAD;
			}
				
			dwReturn = Write_DSP( m_dwCommPagePhys );
			if ( dwReturn != 0 )
			{
				ECHO_DEBUGPRINTF(("LoadDSP - Failed to write comm page address\n"));
				return ECHOSTATUS_DSP_DEAD;
			}

			//
			// Get the serial number via slave mode.
			// This is triggered by the SET_COMMPAGE_ADDR command.
			//	We don't actually use the serial number but we have to get
			//	it as part of the DSP init vodoo.
			//
			Status = ReadSn();
			if ( ECHOSTATUS_OK != Status )
			{
				ECHO_DEBUGPRINTF(("LoadDSP - Failed to read serial number\n"));
				return Status;
			}

			m_pwDspCode = pCode;			// Show which DSP code loaded
			m_bBadBoard = FALSE;			// DSP OK
			
			ECHO_DEBUGPRINTF(("CDspCommObject::LoadDSP  Set m_bBadBoard to FALSE\n"));			
		
			return ECHOSTATUS_OK;
		}
		
		m_pOsSupport->OsGetSystemTime( &ullCurTime );
	}
	
	ECHO_DEBUGPRINTF( ("LoadDSP: DSP load timed out waiting for HF4\n") );	
	
	return ECHOSTATUS_DSP_TIMEOUT;

}	// DWORD	CDspCommObject::LoadDSP




//===========================================================================
//
// LoadFirmware takes care of loading the DSP and any ASIC code.
//
//===========================================================================

ECHOSTATUS CDspCommObject::LoadFirmware()
{
	ECHOSTATUS	dwReturn;
	ULONGLONG	ullRightNow;

	// Sanity check
	if ( NULL == m_pwDspCodeToLoad || NULL == m_pDspCommPage )
	{
		ECHO_DEBUGBREAK();
		return ECHOSTATUS_NO_MEM;
	}
	
	//
	// Even if the external box is off, an application may still try
	// to repeatedly open the driver, causing multiple load attempts and 
	// making the machine spend lots of time in the kernel.  If the ASIC is not
	// loaded, this code will gate the loading attempts so it doesn't happen
	// more than once per second.
	//
	m_pOsSupport->OsGetSystemTime(&ullRightNow);
	if ( 	(FALSE == m_bASICLoaded) &&
			(DSP_LOAD_ATTEMPT_PERIOD > (ullRightNow - m_ullLastLoadAttemptTime)) )
		return ECHOSTATUS_ASIC_NOT_LOADED;
	
	//
	// Update the timestamp
	//
	m_ullLastLoadAttemptTime = ullRightNow;

	//
	// See if the ASIC is present and working - only if the DSP is already loaded
	//	
	if (NULL != m_pwDspCode)
	{
		dwReturn = CheckAsicStatus();
		if (TRUE == dwReturn)
			return ECHOSTATUS_OK;
		
		//
		// ASIC check failed; force the DSP to reload
		//	
		m_pwDspCode = NULL;
	}

	//
	// Try and load the DSP
	//
	dwReturn = LoadDSP( m_pwDspCodeToLoad );
	if ( 	(ECHOSTATUS_OK != dwReturn) && 
			(ECHOSTATUS_FIRMWARE_LOADED != dwReturn) )
	{
		return dwReturn;
	}
	
	ECHO_DEBUGPRINTF(("DSP load OK\n"));

	//
	// Load the ASIC if the DSP load succeeded; LoadASIC will
	// always return TRUE for cards that don't have an ASIC.
	//
	dwReturn = LoadASIC();
	if ( FALSE == dwReturn )
	{
		dwReturn = ECHOSTATUS_ASIC_NOT_LOADED;
	}
	else
	{
		//
		// ASIC load was successful
		//
		RestoreDspSettings();

		dwReturn = ECHOSTATUS_OK;
	}
	
	return dwReturn;
	
}	// BOOL CDspCommObject::LoadFirmware()


//===========================================================================
//
// This function is used to read back the serial number from the DSP;
// this is triggered by the SET_COMMPAGE_ADDR command.
//
// Only some early Echogals products have serial numbers in the ROM;
// the serial number is not used, but you still need to do this as
// part of the DSP load process.
//
//===========================================================================

ECHOSTATUS CDspCommObject::ReadSn()
{
	INT32			j;
	DWORD			dwSn[ 6 ];
	ECHOSTATUS	Status;

	ECHO_DEBUGPRINTF( ("CDspCommObject::ReadSn\n") );
	for ( j = 0; j < 5; j++ )
	{
		Status = Read_DSP( &dwSn[ j ] );
		if ( Status != 0 )
		{
			ECHO_DEBUGPRINTF( ("\tFailed to read serial number word %ld\n",
									 j) );
			return ECHOSTATUS_DSP_DEAD;
		}
	}
	ECHO_DEBUGPRINTF( ("\tRead serial number %08lx %08lx %08lx %08lx %08lx\n",
							 dwSn[0], dwSn[1], dwSn[2], dwSn[3], dwSn[4]) );
	return ECHOSTATUS_OK;
	
}	// DWORD	CDspCommObject::ReadSn




//===========================================================================
//
//	This is called after LoadFirmware to restore old gains, meters on, 
// monitors, etc.
//
//===========================================================================

void CDspCommObject::RestoreDspSettings()
{
	ECHO_DEBUGPRINTF(("RestoreDspSettings\n"));
	ECHO_DEBUGPRINTF(("\tControl reg is 0x%lx\n",SWAP(m_pDspCommPage->dwControlReg) ));

	if ( !CheckAsicStatus() )
		return;

	m_pDspCommPage->dwHandshake = 0xffffffff;		
	
#ifdef MIDI_SUPPORT
	m_ullNextMidiWriteTime = 0;
#endif
	
	SetSampleRate();
	if ( 0 != m_wMeterOnCount )
	{
		SendVector( DSP_VC_METERS_ON );
	}

	SetInputClock( m_wInputClock );
	SetOutputClock( m_wOutputClock );
		
	if ( !WaitForHandshake() )
	{
		return;
	}
	UpdateAudioOutLineLevel();

	if ( !WaitForHandshake() )
		return;
	UpdateAudioInLineLevel();

	if ( HasVmixer() )
	{
		if ( !WaitForHandshake() )
			return;
		UpdateVmixerLevel();
	}
	
	if ( !WaitForHandshake() )
		return;

	ClearHandshake();
	SendVector( DSP_VC_UPDATE_FLAGS );
	
	ECHO_DEBUGPRINTF(("RestoreDspSettings done\n"));	
	
}	// void CDspCommObject::RestoreDspSettings()




/****************************************************************************

	DSP utilities

 ****************************************************************************/

//===========================================================================
//
// Write_DSP writes a 32-bit value to the DSP; this is used almost 
// exclusively for loading the DSP.
//
//===========================================================================

ECHOSTATUS CDspCommObject::Write_DSP
(
	DWORD dwData				// 32 bit value to write to DSP data register
)
{
	DWORD 		dwStatus;
	ULONGLONG 	ullCurTime, ullTimeout;

//	ECHO_DEBUGPRINTF(("Write_DSP\n"));
	
	m_pOsSupport->OsGetSystemTime( &ullCurTime );
	ullTimeout = ullCurTime + 10000000L;		// 10 sec.
	while ( ullTimeout >= ullCurTime ) 
	{
		dwStatus = GetDspRegister( CHI32_STATUS_REG );
		if ( ( dwStatus & CHI32_STATUS_HOST_WRITE_EMPTY ) != 0 )
		{
			SetDspRegister( CHI32_DATA_REG, dwData );
//			ECHO_DEBUGPRINTF(("Write DSP: 0x%x", dwData));
			return ECHOSTATUS_OK;
		}
		m_pOsSupport->OsGetSystemTime( &ullCurTime );
	}

	m_bBadBoard = TRUE;		// Set TRUE until DSP re-loaded
	
	ECHO_DEBUGPRINTF(("CDspCommObject::Write_DSP  Set m_bBadBoard to TRUE\n"));
		
	return ECHOSTATUS_DSP_TIMEOUT;
	
}	// ECHOSTATUS CDspCommObject::Write_DSP




//===========================================================================
//
// Read_DSP reads a 32-bit value from the DSP; this is used almost 
// exclusively for loading the DSP and checking the status of the ASIC.
//
//===========================================================================

ECHOSTATUS CDspCommObject::Read_DSP
(
	DWORD *pdwData				// Ptr to 32 bit value read from DSP data register
)
{
	DWORD 		dwStatus;
	ULONGLONG	ullCurTime, ullTimeout;

//	ECHO_DEBUGPRINTF(("Read_DSP\n"));
	m_pOsSupport->OsGetSystemTime( &ullCurTime );

	ullTimeout = ullCurTime + READ_DSP_TIMEOUT;	
	while ( ullTimeout >= ullCurTime )
	{
		dwStatus = GetDspRegister( CHI32_STATUS_REG );
		if ( ( dwStatus & CHI32_STATUS_HOST_READ_FULL ) != 0 )
		{
			*pdwData = GetDspRegister( CHI32_DATA_REG );
//			ECHO_DEBUGPRINTF(("Read DSP: 0x%x\n", *pdwData));
			return ECHOSTATUS_OK;
		}
		m_pOsSupport->OsGetSystemTime( &ullCurTime );
	}

	m_bBadBoard = TRUE;		// Set TRUE until DSP re-loaded
	
	ECHO_DEBUGPRINTF(("CDspCommObject::Read_DSP  Set m_bBadBoard to TRUE\n"));	
	
	return ECHOSTATUS_DSP_TIMEOUT;
}	// ECHOSTATUS CDspCommObject::Read_DSP



//===========================================================================
//
// Much of the interaction between the DSP and the driver is done via vector
// commands; SendVector writes a vector command to the DSP.  Typically,
// this causes the DSP to read or write fields in the comm page.
//
// Returns ECHOSTATUS_OK if sent OK.
//
//===========================================================================

ECHOSTATUS CDspCommObject::SendVector
(
	DWORD dwCommand				// 32 bit command to send to DSP vector register
)
{
	ULONGLONG	ullTimeout;
	ULONGLONG	ullCurTime;

//
// Turn this on if you want to see debug prints for every vector command
//
#if 0
//#ifdef ECHO_DEBUG
	char *	pszCmd;
	switch ( dwCommand )
	{
		case DSP_VC_ACK_INT :
			pszCmd = "DSP_VC_ACK_INT";
			break;
		case DSP_VC_SET_VMIXER_GAIN :
			pszCmd = "DSP_VC_SET_VMIXER_GAIN";
			break;
		case DSP_VC_START_TRANSFER :
			pszCmd = "DSP_VC_START_TRANSFER";
			break;
		case DSP_VC_METERS_ON :
			pszCmd = "DSP_VC_METERS_ON";
			break;
		case DSP_VC_METERS_OFF :
			pszCmd = "DSP_VC_METERS_OFF";
			break;
		case DSP_VC_UPDATE_OUTVOL :
			pszCmd = "DSP_VC_UPDATE_OUTVOL";
			break;
		case DSP_VC_UPDATE_INGAIN :
			pszCmd = "DSP_VC_UPDATE_INGAIN";
			break;
		case DSP_VC_ADD_AUDIO_BUFFER :
			pszCmd = "DSP_VC_ADD_AUDIO_BUFFER";
			break;
		case DSP_VC_TEST_ASIC :
			pszCmd = "DSP_VC_TEST_ASIC";
			break;
		case DSP_VC_UPDATE_CLOCKS :
			pszCmd = "DSP_VC_UPDATE_CLOCKS";
			break;
		case DSP_VC_SET_LAYLA_SAMPLE_RATE :
			if ( GetCardType() == LAYLA )
				pszCmd = "DSP_VC_SET_LAYLA_RATE";
			else if ( GetCardType() == GINA || GetCardType() == DARLA )
				pszCmd = "DSP_VC_SET_GD_AUDIO_STATE";
			else
				pszCmd = "DSP_VC_WRITE_CONTROL_REG";
			break;
		case DSP_VC_MIDI_WRITE :
			pszCmd = "DSP_VC_MIDI_WRITE";
			break;
		case DSP_VC_STOP_TRANSFER :
			pszCmd = "DSP_VC_STOP_TRANSFER";
			break;
		case DSP_VC_UPDATE_FLAGS :
			pszCmd = "DSP_VC_UPDATE_FLAGS";
			break;
		case DSP_VC_RESET :
			pszCmd = "DSP_VC_RESET";
			break;
		default :
			pszCmd = "?????";
			break;
	}

	ECHO_DEBUGPRINTF( ("SendVector: %s dwCommand %s (0x%x)\n",
								GetCardName(),
								pszCmd,
								dwCommand) );				
#endif

	m_pOsSupport->OsGetSystemTime( &ullCurTime );
	ullTimeout = ullCurTime + 100000L;		// 100m.s.

	//
	// Wait for the "vector busy" bit to be off
	//
	while ( ullCurTime <= ullTimeout) 
	{
		DWORD dwReg;

		dwReg = GetDspRegister( CHI32_VECTOR_REG );
		if ( 0 == (dwReg & CHI32_VECTOR_BUSY) )
		{
			SetDspRegister( CHI32_VECTOR_REG, dwCommand );
			
			return ECHOSTATUS_OK;
		}
		m_pOsSupport->OsGetSystemTime( &ullCurTime );
	}

	ECHO_DEBUGPRINTF( ("\tPunked out on SendVector\n") );
	ECHO_DEBUGBREAK();
	return ECHOSTATUS_DSP_TIMEOUT;
	
}	// ECHOSTATUS CDspCommObject::SendVector



//===========================================================================
//
//	Some vector commands involve the DSP reading or writing data to and
// from the comm page; if you send one of these commands to the DSP,
// it will complete the command and then write a non-zero value to
// the dwHandshake field in the comm page.  This function waits for the 
// handshake to show up.
//
//===========================================================================

BOOL CDspCommObject::WaitForHandshake()
{
	ULONGLONG ullDelta;
	ULONGLONG ullStartTime,ullTime;
	
	//
	// Wait up to three milliseconds for the handshake from the DSP 
	//
	m_pOsSupport->OsGetSystemTime( &ullStartTime );
	do
	{
		// Look for the handshake value
		if ( 0 != GetHandshakeFlag() )
		{
			return TRUE;
		}

		// Give the DSP time to access the comm page
		m_pOsSupport->OsSnooze( 2 );
		
		m_pOsSupport->OsGetSystemTime(&ullTime);
		ullDelta = ullTime - ullStartTime;
	} while (ullDelta < (ULONGLONG) HANDSHAKE_TIMEOUT);

	ECHO_DEBUGPRINTF( ("CDspCommObject::WaitForHandshake: Timeout waiting "
								"for DSP\n") );
	ECHO_DEBUGBREAK();
	return FALSE;
	
}		// DWORD	CDspCommObject::WaitForHandshake()




/****************************************************************************

	Transport methods

 ****************************************************************************/

//===========================================================================
//
// StartTransport starts transport for a set of pipes
//
//===========================================================================

ECHOSTATUS CDspCommObject::StartTransport
(
	PCChannelMask	pChannelMask			// Pipes to start
)
{
	ECHO_DEBUGPRINTF( ("StartTransport\n") );

	//
	// Wait for the previous command to complete
	//
	if ( !WaitForHandshake() )
		return ECHOSTATUS_DSP_DEAD;

	//
	// Write the appropriate fields in the comm page
	//
	m_pDspCommPage->cmdStart.Clear();
	m_pDspCommPage->cmdStart = *pChannelMask;
	if ( !m_pDspCommPage->cmdStart.IsEmpty() )
	{
		//
		// Clear the handshake and send the vector command
		//
		ClearHandshake();
		SendVector( DSP_VC_START_TRANSFER );

		//
		// Keep track of which pipes are transporting
		//
		m_cmActive += *pChannelMask;

		return ECHOSTATUS_OK;
	}		// if this monkey is being started

	ECHO_DEBUGPRINTF( ("CDspCommObject::StartTransport: No pipes to start!\n") );
	return ECHOSTATUS_INVALID_CHANNEL;
	
}	// ECHOSTATUS CDspCommObject::StartTransport


//===========================================================================
//
// StopTransport pauses transport for a set of pipes
//
//===========================================================================

ECHOSTATUS CDspCommObject::StopTransport
(
	PCChannelMask	pChannelMask
)
{
	ECHO_DEBUGPRINTF(("StopTransport\n"));

	//
	// Wait for the last command to finish
	//
	if ( !WaitForHandshake() )
		return ECHOSTATUS_DSP_DEAD;

	//
	// Write to the comm page
	//
	m_pDspCommPage->cmdStop.Clear();
	m_pDspCommPage->cmdStop = *pChannelMask;
	m_pDspCommPage->cmdReset.Clear();
	if ( !m_pDspCommPage->cmdStop.IsEmpty() )
	{
		//
		// Clear the handshake and send the vector command
		//
		ClearHandshake();
		SendVector( DSP_VC_STOP_TRANSFER );

		//
		// Keep track of which pipes are transporting
		//
		m_cmActive -= *pChannelMask;

		return ECHOSTATUS_OK;
	}		// if this monkey is being started

	ECHO_DEBUGPRINTF( ("CDspCommObject::StopTransport: No pipes to stop!\n") );
	return ECHOSTATUS_OK;

}	// ECHOSTATUS CDspCommObject::StopTransport


//===========================================================================
//
// ResetTransport resets transport for a set of pipes
//
//===========================================================================

ECHOSTATUS CDspCommObject::ResetTransport
(
	PCChannelMask	pChannelMask
)
{
	ECHO_DEBUGPRINTF(("ResetTransport\n"));

	//
	// Wait for the last command to finish
	//
	if ( !WaitForHandshake() )
		return ECHOSTATUS_DSP_DEAD;

	//
	// Write to the comm page
	//
	m_pDspCommPage->cmdStop.Clear();
	m_pDspCommPage->cmdReset.Clear();
	m_pDspCommPage->cmdStop = *pChannelMask;
	m_pDspCommPage->cmdReset = *pChannelMask;
	if ( !m_pDspCommPage->cmdReset.IsEmpty() )
	{
		//
		// Clear the handshake and send the vector command
		//
		ClearHandshake();
		SendVector( DSP_VC_STOP_TRANSFER );

		//
		// Keep track of which pipes are transporting
		//
		m_cmActive -= *pChannelMask;

		return ECHOSTATUS_OK;
	}		// if this monkey is being started

	ECHO_DEBUGPRINTF( ("CDspCommObject::ResetTransport: No pipes to reset!\n") );
	return ECHOSTATUS_OK;

}	// ECHOSTATUS CDspCommObject::ResetTransport


//===========================================================================
//
// This tells the DSP where to start reading the scatter-gather list
// for a given pipe.
//
//===========================================================================

void CDspCommObject::SetAudioDuckListPhys
(
	WORD	wPipeIndex,			// Pipe index
	DWORD dwNewPhysAdr		// Physical address asserted on the PCI bus
)
{
	if (wPipeIndex < GetNumPipes() )
	{
		m_pDspCommPage->DuckListPhys[ wPipeIndex ].PhysAddr = 
																		SWAP( dwNewPhysAdr );
	}
}	// void CDspCommObject::SetAudioDuckListPhys



//===========================================================================
//
// Get a mask with active pipes
//
//===========================================================================

void CDspCommObject::GetActivePipes
(
	PCChannelMask	pChannelMask
)
{
	pChannelMask->Clear();
	*pChannelMask += m_cmActive;
}	// void CDspCommObject::GetActivePipes()


//===========================================================================
//
//	Set the audio format for a pipe
//
//===========================================================================

ECHOSTATUS CDspCommObject::SetAudioFormat
(
	WORD 							wPipeIndex,
	PECHOGALS_AUDIOFORMAT	pFormat
)
{
	WORD wDspFormat = DSP_AUDIOFORM_SS_16LE;
	
	ECHO_DEBUGPRINTF(("CDspCommObject::SetAudioFormat - pipe %d  bps %d  channels %d\n",
							wPipeIndex,pFormat->wBitsPerSample,pFormat->wDataInterleave));

	//
	// Check the pipe number
	//
	if (wPipeIndex >= GetNumPipes() )
	{
		ECHO_DEBUGPRINTF( ("CDspCommObject::SetAudioFormat: Invalid pipe"
								 "%d\n",
								 wPipeIndex) );
		return ECHOSTATUS_INVALID_CHANNEL;
	}

	//
	// Look for super-interleave
	//
	if (pFormat->wDataInterleave > 2)
	{
		switch (pFormat->wBitsPerSample)
		{
			case 16 :
				wDspFormat = DSP_AUDIOFORM_SUPER_INTERLEAVE_16LE;
				break;
				
			case 24 :
				wDspFormat = DSP_AUDIOFORM_SUPER_INTERLEAVE_24LE;
				break;
				
			case 32 :
				wDspFormat = DSP_AUDIOFORM_SUPER_INTERLEAVE_32LE;
				break;
		}
		
		wDspFormat |= pFormat->wDataInterleave;
	}
	else
	{
		//
		// For big-endian data, only 32 bit mono->mono samples and 32 bit stereo->stereo
		// are supported
		//
		if (pFormat->byDataAreBigEndian)
		{
			
			switch ( pFormat->wDataInterleave )
			{
				case 1 :
					wDspFormat = DSP_AUDIOFORM_MM_32BE;
					break;
					
#ifdef STEREO_BIG_ENDIAN32_SUPPORT
				case 2 :
					wDspFormat = DSP_AUDIOFORM_SS_32BE;
					break;
#endif

			}
		}
		else
		{
			//
			// Check for 32 bit little-endian mono->mono case
			//
			if ( 	(1 == pFormat->wDataInterleave) &&
					(32 == pFormat->wBitsPerSample) &&
					(0 == pFormat->byMonoToStereo) )
			{
				wDspFormat = DSP_AUDIOFORM_MM_32LE;
			}
			else
			{
				//
				// Handle the other little-endian formats
				//
				switch (pFormat->wBitsPerSample)
				{
					case 8 :
						if (2 == pFormat->wDataInterleave)
							wDspFormat = DSP_AUDIOFORM_SS_8;
						else
							wDspFormat = DSP_AUDIOFORM_MS_8;

						break;
				
					default :		
					case 16 :
						if (2 == pFormat->wDataInterleave)
							wDspFormat = DSP_AUDIOFORM_SS_16LE;
						else
							wDspFormat = DSP_AUDIOFORM_MS_16LE;
						break;	
					
					case 24 :
						if (2 == pFormat->wDataInterleave)
							wDspFormat = DSP_AUDIOFORM_SS_24LE;
						else
							wDspFormat = DSP_AUDIOFORM_MS_24LE;
						break;					
					
					case 32 :
						if (2 == pFormat->wDataInterleave)
							wDspFormat = DSP_AUDIOFORM_SS_32LE;
						else
							wDspFormat = DSP_AUDIOFORM_MS_32LE;
						break;					
				}
				
			} // check other little-endian formats
		
		} // not big endian data
		
	} // not super-interleave
	
	m_pDspCommPage->wAudioFormat[wPipeIndex] = SWAP( wDspFormat );	
	
	return ECHOSTATUS_OK;

}	// ECHOSTATUS CDspCommObject::SetAudioFormat


//===========================================================================
//
//	Get the audio format for a pipe
//
//===========================================================================

ECHOSTATUS CDspCommObject::GetAudioFormat
( 
	WORD 							wPipeIndex,
	PECHOGALS_AUDIOFORMAT	pFormat
)
{
	if (wPipeIndex >= GetNumPipes() )
	{
		ECHO_DEBUGPRINTF( ("CDspCommObject::GetAudioFormat: Invalid pipe %d\n",
								 wPipeIndex) );

		return ECHOSTATUS_INVALID_CHANNEL;
	}

	pFormat->byDataAreBigEndian = 0;	// true for most of the formats
	pFormat->byMonoToStereo = 0;
	
	switch (SWAP(m_pDspCommPage->wAudioFormat[wPipeIndex]))
	{
		case DSP_AUDIOFORM_MS_8 :
			pFormat->wDataInterleave = 1;
			pFormat->wBitsPerSample = 8;
			pFormat->byMonoToStereo = 1;
			break;
			
		case DSP_AUDIOFORM_MS_16LE :
			pFormat->wDataInterleave = 1;
			pFormat->wBitsPerSample = 16;
			pFormat->byMonoToStereo = 1;			
			break;
			
		case DSP_AUDIOFORM_SS_8 :
			pFormat->wDataInterleave = 2;
			pFormat->wBitsPerSample = 8;
			break;

		case DSP_AUDIOFORM_SS_16LE :
			pFormat->wDataInterleave = 2;
			pFormat->wBitsPerSample = 16;
			break;
		
		case DSP_AUDIOFORM_SS_32LE :
			pFormat->wDataInterleave = 2;
			pFormat->wBitsPerSample = 32;
			break;			
		
		case DSP_AUDIOFORM_MS_32LE :
			pFormat->byMonoToStereo = 1;			
			// fall through

		case DSP_AUDIOFORM_MM_32LE :
			pFormat->wDataInterleave = 1;
			pFormat->wBitsPerSample = 32;
			break;			
			
		case DSP_AUDIOFORM_MM_32BE :
			pFormat->wDataInterleave = 1;
			pFormat->wBitsPerSample = 32;
			pFormat->byDataAreBigEndian = 1;
			break;			
			
		case DSP_AUDIOFORM_SS_32BE :
			pFormat->wDataInterleave = 2;
			pFormat->wBitsPerSample = 32;
			pFormat->byDataAreBigEndian = 1;
			break;			
		
	}
	
	return ECHOSTATUS_OK;
	
}	// void CDspCommObject::GetAudioFormat



/****************************************************************************

	Mixer methods

 ****************************************************************************/

//===========================================================================
//
// SetPipeOutGain - set the gain for a single output pipe
//
//===========================================================================

ECHOSTATUS CDspCommObject::SetPipeOutGain
( 
	WORD 	wPipeOut, 
	WORD	wBusOut,
	INT32	iGain,
	BOOL 	fImmediate
)
{
	if ( wPipeOut < m_wNumPipesOut )
	{
		//
		// Wait for the handshake
		//
		if ( !WaitForHandshake() )
			return ECHOSTATUS_DSP_DEAD;
			
		//
		// Save the new value
		//
		iGain = GENERIC_TO_DSP(iGain);
		m_pDspCommPage->OutLineLevel[ wPipeOut ] = (BYTE) iGain;

		/*
		ECHO_DEBUGPRINTF( ("CDspCommObject::SetPipeOutGain: Out pipe %d "
								 "= 0x%lx\n",
								 wPipeOut,
								 iGain) );
		*/

		//
		// If fImmediate is true, then do the gain setting right now.
		// If you want to do a batch of gain settings all at once, it's
		// more efficient to call this several times and then only set
		// fImmediate for the last one; then the DSP picks up all of
		// them at once.
		//								 
		if (fImmediate)
		{
			return UpdateAudioOutLineLevel();
		}

		return ECHOSTATUS_OK;		

	}

	ECHO_DEBUGPRINTF( ("CDspCommObject::SetPipeOutGain: Invalid out pipe "
							 "%d\n",
							 wPipeOut) );
	ECHO_DEBUGBREAK();	 
							 
	return ECHOSTATUS_INVALID_CHANNEL;
	
}	// SetPipeOutGain


//===========================================================================
//
// GetPipeOutGain returns the current gain for an output pipe.  This isn't
// really used as the mixer code in CEchoGals stores logical values for
// these, but it's here for completeness.
//
//===========================================================================

ECHOSTATUS CDspCommObject::GetPipeOutGain
( 
	WORD 	wPipeOut, 
	WORD 	wBusOut,
	INT32 &iGain
)
{
	if (wPipeOut < m_wNumPipesOut)
	{
		iGain = (INT32) (char) m_pDspCommPage->OutLineLevel[ wPipeOut ];
		iGain = DSP_TO_GENERIC(8);
		return ECHOSTATUS_OK;		
	}

	ECHO_DEBUGPRINTF( ("CDspCommObject::GetPipeOutGain: Invalid out pipe "
							 "%d\n",
							 wPipeOut) );
							 
	return ECHOSTATUS_INVALID_CHANNEL;
	
}	// GetPipeOutGain

	

//===========================================================================
//
// Set input bus gain - iGain is in units of 0.5 dB
//
//===========================================================================

ECHOSTATUS CDspCommObject::SetBusInGain( WORD wBusIn, INT32 iGain)
{
	if (wBusIn > m_wNumBussesIn)
		return ECHOSTATUS_INVALID_CHANNEL;

	//
	// Wait for the handshake (OK even if ASIC is not loaded)
	//
	if ( !WaitForHandshake() )
		return ECHOSTATUS_DSP_DEAD;
		
	//
	// Adjust the gain value
	//		
	iGain += GL20_INPUT_GAIN_MAGIC_NUMBER;
	
	//
	// Put it in the comm page
	//
	m_pDspCommPage->InLineLevel[wBusIn] = (BYTE) iGain;

	return UpdateAudioInLineLevel();
}	


//===========================================================================
//
// Get the input bus gain in units of 0.5 dB
//
//===========================================================================

ECHOSTATUS CDspCommObject::GetBusInGain( WORD wBusIn, INT32 &iGain)
{
	if (wBusIn > m_wNumBussesIn)
		return ECHOSTATUS_INVALID_CHANNEL;
		
	iGain = m_pDspCommPage->InLineLevel[wBusIn];
	iGain -= GL20_INPUT_GAIN_MAGIC_NUMBER;

	return ECHOSTATUS_OK;
}	


//===========================================================================
//
//	Set the nominal level for an input or output bus
//
// bState TRUE			-10 nominal level
// bState FALSE		+4 nominal level
//
//===========================================================================

ECHOSTATUS CDspCommObject::SetNominalLevel
(
	WORD	wBus,
	BOOL	bState
)
{
	//
	// Check the pipe index
	//
	if (wBus < (m_wNumBussesOut + m_wNumBussesIn))
	{
		//
		// Wait for the handshake (OK even if ASIC is not loaded)
		//
		if ( !WaitForHandshake() )
			return ECHOSTATUS_DSP_DEAD;

		//
		// Set the nominal bit
		//		
		if ( bState )
			m_pDspCommPage->cmdNominalLevel.SetIndexInMask( wBus );
		else
			m_pDspCommPage->cmdNominalLevel.ClearIndexInMask( wBus );

		return UpdateAudioOutLineLevel();
	}

	ECHO_DEBUGPRINTF( ("CDspCommObject::SetNominalOutLineLevel Invalid "
							 "index %d\n",
							 wBus ) );
	return ECHOSTATUS_INVALID_CHANNEL;

}	// ECHOSTATUS CDspCommObject::SetNominalLevel


//===========================================================================
//
//	Get the nominal level for an input or output bus
//
// bState TRUE			-10 nominal level
// bState FALSE		+4 nominal level
//
//===========================================================================

ECHOSTATUS CDspCommObject::GetNominalLevel
(
	WORD	wBus,
	PBYTE pbyState
)
{

	if (wBus < (m_wNumBussesOut + m_wNumBussesIn))
	{
		*pbyState = (BYTE)
			m_pDspCommPage->cmdNominalLevel.TestIndexInMask( wBus );
		return ECHOSTATUS_OK;
	}

	ECHO_DEBUGPRINTF( ("CDspCommObject::GetNominalLevel Invalid "
							 "index %d\n",
							 wBus ) );
	return ECHOSTATUS_INVALID_CHANNEL;
}	// ECHOSTATUS CDspCommObject::GetNominalLevel


//===========================================================================
//
//	Set the monitor level from an input bus to an output bus.
//
//===========================================================================

ECHOSTATUS CDspCommObject::SetAudioMonitor
(
	WORD	wBusOut,	// output bus
	WORD	wBusIn,	// input bus
	INT32	iGain,
	BOOL 	fImmediate
)
{
	/*
	ECHO_DEBUGPRINTF( ("CDspCommObject::SetAudioMonitor: "
							 "Out %d in %d Gain %d (0x%x)\n",
							 wBusOut, wBusIn, iGain, iGain) );
	*/

	//
	// The monitor array is a one-dimensional array;
	// compute the offset into the array
	//
	WORD	wOffset = ComputeAudioMonitorIndex( wBusOut, wBusIn );

	//
	// Wait for the offset
	//	
	if ( !WaitForHandshake() )
		return ECHOSTATUS_DSP_DEAD;

	//
	// Write the gain value to the comm page
	//
	iGain = GENERIC_TO_DSP(iGain);
	m_pDspCommPage->byMonitors[ wOffset ] = (BYTE) (iGain);
	
	//
	// If fImmediate is set, do the command right now
	//
	if (fImmediate)
	{
		return UpdateAudioOutLineLevel();
	}
	
	return ECHOSTATUS_OK;

}	// ECHOSTATUS CDspCommObject::SetAudioMonitor


//===========================================================================
//
// SetMetersOn turns the meters on or off.  If meters are turned on, the
// DSP will write the meter and clock detect values to the comm page
// at about 30 Hz.
//
//===========================================================================

ECHOSTATUS CDspCommObject::SetMetersOn
(
	BOOL bOn
)
{
	if ( bOn )
	{
		if ( 0 == m_wMeterOnCount )
		{
			SendVector( DSP_VC_METERS_ON );
		}
		m_wMeterOnCount++;
	}
	else
	{
		INT32	iDevice;
	
		if ( m_wMeterOnCount == 0 )
			return ECHOSTATUS_OK;

		if ( 0 == --m_wMeterOnCount )
		{
			SendVector( DSP_VC_METERS_OFF );
			
			for ( iDevice = 0; iDevice < DSP_MAXPIPES; iDevice++ )
			{
				BYTE muted;

				muted = (BYTE) GENERIC_TO_DSP(ECHOGAIN_MUTED);
				m_pDspCommPage->VUMeter[ iDevice ]   = muted;
				m_pDspCommPage->PeakMeter[ iDevice ] = muted;
			}
		}
	}
	return ECHOSTATUS_OK;
	
}	// ECHOSTATUS CDspCommObject::SetMetersOn


//===========================================================================
//
// Tell the DSP to read and update output, nominal & monitor levels 
//	in comm page.
//
//===========================================================================

ECHOSTATUS CDspCommObject::UpdateAudioOutLineLevel()
{
	//ECHO_DEBUGPRINTF( ( "CDspCommObject::UpdateAudioOutLineLevel:\n" ) );
	
	if (FALSE == m_bASICLoaded)
		return ECHOSTATUS_ASIC_NOT_LOADED;
	
	ClearHandshake();
	return( SendVector( DSP_VC_UPDATE_OUTVOL ) );
	
}	// ECHOSTATUS CDspCommObject::UpdateAudioOutLineLevel()


//===========================================================================
//
// Tell the DSP to read and update input levels in comm page
//
//===========================================================================

ECHOSTATUS CDspCommObject::UpdateAudioInLineLevel()
{
	//ECHO_DEBUGPRINTF( ( "CDspCommObject::UpdateAudioInLineLevel:\n" ) );
	
	if (FALSE == m_bASICLoaded)
		return ECHOSTATUS_ASIC_NOT_LOADED;

	ClearHandshake();
	return( SendVector( DSP_VC_UPDATE_INGAIN ) );
}		// ECHOSTATUS CDspCommObject::UpdateAudioInLineLevel()


//===========================================================================
//
// Tell the DSP to read and update virtual mixer levels 
//	in comm page.  This method is overridden by cards that actually 
// support a vmixer.
//
//===========================================================================

ECHOSTATUS CDspCommObject::UpdateVmixerLevel()
{
	ECHO_DEBUGPRINTF(("CDspCommObject::UpdateVmixerLevel\n"));
	return ECHOSTATUS_NOT_SUPPORTED;
}	// ECHOSTATUS CDspCommObject::UpdateVmixerLevel()


//===========================================================================
//
// Tell the DSP to change the input clock
//
//===========================================================================

ECHOSTATUS CDspCommObject::SetInputClock(WORD wClock)
{
	//
	// Wait for the last command
	//
	if (!WaitForHandshake())
		return ECHOSTATUS_DSP_DEAD;

	ECHO_DEBUGPRINTF( ("CDspCommObject::SetInputClock:\n") );		
		
	//
	// Write to the comm page
	//
	m_pDspCommPage->wInputClock = SWAP(wClock);
	
	//
	// Clear the handshake and send the command
	//
	ClearHandshake();
	ECHOSTATUS Status = SendVector(DSP_VC_UPDATE_CLOCKS);
	
	return Status;

}	// ECHOSTATUS CDspCommObject::SetInputClock


//===========================================================================
//
// Tell the DSP to change the output clock - Layla20 only
//
//===========================================================================

ECHOSTATUS CDspCommObject::SetOutputClock(WORD wClock)
{

	return ECHOSTATUS_CLOCK_NOT_SUPPORTED;
	
}	// ECHOSTATUS CDspCommObject::SetOutputClock


//===========================================================================
//
// Fill out an ECHOGALS_METERS struct using the current values in the 
// comm page.  This method is overridden for vmixer cards.
//
//===========================================================================

ECHOSTATUS CDspCommObject::GetAudioMeters
(
	PECHOGALS_METERS	pMeters
)
{
	pMeters->iNumPipesOut = 0;
	pMeters->iNumPipesIn = 0;

	//
	//	Output 
	// 
	DWORD dwCh = 0;
	WORD 	i;

	pMeters->iNumBussesOut = (INT32) m_wNumBussesOut;
	for (i = 0; i < m_wNumBussesOut; i++)
	{
		pMeters->iBusOutVU[i] = 
			DSP_TO_GENERIC( ((INT32) (INT8) m_pDspCommPage->VUMeter[ dwCh ]) );

		pMeters->iBusOutPeak[i] = 
			DSP_TO_GENERIC( ((INT32) (INT8) m_pDspCommPage->PeakMeter[ dwCh ]) );
		
		dwCh++;
	}

	pMeters->iNumBussesIn = (INT32) m_wNumBussesIn;	
	for (i = 0; i < m_wNumBussesIn; i++)
	{
		pMeters->iBusInVU[i] = 
			DSP_TO_GENERIC( ((INT32) (INT8) m_pDspCommPage->VUMeter[ dwCh ]) );
		pMeters->iBusInPeak[i] = 
			DSP_TO_GENERIC( ((INT32) (INT8) m_pDspCommPage->PeakMeter[ dwCh ]) );
		
		dwCh++;
	}
	
	return ECHOSTATUS_OK;
	
} // GetAudioMeters


#ifdef DIGITAL_INPUT_AUTO_MUTE_SUPPORT

//===========================================================================
//
// Digital input auto-mute - Gina24, Layla24, and Mona only
//
//===========================================================================

ECHOSTATUS CDspCommObject::GetDigitalInputAutoMute(BOOL &fAutoMute)
{
	fAutoMute = m_fDigitalInAutoMute;	
	
	ECHO_DEBUGPRINTF(("CDspCommObject::GetDigitalInputAutoMute %d\n",fAutoMute));
	
	return ECHOSTATUS_OK;
}

ECHOSTATUS CDspCommObject::SetDigitalInputAutoMute(BOOL fAutoMute)
{
	ECHO_DEBUGPRINTF(("CDspCommObject::SetDigitalInputAutoMute %d\n",fAutoMute));
	
	//
	// Store the flag
	//
	m_fDigitalInAutoMute = fAutoMute;
	
	//
	// Re-set the input clock to the current value - indirectly causes the 
	// auto-mute flag to be sent to the DSP
	//
	SetInputClock(m_wInputClock);
	
	return ECHOSTATUS_OK;
}

#endif // DIGITAL_INPUT_AUTO_MUTE_SUPPORT




/****************************************************************************

	Power management

 ****************************************************************************/

//===========================================================================
//
// Tell the DSP to go into low-power mode
//
//===========================================================================

ECHOSTATUS CDspCommObject::GoComatose()
{
	ECHO_DEBUGPRINTF(("CDspCommObject::GoComatose\n"));

	if (NULL != m_pwDspCode)
	{
		//
		// Make LoadFirmware do a complete reload
		//	
		m_pwDspCode = NULL;
		
		//
		// Make sure that the sample rate get re-set on wakeup
		// (really only for Indigo and Mia)
		//
		m_pDspCommPage->dwControlReg = 0;
		
		//
		// Put the DSP to sleep
		//
		return SendVector(DSP_VC_GO_COMATOSE);
	}
	
	return ECHOSTATUS_OK;

}	// end of GoComatose



#ifdef MIDI_SUPPORT

/****************************************************************************

	MIDI

 ****************************************************************************/

//===========================================================================
//
// Send a buffer full of MIDI data to the DSP
//
//===========================================================================

ECHOSTATUS CDspCommObject::WriteMidi
(
	PBYTE		pData,						// Ptr to data buffer
	DWORD		dwLength,					// How many bytes to write
	PDWORD	pdwActualCt					// Return how many actually written
)
{
	DWORD 		dwWriteCount,dwHandshake,dwStatus;
	BYTE			*pOutBuffer;
	
	
	//
	// Return immediately if the handshake flag is clar
	//
	dwHandshake = GetHandshakeFlag();
	if (0 == dwHandshake)
	{
		ECHO_DEBUGPRINTF(("CDCO::WriteMidi - can't write - handshake %ld\n",dwHandshake));
		
		*pdwActualCt = 0;
		return ECHOSTATUS_BUSY;
	}
	
	//
	// Return immediately if HF4 is clear - HF4 indicates that it is safe
	// to write MIDI output data
	//
	dwStatus = GetDspRegister( CHI32_STATUS_REG );
	if ( 0 == (dwStatus & CHI32_STATUS_REG_HF4 ) )
	{
		ECHO_DEBUGPRINTF(("CDCO::WriteMidi - can't write - dwStatus 0x%lx\n",dwStatus));
		
		*pdwActualCt = 0;
		return ECHOSTATUS_BUSY;
	}
	
	
	//
	// Copy data to the comm page; limit to the amount of space in the DSP output
	// FIFO and in the comm page
	//
	dwWriteCount = dwLength;
	if (dwWriteCount > (CP_MIDI_OUT_BUFFER_SIZE - 1))
	{
		dwWriteCount = CP_MIDI_OUT_BUFFER_SIZE - 1;
	}

	ECHO_DEBUGPRINTF(("WriteMidi - dwWriteCount %ld\n",dwWriteCount));
			
	*pdwActualCt = dwWriteCount;	// Save the # of bytes written for the caller

	pOutBuffer = m_pDspCommPage->byMidiOutData;
	*pOutBuffer = (BYTE) dwWriteCount;
	
	pOutBuffer++;
	
	OsCopyMemory(pOutBuffer,pData,dwWriteCount);

	//
	// Send the command to the DSP
	//	 
	ClearHandshake();
	m_pDspCommPage->dwMidiOutFreeCount = 0;
	SendVector( DSP_VC_MIDI_WRITE );
	
	//
	// Save the current time - used to detect if MIDI out is currently busy
	//
	ULONGLONG ullTime;

	m_pOsSupport->OsGetSystemTime( &ullTime );
	m_ullMidiOutTime = ullTime;
														
	return ECHOSTATUS_OK;
	
}		// ECHOSTATUS CDspCommObject::WriteMidi


//===========================================================================
//
// Called from the interrupt handler - get a MIDI input byte
//
//===========================================================================

ECHOSTATUS CDspCommObject::ReadMidi
(
	WORD 		wIndex,				// Buffer index
	DWORD &	dwData				// Return data
)
{
	if ( wIndex >= CP_MIDI_IN_BUFFER_SIZE )
		return ECHOSTATUS_INVALID_INDEX;

	//
	// Get the data
	//	
	dwData = SWAP( m_pDspCommPage->wMidiInData[ wIndex ] );

	//
	// Timestamp for the MIDI input activity indicator
	//
	ULONGLONG ullTime;

	m_pOsSupport->OsGetSystemTime( &ullTime );
	m_ullMidiInTime = ullTime;

	return ECHOSTATUS_OK;
	
}	// ECHOSTATUS CDspCommObject::ReadMidi


ECHOSTATUS CDspCommObject::SetMidiOn( BOOL bOn )
{
	if ( bOn )
	{
		if ( 0 == m_wMidiOnCount )
		{
			if ( !WaitForHandshake() )
				return ECHOSTATUS_DSP_DEAD;

			m_pDspCommPage->dwFlags |= SWAP( (DWORD) DSP_FLAG_MIDI_INPUT );
			
			ClearHandshake();
			SendVector( DSP_VC_UPDATE_FLAGS );
		}
		m_wMidiOnCount++;
	}
	else
	{
		if ( m_wMidiOnCount == 0 )
			return ECHOSTATUS_OK;

		if ( 0 == --m_wMidiOnCount )
		{
			if ( !WaitForHandshake() )
				return ECHOSTATUS_DSP_DEAD;
				
			m_pDspCommPage->dwFlags &= SWAP( (DWORD) ~DSP_FLAG_MIDI_INPUT );
			
			ClearHandshake();
			SendVector( DSP_VC_UPDATE_FLAGS );
		}
	}

	return ECHOSTATUS_OK;

}	// ECHOSTATUS CDspCommObject::SetMidiOn


//===========================================================================
//
// Detect MIDI output activity
//
//===========================================================================

BOOL CDspCommObject::IsMidiOutActive()
{
	ULONGLONG	ullCurTime;

	m_pOsSupport->OsGetSystemTime( &ullCurTime );
	return( ( ( ullCurTime - m_ullMidiOutTime ) > MIDI_ACTIVITY_TIMEOUT_USEC ) ? FALSE : TRUE );
	
}	// BOOL CDspCommObject::IsMidiOutActive()


#endif // MIDI_SUPPORT



// **** CDspCommObject.cpp ****