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 IIS Interface SFR
    ioPhysicalBase.LowPart = S3C6410_BASE_REG_PA_I2S_40;      
    g_pIISReg = (S3C6410_IIS_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_IIS_REG), FALSE);
    if (g_pIISReg == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] MapRegisters() : g_pIISReg 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_pIISReg != NULL)
    {
        MmUnmapIoSpace((PVOID)g_pIISReg, sizeof(S3C6410_IIS_REG));
        g_pIISReg = 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;
}


BOOL
HardwareContext::InitIISCodec()
{
    DWORD   dwErr = TRUE;
    DWORD   bytes = 0;

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

    if ( m_hI2C == INVALID_HANDLE_VALUE )
    {
        dwErr = GetLastError();
        WAV_ERR((_T("[WAV:ERR] InitIISCodec() : m_hI2C is INVALID_HANDLE_VALUE\n\r")));
        return FALSE;
    }

    I2S_Init8580Driver();

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

    return dwErr;
}


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_I2S_V40_TX);
    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, IIS_get_output_physical_buffer_address(IIS_CH_2), 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],
                            IIS_get_output_physical_buffer_address(IIS_CH_2), AUDIO_DMA_PAGE_SIZE);
        DMA_set_LLI_entry(&g_OutputDMA, 1, LLI_FIRST_ENTRY, m_OutputDMABufferPhyPage[1],
                            IIS_get_output_physical_buffer_address(IIS_CH_2), 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_I2S_V40_RX);
    if (bRet)
    {
        DMA_initialize_channel(&g_InputDMA, TRUE);
        DMA_set_channel_source(&g_InputDMA, IIS_get_input_physical_buffer_address(IIS_CH_2), 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);
        DMA_initialize_LLI(&g_InputDMA, 2);
        DMA_set_initial_LLI(&g_InputDMA, 1);
        DMA_set_LLI_entry(&g_InputDMA, 0, LLI_NEXT_ENTRY, IIS_get_input_physical_buffer_address(IIS_CH_2),
                            m_InputDMABufferPhyPage[0], AUDIO_DMA_PAGE_SIZE);
        DMA_set_LLI_entry(&g_InputDMA, 1, LLI_FIRST_ENTRY, IIS_get_input_physical_buffer_address(IIS_CH_2),
                            m_InputDMABufferPhyPage[1], AUDIO_DMA_PAGE_SIZE);
    }

CleanUp:

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

    return bRet;
}


BOOL
HardwareContext::InitInterruptThread()
{
    DWORD Irq;
    DWORD dwPriority;

    Irq = g_OutputDMA.dwIRQ;
    if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &Irq, sizeof(DWORD), &m_dwSysintrOutput, sizeof(DWORD), NULL))
    {
        WAV_ERR((_T("[WAV:ERR] InitInterruptThread() : Output DMA IOCTL_HAL_REQUEST_SYSINTR Failed \n\r")));
        return FALSE;
    }

    Irq = g_InputDMA.dwIRQ;
    if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &Irq, sizeof(DWORD), &m_dwSysintrInput, sizeof(DWORD), NULL))
    {
        WAV_ERR((_T("[WAV:ERR] InitInterruptThread() : Input DMA IOCTL_HAL_REQUEST_SYSINTR Failed \n\r")));
        return FALSE;
    }

    m_hOutputDMAInterrupt = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (m_hOutputDMAInterrupt == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] InitInterruptThread() : Output DMA CreateEvent() Failed \n\r")));
        return(FALSE);
    }

    m_hInputDMAInterrupt = CreateEvent(NULL, FALSE, FALSE, NULL);
    if (m_hInputDMAInterrupt == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] InitInterruptThread() : Input DMA CreateEvent() Failed \n\r")));
        return(FALSE);
    }

    if (!InterruptInitialize(m_dwSysintrOutput, m_hOutputDMAInterrupt, NULL, 0))
    {
        WAV_ERR((_T("[WAV:ERR] InitInterruptThread() : Output DMA InterruptInitialize() Failed \n\r")));
        return FALSE;
    }

    if (! InterruptInitialize(m_dwSysintrInput, m_hInputDMAInterrupt, NULL, 0))
    {
        WAV_ERR((_T("[WAV:ERR] InitInterruptThread() : Input DMA InterruptInitialize() Failed \n\r")));
        return FALSE;
    }


    m_hOutputDMAInterruptThread = CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0,
                            (LPTHREAD_START_ROUTINE)CallInterruptThreadOutputDMA, this, 0, NULL);

    if (m_hOutputDMAInterruptThread == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] InitInterruptThread() : Output DMA CreateThread() Failed \n\r")));
        return FALSE;
    }

    m_hInputDMAInterruptThread = CreateThread((LPSECURITY_ATTRIBUTES)NULL, 0,
                            (LPTHREAD_START_ROUTINE)CallInterruptThreadInputDMA, this, 0, NULL);

    if (m_hInputDMAInterruptThread == NULL)
    {
        WAV_ERR((_T("[WAV:ERR] InitInterruptThread() : Input DMA CreateThread() Failed \n\r")));
        return FALSE;
    }

    dwPriority = GetInterruptThreadPriority();

    // Bump up the priority since the interrupt must be serviced immediately.
    CeSetThreadPriority(m_hOutputDMAInterruptThread, dwPriority);
    CeSetThreadPriority(m_hInputDMAInterruptThread, dwPriority);
    WAV_INF((_T("[WAV:INF] InitInterruptThread() : IST Priority = %d\n\r"), dwPriority));

    return(TRUE);
}


BOOL
HardwareContext::DeinitInterruptThread()
{
    return TRUE;
}


DWORD
HardwareContext::GetInterruptThreadPriority()
{
    HKEY hDevKey;
    DWORD dwValType;
    DWORD dwValLen;
    DWORD dwPrio = INTERRUPT_THREAD_PRIORITY_DEFAULT;
    LONG lResult;

    hDevKey = OpenDeviceKey((LPWSTR)m_DriverIndex);
    if (INVALID_HANDLE_VALUE != hDevKey)
    {
        dwValLen = sizeof(DWORD);
        lResult = RegQueryValueEx(hDevKey, TEXT("Priority256"), NULL, &dwValType, (PUCHAR)&dwPrio, &dwValLen);
        RegCloseKey(hDevKey);
    }
    else
    {
        WAV_ERR((_T("[WAV:ERR] GetInterruptThreadPriority() : OpenDeviceKey() Failed\n\r")));
    }

    return dwPrio;
}


ULONG
HardwareContext::TransferOutputBuffer(DWORD dwStatus)
{
    ULONG BytesTransferred = 0;
    ULONG BytesTotal = 0;

    dwStatus &= (DMA_DONEA|DMA_DONEB|DMA_BIU);

    WAV_MSG((_T("[WAV] TransferOutputBuffer(0x%08x)\n\r"), dwStatus));

    switch (dwStatus)
    {
    case 0:
    case DMA_BIU: