// ****************************************************************************
//
//      CLaylaDspCommObject.cpp
//
//              Implementation file for EchoGals generic driver Layla 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"
#include "CLaylaDspCommObject.h"

#include "Layla20DSP.c"
#include "LaylaASIC.c"

//
// The ASIC files for Layla20 are always this size
//
#define LAYLA_ASIC_SIZE         32385


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

        Construction and destruction

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

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

CLaylaDspCommObject::CLaylaDspCommObject
(
        PDWORD          pdwRegBase,                             // Virtual ptr to DSP registers
        PCOsSupport     pOsSupport
) : CDspCommObject( pdwRegBase, pOsSupport )
{
        strcpy( m_szCardName, "Layla" );
        m_pdwDspRegBase = pdwRegBase;           // Virtual addr DSP's register base

        m_wNumPipesOut = 12;
        m_wNumPipesIn = 10;
        m_wNumBussesOut = 12;
        m_wNumBussesIn = 10;
        m_wFirstDigitalBusOut = 10;
        m_wFirstDigitalBusIn = 8;

        m_fHasVmixer = FALSE;

        m_wNumMidiOut = 1;                                      // # MIDI out channels
        m_wNumMidiIn = 1;                                               // # MIDI in  channels

        m_bHasASIC = TRUE;

        m_pwDspCodeToLoad = pwLayla20DSP;
        
}       // CLaylaDspCommObject::CLaylaDspCommObject( DWORD dwPhysRegBase )


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

CLaylaDspCommObject::~CLaylaDspCommObject()
{
        ECHO_DEBUGPRINTF( ( "CLaylaDspCommObject::~CLaylaDspCommObject() is toast!\n" ) );
}       // CLaylaDspCommObject::~CLaylaDspCommObject()




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

        Hardware setup and config

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

//===========================================================================
//
// Layla20 has an ASIC in the external box
//
//===========================================================================

BOOL CLaylaDspCommObject::LoadASIC()
{
        if ( m_bASICLoaded == TRUE )
                return TRUE;

        if ( !CDspCommObject::LoadASIC( DSP_FNC_LOAD_LAYLA_ASIC,
                                                                                          pbLaylaASIC,
                                                                                          LAYLA_ASIC_SIZE ) )
                return FALSE;
        //
        // Check if ASIC is alive and well.
        //
        return( CheckAsicStatus() );
}       // BOOL CLaylaDspCommObject::LoadASIC()


//===========================================================================
//
// SetSampleRate
// 
// Set the sample rate for Layla
//
// Layla is simple; just send it the sampling rate (assuming that the clock
// mode is correct).
//
//===========================================================================

DWORD CLaylaDspCommObject::SetSampleRate( DWORD dwNewSampleRate )
{
        //
        // Only set the clock for internal mode
        //      Do not return failure, simply treat it as a non-event.
        //
        if ( GetInputClock() != ECHO_CLOCK_INTERNAL )
        {
                ECHO_DEBUGPRINTF( ( "SetSampleRate: Cannot set sample rate because "
                                                                  "Layla clock NOT set to CLK_CLOCKININTERNAL\n" ) );
                m_pDspCommPage->dwSampleRate = SWAP( dwNewSampleRate );
                return GetSampleRate();
        }
        
        //
        // Sanity check - check the sample rate
        //
        if ( ( dwNewSampleRate < 8000 ) ||
                  ( dwNewSampleRate > 50000 ) )
        {
                ECHO_DEBUGPRINTF( ( "SetSampleRate: Layla sample rate %ld out of range, "
                                                                  "no change made\n",
                                                                  dwNewSampleRate) );
                return 0xffffffff;
        }

        if ( !WaitForHandshake() )
                return 0xffffffff;

        m_pDspCommPage->dwSampleRate = SWAP( dwNewSampleRate );
        
        ClearHandshake();
        SendVector( DSP_VC_SET_LAYLA_SAMPLE_RATE );
        ECHO_DEBUGPRINTF( ( "SetSampleRate: Layla sample rate changed to %ld\n",
                                                          dwNewSampleRate ) );
        return( dwNewSampleRate );
}       // DWORD CLaylaDspCommObject::SetSampleRate( DWORD dwNewSampleRate )


//===========================================================================
//
// Send new input clock setting to DSP
//
//===========================================================================

ECHOSTATUS CLaylaDspCommObject::SetInputClock(WORD wClock)
{
        BOOL                    bSetRate;
        WORD                    wNewClock;

        ECHO_DEBUGPRINTF( ( "CLaylaDspCommObject::SetInputClock:\n" ) );

        bSetRate = FALSE;
        
        switch ( wClock )
        {
                case ECHO_CLOCK_INTERNAL : 
                        ECHO_DEBUGPRINTF( ( "\tSet Layla24 clock to INTERNAL\n" ) );

                        // If the sample rate is out of range for some reason, set it
                        // to a reasonable value.  mattg
                        if ( ( GetSampleRate() < 8000 ) ||
                             ( GetSampleRate() > 50000 ) )
                        {
                                m_pDspCommPage->dwSampleRate = SWAP( (DWORD) 48000 );
                        }

                        bSetRate = TRUE;
                        wNewClock = LAYLA20_CLOCK_INTERNAL;
                        break;

                case ECHO_CLOCK_SPDIF:
                        ECHO_DEBUGPRINTF( ( "\tSet Layla20 clock to SPDIF\n" ) );
                        
                        wNewClock = LAYLA20_CLOCK_SPDIF;
                        break;

                case ECHO_CLOCK_WORD: 
                        ECHO_DEBUGPRINTF( ( "\tSet Layla20 clock to WORD\n" ) );
                        
                        wNewClock = LAYLA20_CLOCK_WORD;
                        
                        break;

                case ECHO_CLOCK_SUPER: 
                        ECHO_DEBUGPRINTF( ( "\tSet Layla20 clock to SUPER\n" ) );
                        
                        wNewClock = LAYLA20_CLOCK_SUPER;
                        
                        break;

                default :
                        ECHO_DEBUGPRINTF(("Input clock 0x%x not supported for Layla24\n",wClock));
                        ECHO_DEBUGBREAK();
                                return ECHOSTATUS_CLOCK_NOT_SUPPORTED;

        }               // switch (wClock)

        //
        // Winner! Save the new input clock.
        //
        m_wInputClock = wClock;

        //
        // Send the new clock to the DSP
        //
        m_pDspCommPage->wInputClock = SWAP(wNewClock);
        ClearHandshake();
        SendVector( DSP_VC_UPDATE_CLOCKS );
        
        if ( bSetRate )
                SetSampleRate();
                
        return ECHOSTATUS_OK;
}               // ECHOSTATUS CLaylaDspCommObject::SetInputClock()


//===========================================================================
//
// Set new output clock
//
//===========================================================================

ECHOSTATUS CLaylaDspCommObject::SetOutputClock(WORD wClock)
{
        WORD wLaylaOutClock;

        if (FALSE == m_bASICLoaded)
                return ECHOSTATUS_ASIC_NOT_LOADED;
                
        if (!WaitForHandshake())
                return ECHOSTATUS_DSP_DEAD;

        ECHO_DEBUGPRINTF( ("CDspCommObject::SetOutputClock:\n") );
                
        //
        // Translate generic driver clock constants to values for Layla20 firmware
        //
        switch (wClock)
        {
                case ECHO_CLOCK_SUPER :
                        wLaylaOutClock = LAYLA20_OUTPUT_CLOCK_SUPER;
                        break;
        
                case ECHO_CLOCK_WORD :
                        wLaylaOutClock = LAYLA20_OUTPUT_CLOCK_WORD;
                        break;
                                                                                                                        
                default :
                        return ECHOSTATUS_INVALID_PARAM;
        }

        m_pDspCommPage->wOutputClock = SWAP(wLaylaOutClock);
        m_wOutputClock = wClock;
        
        ClearHandshake();
        ECHOSTATUS Status = SendVector(DSP_VC_UPDATE_CLOCKS);
        
        return Status;
}       // ECHOSTATUS CLaylaDspCommObject::SetOutputClock


//===========================================================================
//
// Input bus gain - iGain is in units of .5 dB
//
//===========================================================================

