hwctxt.cpp

6410BSP3

void
HardwareContext::InterruptThreadInputDMA()
{
    ULONG InputTransferred;        // How can I use it ???

#if (_WIN32_WCE < 600)
    // Fast way to access embedded pointers in wave headers in other processes.
    SetProcPermissions((DWORD)-1);
#endif

    WAV_INF((_T("[WAV:INF] ++InterruptThreadInputDMA()\n\r")));

    while(TRUE)
    {
        WaitForSingleObject(m_hInputDMAInterrupt, INFINITE);

        Lock();

        __try
        {
            DMA_set_interrupt_mask(&g_InputDMA);
            DMA_clear_interrupt_pending(&g_InputDMA);

            InterruptDone(m_dwSysintrInput);

            DMA_clear_interrupt_mask(&g_InputDMA);

            if ( m_Dx == D0 )
            {
                if (m_nInputBufferInUse == INPUT_DMA_BUFFER0)
                {
                    // Buffer0 DMA finished
                    // DMA start with Buffer 1
                    m_nInputBufferInUse = INPUT_DMA_BUFFER1;
                }
                else
                {
                    // Buffer 1 DMA finished
                    // DMA start with Buffer 0
                    m_nInputBufferInUse = INPUT_DMA_BUFFER0;
                }

                if(m_InputDMAStatus & DMA_BIU)
                {
                    m_InputDMAStatus &= ~DMA_STRTB;        // Buffer B just completed...
                    m_InputDMAStatus |= DMA_DONEB;
                    m_InputDMAStatus &= ~DMA_BIU;        // Buffer A is in use
                }
                else
                {
                    m_InputDMAStatus &= ~DMA_STRTA;        // Buffer A just completed...
                    m_InputDMAStatus |= DMA_DONEA;
                    m_InputDMAStatus |= DMA_BIU;            // Buffer B is in use
                }

                InputTransferred = TransferInputBuffers(m_InputDMAStatus);
                WAV_INF((_T("[WAV:INF] InputTransferred = %d\n\r"), InputTransferred));
            }
        }
        __except(GetExceptionCode()==STATUS_ACCESS_VIOLATION ?
                EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH)
        {
            WAV_ERR((_T("WAVDEV2.DLL:InterruptThreadInputDMA() - EXCEPTION: %d"), GetExceptionCode()));
        }

        Unlock();
    }

    WAV_INF((_T("[WAV:INF] --InterruptThreadInputDMA()\n\r")));
}


BOOL
HardwareContext::MapRegisters()
{
    BOOL bRet = TRUE;
    PHYSICAL_ADDRESS    ioPhysicalBase = {0,0};

    WAV_MSG((_T("[WAV] ++MapRegisters()\n\r")));

    // Alloc and Map GPIO SFR
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_GPIO;
    g_pGPIOReg = (S3C6410_GPIO_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_GPIO_REG), FALSE);
    if (g_pGPIOReg == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pGPIOReg MmMapIoSpace() Failed\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

    // Alloc and Map DMAC0 SFR
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_DMA0;    
    g_pDMAC0Reg = (S3C6410_DMAC_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_DMAC_REG), FALSE);
    if (g_pDMAC0Reg == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pDMAC0Reg MmMapIoSpace() Failed\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

    // Alloc and Map DMAC1 SFR
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_DMA1;
    g_pDMAC1Reg = (S3C6410_DMAC_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_DMAC_REG), FALSE);
    if (g_pDMAC1Reg == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pDMAC1Reg MmMapIoSpace() Failed\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

    // Alloc and Map AC97 Interface SFR
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_AC97;    
    g_pAC97Reg = (S3C6410_AC97_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_AC97_REG), FALSE);
    if (g_pAC97Reg == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pAC97Reg MmMapIoSpace() Failed\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

    // Alloc and Map System Controller SFR
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_SYSCON;      
    g_pSysConReg = (S3C6410_SYSCON_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_SYSCON_REG), FALSE);
    if (g_pSysConReg == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pSysConReg MmMapIoSpace() Failed\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

CleanUp:

    if (bRet == FALSE)
    {
        UnMapRegisters();
    }

    WAV_MSG((_T("[WAV] --MapRegisters()\n\r")));

    return(TRUE);
}


