hwctxt.cpp

Microsoft WinCE 6.0 BSP FINAL release source code for use with the i.MX27ADS TO2 WCE600_FINAL_MX27_S

    }

    // We need to configure the CKO signal to output CKIH for the MC13783 CLI
    // clock input.
    /* TODO The CKIH is not there in Bono, need to find the substitute for it */
    DDKClockSetCKO(TRUE, DDK_CLOCK_CKO_SRC_CLK26M, DDK_CLOCK_CKO_DIV_1);

    // We now have the ability to access all of the hardware components that
    // are needed to perform audio recording and playback.
    rc = TRUE;

cleanUp:
    if (!rc) BSPAudioDeinit();

    DEBUGMSG(ZONE_FUNCTION, (_T("-HardwareContext::BSPAudioInit\n")));

    return rc;
}


//-----------------------------------------------------------------------------
//
//  Function:  BSPAudioDeinit
//
//  This function unmaps the peripheral registers previously mapped with
//  the MapRegisters function.
//
//  Parameters:
//      None.
//
//  Returns:
//      Returns TRUE if successful, otherwise returns FALSE.
//
//-----------------------------------------------------------------------------
BOOL HardwareContext::BSPAudioDeinit()
{
    DEBUGMSG(ZONE_FUNCTION, (_T("+HardwareContext::BSPAudioDeinit\n")));

    // Unmap SSI1 peripheral registers
    if (m_pSSI1)
    {
        MmUnmapIoSpace(m_pSSI1, sizeof(CSP_SSI_REG));
        m_pSSI1 = NULL;
    }

    // Unmap SSI2 peripheral registers
    if (m_pSSI2)
    {
        MmUnmapIoSpace(m_pSSI2, sizeof(CSP_SSI_REG));
        m_pSSI2 = NULL;
    }

    // Unmap AUDMUX peripheral registers
    if (m_pAUDMUX)
    {
        MmUnmapIoSpace(m_pAUDMUX, sizeof(CSP_AUDMUX_REG));
        m_pAUDMUX = NULL;
    }

    if (hStDAC != NULL)
    {
        PmicAudioClose(hStDAC);
        hStDAC = NULL;
    }

#ifdef AUDIO_RECORDING_ENABLED
    if (hVoiceCODEC != NULL)
    {
        PmicAudioClose(hVoiceCODEC);
        hVoiceCODEC = NULL;
    }
#endif

    DEBUGMSG(ZONE_FUNCTION, (_T("-HardwareContext::BSPAudioDeinit\n")));

    return TRUE;
}


//-----------------------------------------------------------------------------
//
//  Function: BSPAudioAllocDMABuffers
//
//  Allocate the audio DMA buffers.
//
//  Parameters:
//      pAddress - returns physical address of allocated DMA buffers
//
//  Returns:
//      PBYTE virtual address of allocated memory region (NULL if error)
//
//-----------------------------------------------------------------------------


PBYTE HardwareContext::BSPAudioAllocDMABuffers(PHYSICAL_ADDRESS *pAddress)
{

	    // Use dynamically allocated memory for the audio DMA buffers.

#ifdef AUDIO_RECORDING_ENABLED
	    // Allocate 2 DMA buffers each for audio playback and recording.
	    static const DMA_BUFFER_REGION_SIZE_NBYTES = AUDIO_DMA_PAGE_SIZE * 4;
#else
	    // Only allocate 2 DMA buffers for audio playback.
	    static const DMA_BUFFER_REGION_SIZE_NBYTES = AUDIO_DMA_PAGE_SIZE * 2;
#endif

	    DMA_ADAPTER_OBJECT Adapter;

	    memset(&Adapter, 0, sizeof(DMA_ADAPTER_OBJECT));
	    Adapter.InterfaceType = Internal;
	    Adapter.ObjectSize    = sizeof(DMA_ADAPTER_OBJECT);

	    // Allocate DMA buffers from external memory.
	    return (PBYTE)HalAllocateCommonBuffer(&Adapter,
	                                          DMA_BUFFER_REGION_SIZE_NBYTES,
	                                          pAddress,
	                                          FALSE);

}



//-----------------------------------------------------------------------------
//
//  Function: BSPAudioDeallocDMABuffers
//
//  Deallocate the audio DMA buffers that were previously allocated by calling
//  BSPAudioAllocDMABuffers().
//
//  Parameters:
//      virtual address.
//
//  Returns:
//      None.
//
//-----------------------------------------------------------------------------
void HardwareContext::BSPAudioDeallocDMABuffers(PVOID virtualAddress)
{
#ifndef BSP_AUDIO_DMA_BUF_ADDR

    // Only deallocate the audio DMA buffer memory if it was previously
    // dynamically allocated.

    PHYSICAL_ADDRESS phyAddr;

    // Logical address parameter is ignored
    phyAddr.QuadPart = 0;

    HalFreeCommonBuffer(NULL, 0, phyAddr, virtualAddress, FALSE);

#endif // #ifndef BSP_AUDIO_DMA_BUF_ADDR
}



//-----------------------------------------------------------------------------
//
//  Function: BSPAudioPowerUp
//
//  This function powers up the SSI, AUDMUX, and external audio chip.
//
//  Parameters:
//      power state.
//
//  Returns:
//      None.
//
//-----------------------------------------------------------------------------
void HardwareContext::BSPAudioPowerUp(const BOOL fullPowerUp)
{
    if (!fullPowerUp)
    {
        PmicAudioPowerUp();
    }
    else
    {
        BSPAudioSetCodecPower(AUDIO_PWR_STATE_STANDBY);
    }
}


//-----------------------------------------------------------------------------
//
//  Function: BSPAudioPowerDown
//
//  This function powers down the SSI, AUDMUX, and external audio chip.
//
//  Parameters:
//      power state.
//
//  Returns:
//      None.
//
//-----------------------------------------------------------------------------
void HardwareContext::BSPAudioPowerDown(const BOOL fullPowerOff)
{
    if (!fullPowerOff)
    {
        PmicAudioPowerDown();
    }
    else
    {
        BSPAudioSetCodecPower(AUDIO_PWR_STATE_OFF);
    }
}


//-----------------------------------------------------------------------------
//
//  Function: BSPAudioGetStDACSSI
//
//  Returns the SSI that is currently connected to the PMIC Stereo DAC.
//
//  Parameters:
//      None.
//
//  Returns:
//      The SSI that is connected to the PMIC Stereo DAC.
//
//-----------------------------------------------------------------------------
PCSP_SSI_REG HardwareContext::BSPAudioGetStDACSSI()
{
    return STEREO_DAC_SSI;
}


#ifdef AUDIO_RECORDING_ENABLED

//-----------------------------------------------------------------------------
//
//  Function: BSPAudioGetVCodecSSI
//
//  Returns the SSI that is currently connected to the PMIC Voice CODEC.
//
//  Parameters:
//      None.
//
//  Returns:
//      The SSI that is connected to the PMIC Voice CODEC.
//
//-----------------------------------------------------------------------------
PCSP_SSI_REG HardwareContext::BSPAudioGetVCodecSSI()
{
    return VOICE_CODEC_SSI;
}

#endif // #ifdef AUDIO_RECORDING_ENABLED