ECHOSTATUS CLaylaDspCommObject::SetBusInGain( WORD wBusIn, INT32 iGain)
{
        ECHO_DEBUGPRINTF(("CLaylaDspCommObject::SetBusInGain\n"));
        
        if (wBusIn >= LAYLA20_INPUT_TRIMS)
                return ECHOSTATUS_INVALID_CHANNEL;

        //
        // Store the gain for later use
        //
        m_byInputTrims[wBusIn] = (BYTE) iGain;

        //
        // Adjust the input gain depending on the nominal level switch
        //
        BYTE byMinus10;
        GetNominalLevel( wBusIn + m_wNumBussesOut, &byMinus10);
        
        if (0 == byMinus10)
        {
                //
                // This channel is in +4 mode; subtract 12 dB from the input gain
                // (note that iGain is in units of .5 dB)
                //
                iGain -= 12 << 1;
        }
        
        return CDspCommObject::SetBusInGain(wBusIn,iGain);

}       


ECHOSTATUS CLaylaDspCommObject::GetBusInGain( WORD wBusIn, INT32 &iGain)
{
        if (wBusIn >= LAYLA20_INPUT_TRIMS)
                return ECHOSTATUS_INVALID_CHANNEL;
        
        iGain = (INT32) m_byInputTrims[wBusIn]; 
        
        return ECHOSTATUS_OK;
}       


//===========================================================================
//
// Set the nominal level for an input or output bus
//
//      Set bState to TRUE for -10, FALSE for +4 
//
// Layla20 sets the input nominal level by adjusting the 
// input trim
//
//===========================================================================

ECHOSTATUS CLaylaDspCommObject::SetNominalLevel
(
        WORD    wBus,
        BOOL    bState
)
{
        ECHO_DEBUGPRINTF(("CLaylaDspCommObject::SetNominalLevel\n"));

        if (wBus < m_wNumBussesOut)
        {
                //
                //      This is an output bus; call the base class routine to service it
                //
                return CDspCommObject::SetNominalLevel(wBus,bState);
        }

        //
        // Check the bus number
        //
        ECHO_DEBUGPRINTF(("\tChecking the bus number\n"));
        if (wBus < (m_wNumBussesOut + LAYLA20_INPUT_TRIMS))
        {
                ECHO_DEBUGPRINTF(("\twBus %d  m_pDspCommPage %p\n",wBus,m_pDspCommPage));
                //
                // Set the nominal bit in the comm page
                //              
                if ( bState )
                        m_pDspCommPage->cmdNominalLevel.SetIndexInMask( wBus );
                else
                        m_pDspCommPage->cmdNominalLevel.ClearIndexInMask( wBus );
                
                //
                // Set the input trim, using the current gain
                //      
                ECHO_DEBUGPRINTF(("\tCalling SetBusInGain\n"));
                
                wBus = wBus - m_wNumBussesOut;
                return SetBusInGain(    wBus, (INT32) m_byInputTrims[wBus]);
        }

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

}       // ECHOSTATUS CLaylaDspCommObject::SetNominalLevel


//===========================================================================
//
// ASIC status check
//
// This test sometimes fails for Layla20; for Layla20, the loop runs 5 times
// and succeeds if it wins on three of the loops.
//
//===========================================================================

BOOL CLaylaDspCommObject::CheckAsicStatus()
{
        DWORD dwNumTests;
        DWORD dwNumWins;
        BOOL bLoaded;

        dwNumTests = NUM_ASIC_ATTEMPTS;
        dwNumWins = 0;
        do
        {
                bLoaded = CDspCommObject::CheckAsicStatus();
                if (FALSE != bLoaded)
                {
                        dwNumWins++;
                        if (NUM_ASIC_WINS == dwNumWins)
                        {
                                m_bASICLoaded = TRUE;
                                break;
                        }
                }
        
                m_bASICLoaded = FALSE;
                dwNumTests--;
        } while (dwNumTests != 0);

        return m_bASICLoaded;

}       // BOOL CLaylaDspCommObject::CheckAsicStatus()


// **** LaylaDspCommObject.cpp ****