BOOL
HardwareContext::UnMapRegisters()
{
    WAV_MSG((_T("[WAV] UnMapRegisters()\n\r")));

    if (g_pGPIOReg != NULL)
    {
        MmUnmapIoSpace((PVOID)g_pGPIOReg, sizeof(S3C6410_GPIO_REG));
        g_pGPIOReg = NULL;
    }

    if (g_pAC97Reg != NULL)
    {
        MmUnmapIoSpace((PVOID)g_pAC97Reg, sizeof(S3C6410_AC97_REG));
        g_pAC97Reg = NULL;
    }

    if (g_pDMAC0Reg != NULL)
    {
        MmUnmapIoSpace((PVOID)g_pDMAC0Reg, sizeof(S3C6410_DMAC_REG));
        g_pDMAC0Reg = NULL;
    }

    if (g_pDMAC1Reg != NULL)
    {
        MmUnmapIoSpace((PVOID)g_pDMAC1Reg, sizeof(S3C6410_DMAC_REG));
        g_pDMAC1Reg = NULL;
    }

    if (g_pSysConReg != NULL)
    {
        MmUnmapIoSpace((PVOID)g_pSysConReg, sizeof(S3C6410_SYSCON_REG));
        g_pSysConReg = NULL;
    }

    return TRUE;
}