//------------------------------------------------------------------------------
//
//  FUNCTION:       BSPGetSsiFifoPhyAddr
//
//  DESCRIPTION:    Returns the SSI channel physical register address
//                  for the desired SSI direction and channel.
//
//  PARAMETERS:     ssiId - SSI id
//                  dir - SSI transfer direction
//                  ch  - SSI channel
//
//  RETURNS:        address of SSI channel transmit/receive
//                  register. 0 if invalid parameters
//
//------------------------------------------------------------------------------
UINT32 HardwareContext::BSPGetSsiFifoPhyAddr(SSI_TRANSFER_DIR dir, SSI_CHANNEL ch,
																	CSP_SSI_REG *SsiSrc)
{
    UINT32 		addr = 0;
    CSP_SSI_REG	*pSSI = NULL;

    //DEBUGMSG(SSI_ZONE_FUNC, (TEXT("SsiClass::GetFifoPhyAddr+ m_ssiID(%d)\r\n"), m_ssiID));

    if (SsiSrc == STEREO_DAC_SSI)
    {
    	//pSSI = (PCSP_SSI_REG *)CSP_BASE_REG_PA_SSI2;
       //TODO Change to SSI2 once the hardware fix is done
       pSSI = (CSP_SSI_REG *)CSP_BASE_REG_PA_SSI2;
    }

#ifdef AUDIO_RECORDING_ENABLED
    if (SsiSrc == VOICE_CODEC_SSI)
    {
       pSSI = (CSP_SSI_REG*)CSP_BASE_REG_PA_SSI1;
    }
#endif

    switch(dir)
    {
        case SSI_TRANSFER_TX:
            if(ch == SSI_CHANNEL0)
                addr = (UINT32)&pSSI->STX0;
            else if(ch == SSI_CHANNEL1)
                addr = (UINT32)&pSSI->STX1;
            break;
        case SSI_TRANSFER_RX:
            if(ch == SSI_CHANNEL0)
                addr = (UINT32)&pSSI->SRX0;
            else if(ch == SSI_CHANNEL1)
                addr = (UINT32)&pSSI->SRX1;
            break;
        default:
            //ERRORMSG(SSI_ZONE_ERROR, (TEXT("GetFifoPhyAddr: Invalid transfer dir! %d\r\n"), dir));
            goto cleanup;
    }

cleanup:
    //DEBUGMSG(SSI_ZONE_FUNC, (TEXT("SsiClass::GetFifoAddr- addr(0x%08x)\r\n"), addr));
    return addr;
}

#ifdef DEBUG
//------------------------------------------------------------------------------
//
//  FUNCTION:       BSPSSIShowReg
//
//  DESCRIPTION:    Gives the SSI register dump
//
//  PARAMETERS:     SSI register mapping pointer
//
//  RETURNS:        None.
//
//------------------------------------------------------------------------------
void HardwareContext::BSPSSIShowReg(CSP_SSI_REG *pSSI)
{

	UINT32	val;

	DEBUGMSG(1, (TEXT("SSI General Registers:\r\n")));
	val = INREG32(&pSSI->STX0);
    DEBUGMSG(1, (TEXT("STX0(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->STX1);
	DEBUGMSG(1, (TEXT("STX1(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SRX0);
	DEBUGMSG(1, (TEXT("SRX0(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->STX1);
	DEBUGMSG(1, (TEXT("STX1(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SCR);
	DEBUGMSG(1, (TEXT("SCR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SISR);
	DEBUGMSG(1, (TEXT("SISR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SIER);
	DEBUGMSG(1, (TEXT("SIER(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->STCR);
	DEBUGMSG(1, (TEXT("STCR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SRCR);
	DEBUGMSG(1, (TEXT("SRCR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->STCCR);
	DEBUGMSG(1, (TEXT("STCCR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SRCCR);
	DEBUGMSG(1, (TEXT("SRCCR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SFCSR);
	DEBUGMSG(1, (TEXT("SFCSR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->STR);
	DEBUGMSG(1, (TEXT("STR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SOR);
	DEBUGMSG(1, (TEXT("SOR(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SACNT);
	DEBUGMSG(1, (TEXT("SACNT(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SACADD);
	DEBUGMSG(1, (TEXT("SACADD(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SACDAT);
	DEBUGMSG(1, (TEXT("SACDAT(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SATAG);
	DEBUGMSG(1, (TEXT("SATAG(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->STMSK);
	DEBUGMSG(1, (TEXT("STMSK(0x%08x)\r\n"), val));
	val = INREG32(&pSSI->SRMSK);
	DEBUGMSG(1, (TEXT("SRMSK(0x%08x)\r\n"), val));

}
#endif

#ifdef DEBUG
//------------------------------------------------------------------------------