BOOL
HardwareContext::MapDMABuffers()
{
    PVOID pVirtDMABufferAddr = NULL;
    DMA_ADAPTER_OBJECT Adapter;
    BOOL bRet = TRUE;

    WAV_MSG((_T("[WAV] ++MapDMABuffers()\n\r")));

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

    // Allocate DMA Buffer
    pVirtDMABufferAddr = HalAllocateCommonBuffer(&Adapter, AUDIO_DMA_BUFFER_SIZE, &g_PhyDMABufferAddr, FALSE);
    if (pVirtDMABufferAddr == NULL)
    {
        WAV_MSG((_T("[WAV:ERR] MapDMABuffers() : DMA Buffer Allocation Failed\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

    // Setup the Physical Address of DMA Buffer Page Address
    m_OutputDMABufferPhyPage[0] = (UINT32)g_PhyDMABufferAddr.LowPart;
    m_OutputDMABufferPhyPage[1] = (UINT32)(g_PhyDMABufferAddr.LowPart+AUDIO_DMA_PAGE_SIZE);
    m_InputDMABufferPhyPage[0] = (UINT32)(g_PhyDMABufferAddr.LowPart+AUDIO_DMA_PAGE_SIZE*2);
    m_InputDMABufferPhyPage[1] = (UINT32)(g_PhyDMABufferAddr.LowPart+AUDIO_DMA_PAGE_SIZE*3);

    // Setup the Virtual Address of DMA Buffer Page Address
    m_OutputDMABufferVirPage[0] = (PBYTE)pVirtDMABufferAddr;
    m_OutputDMABufferVirPage[1] = (PBYTE)((UINT32)pVirtDMABufferAddr+AUDIO_DMA_PAGE_SIZE);
    m_InputDMABufferVirPage[0] = (PBYTE)((UINT32)pVirtDMABufferAddr+AUDIO_DMA_PAGE_SIZE*2);
    m_InputDMABufferVirPage[1] = (PBYTE)((UINT32)pVirtDMABufferAddr+AUDIO_DMA_PAGE_SIZE*3);

CleanUp:

    WAV_MSG((_T("[WAV] --MapDMABuffers() : %d\n\r"), bRet));

    return bRet;
}


BOOL
HardwareContext::UnMapDMABuffers()
{
    WAV_MSG((_T("[WAV] UnMapDMABuffers()\n\r")));

    if(m_OutputDMABufferVirPage[0])
    {
        PHYSICAL_ADDRESS PhysicalAddress;
        PhysicalAddress.LowPart = m_OutputDMABufferPhyPage[0];    // No Meaning just for compile

        HalFreeCommonBuffer(0, 0, PhysicalAddress, (PVOID)m_OutputDMABufferVirPage[0], FALSE);

        m_OutputDMABufferVirPage[0] = NULL;
        m_OutputDMABufferVirPage[1] = NULL;
        m_InputDMABufferVirPage[0] = NULL;
        m_InputDMABufferVirPage[1] = NULL;
    }

    return TRUE;
}


void
HardwareContext::CodecPowerOn()
{
    WAV_MSG((_T("[WAV] ++CodecPowerOn() \n\r")));

    // Codec Power is no controllerable in SMDK6410

    WAV_MSG((_T("[WAV] --CodecPowerOn() \n\r")));
}


void
HardwareContext::CodecPowerOff()
{
    WAV_MSG((_T("[WAV] ++CodecPowerOff() \n\r")));

    // Codec Power is no controllerable in SMDK6410

    WAV_MSG((_T("[WAV] --CodecPowerOff() \n\r")));
}


BOOL
HardwareContext::InitAC97()
{
    BOOL bRet = FALSE;

    WAV_MSG((_T("[WAV] ++InitAC97() \n\r")));

    AC97_initialize_ACLink();

    // WM9713 Need This !!!!
    WriteCodecRegister(WM9713_POWER_CONTROL, 0x1000);

    AC97_enable_codec_ready_interrupt();

    AC97_enable_ACLink_data_transfer();

    bRet = AC97_wait_for_codec_ready();
    if (bRet == FALSE)
    {
        WAV_ERR((_T("[WAV:ERR] --InitAC97() : AC97 Initialize Failed\n\r")));
        return FALSE;
    }

    AC97_disable_all_interrupt();
    AC97_clear_all_interrupt();

    AC97_set_pcmout_transfer_mode(AC97_CH_OFF);
    AC97_set_pcmin_transfer_mode(AC97_CH_OFF);

    WAV_MSG((_T("[WAV] --InitAC97() \n\r")));

    return TRUE;
}


BOOL
HardwareContext::InitCodec()
{
    USHORT CodecVendorID0, CodecVendorID1;
    BOOL bRet = TRUE;

    WAV_MSG((_T("[WAV] ++InitCodec()\n\r")));

    WriteCodecRegister(WM9713_POWER_CONTROL, 0x0000);
    WriteCodecRegister(WM9713_POWERDOWN1, 0x0000);
    WriteCodecRegister(WM9713_POWERDOWN2, 0x0000);
    WriteCodecRegister(WM9713_MCLK_PLL_CTRL0, 0x0b80);

    WriteCodecRegister(WM9713_HEADPHONE_VOL, 0x0808);            // Unmute HPL, HPR
    WriteCodecRegister(WM9713_DAC_VOL_ROUTING, 0x6404);        // Unmute DAC to HPMix, SPKMix, MONOMix, 0 dB
    WriteCodecRegister(WM9713_OUTPUT_MUX, 0x00a0);            // Output HPL, HPR is HPMix, All others is Vmid

    WriteCodecRegister(WM9713_RECORD_ROUTING_MUX, 0xd652);    // Record Mux Source is LineIn, +20dB
    WriteCodecRegister(WM9713_RECORD_VOL, 0x0000);            // Unmute ADC input

    WriteCodecRegister(WM9713_ADDITIONAL_FUNC2, 0x0080);        // AC97_ADDITIONAL_FUNC2    // Set DAC Auto-Mute, bit[1:0]=00, ADC Slot(L/R=3/4)
    WriteCodecRegister(WM9713_EXTED_AUDIOCTRL, 0x0031);         // bit[5:4]=11, SPDIF Output Slot(L/R=10/11), VRA Enabled

    //------------------------------------------------------------------------------
    // If using sampling rate other than 48KHz you must enable VRA before set sampling rate !!!!!
    //------------------------------------------------------------------------------
    WriteCodecRegister(WM9713_AUDIO_DAC_RATE, SAMPLERATE);        // 2Ch DAC Sample rate
    WriteCodecRegister(WM9713_AUDIO_ADC_RATE, SAMPLERATE);        // 32h ADC Sample rate
    WriteCodecRegister(WM9713_AUX_DAC_RATE, SAMPLERATE);         // AC97_AUXDAC_RATE    // 2Eh AUXDAC Sample rate

    CodecMuteControl(DMA_CH_OUT | DMA_CH_IN, FALSE);    // output, Input Mute
    CodecPowerControl();                                // ADC, DAC Power Off

    CodecVendorID0 = ReadCodecRegister(WM9713_VENDOR_ID1);
    CodecVendorID1 = ReadCodecRegister(WM9713_VENDOR_ID2);

    if (CodecVendorID0 != 0x574d || CodecVendorID1 != 0x4c13)
    {
        // 0x574D4C13 is VenderID of WM9713 Codec
        WAV_ERR((_T("[WAV:ERR] InitCodec() : VenderID Mismatch\n\r")));
        bRet = FALSE;
    }

    WAV_INF((_T("[WAV:INF] InitCodec() : VenderID = 0x%08x\n\r"), ((CodecVendorID0<<16) | CodecVendorID1)));

    WAV_MSG((_T("[WAV] --InitCodec()\n\r")));

    return bRet;
}


BOOL
HardwareContext::InitOutputDMA()
{
    BOOL bRet = TRUE;

    WAV_MSG((_T("[WAV] ++InitOutputDMA()\n\r")));

    if (!g_PhyDMABufferAddr.LowPart)
    {
        WAV_ERR((_T("[WAV:ERR] InitOutputDMA() : DMA Buffer is Not Allocated Yet\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

    bRet = DMA_request_channel(&g_OutputDMA, DMA_AC97_PCMOUT);
    if (bRet)
    {
        DMA_initialize_channel(&g_OutputDMA, TRUE);
        DMA_set_channel_source(&g_OutputDMA, m_OutputDMABufferPhyPage[0], WORD_UNIT, BURST_1, INCREASE);
        DMA_set_channel_destination(&g_OutputDMA, AC97_get_pcmout_physical_buffer_address(), WORD_UNIT, BURST_1, FIXED);
        DMA_set_channel_transfer_size(&g_OutputDMA, AUDIO_DMA_PAGE_SIZE);
        DMA_initialize_LLI(&g_OutputDMA, 2);
        DMA_set_LLI_entry(&g_OutputDMA, 0, LLI_NEXT_ENTRY, m_OutputDMABufferPhyPage[0],
                            AC97_get_pcmout_physical_buffer_address(), AUDIO_DMA_PAGE_SIZE);
        DMA_set_LLI_entry(&g_OutputDMA, 1, LLI_FIRST_ENTRY, m_OutputDMABufferPhyPage[1],
                            AC97_get_pcmout_physical_buffer_address(), AUDIO_DMA_PAGE_SIZE);
        DMA_set_initial_LLI(&g_OutputDMA, 1);
    }

CleanUp:

    WAV_MSG((_T("[WAV] --InitOutputDMA()\n\r")));

    return bRet;
}


BOOL HardwareContext::InitInputDMA()
{
    BOOL bRet = TRUE;

    WAV_MSG((_T("[WAV] ++InitInputDMA()\n\r")));

    if (!g_PhyDMABufferAddr.LowPart)
    {
        WAV_ERR((_T("[WAV:ERR] InitInputDMA() : DMA Buffer is Not Allocated Yet\n\r")));
        bRet = FALSE;
        goto CleanUp;
    }

    bRet = DMA_request_channel(&g_InputDMA, DMA_AC97_PCMIN);
    if (bRet)
    {
        DMA_initialize_channel(&g_InputDMA, TRUE);
        DMA_set_channel_source(&g_InputDMA, AC97_get_pcmin_physical_buffer_address(), WORD_UNIT, BURST_1, FIXED);
        DMA_set_channel_destination(&g_InputDMA, m_InputDMABufferPhyPage[0], WORD_UNIT, BURST_1, INCREASE);
        DMA_set_channel_transfer_size(&g_InputDMA, AUDIO_DMA_PAGE_SIZE);