wavepdd.cpp

此代码为WCE5.0下声卡的源代码

        case WPDMX_MIC_MUTE:
            *pdwSetting = g_VolumeSettings.fMicMute;
            break;
        case WPDMX_INPUT_MUX:
            *pdwSetting = g_VolumeSettings.dwInputSelect;
            break;
        default:
            DEBUGMSG(1, (TEXT("private_GetMixerValue: unrecognized control %d"), dwControl));
            return MMSYSERR_NOTSUPPORTED;
    }
    DEBUGMSG(ZONE_VOLUME, (TEXT("private_GetMixerValue(%04x, %08x)\r\n"), dwControl, *pdwSetting));

    return MMSYSERR_NOERROR;
}



// -----------------------------------------------------------------------------
//                          PDD_AudioPowerHandler
// -----------------------------------------------------------------------------
VOID
PDD_AudioPowerHandler(
    BOOL power_down
   )
{
    //
    // Handle any power up/down issues here. 
    //
}


// -----------------------------------------------------------------------------
//                       PDD_AudioGetInterruptType
// -----------------------------------------------------------------------------
AUDIO_STATE 
PDD_AudioGetInterruptType( VOID )
{

    AUDIO_STATE result = AUDIO_STATE_IGNORE;

    UCHAR intsrc = pCES1371->GetInterruptSource();

    //
    // Which interrupt is the source?
    //
    if ( intsrc & ES1371_INT_DAC0 )
    { 
        //
        // ACK the ISR.
        //
        pCES1371->AckDMAInterrupt( ES1371_INT_DAC0 );
        result |= AUDIO_STATE_OUT_PLAYING;
    }

    if ( intsrc & ES1371_INT_ADC )
    { 
        //
        // ACK the ISR.
        //
        pCES1371->AckDMAInterrupt( ES1371_INT_ADC );
        result |= AUDIO_STATE_IN_RECORDING;
    }
    if (intsrc & ES1371_INT_PM)
    {
        //
        // ACK the ISR.
        //
        pCES1371->AckDMAInterrupt( intsrc );
        DEBUGMSG(ZONE_ERROR, (TEXT("ES1371: power interrupt ocurred ")));
    }

    //
    // Don't indicate any state change on this interrupt...
    //
    return result;
}


// -----------------------------------------------------------------------------
//                              PDD_AudioInitialize
// -----------------------------------------------------------------------------
BOOL 
PDD_AudioInitialize(
    DWORD dwIndex   
   )
{
    DWORD dwRet;
    ULONG ulSysIntr;
    ULONG ulIoBase;
    ULONG ulIoLen;
    ULONG ulDeviceID;
    ULONG ulRevisionID;
    BOOL InstallIsr = FALSE;
    WCHAR IsrDll[DEVDLL_LEN];
    WCHAR IsrHandler[DEVENTRY_LEN];
    DWORD Irq = -1;


    FUNC_WPDD("PDD_AudioInitialize");

    g_dwBusNumber = 0;
    g_IfcType = PCIBus;
    if ((dwRet = GetRegistryConfig((LPWSTR)dwIndex, &ulSysIntr, &ulIoBase, &ulIoLen, &ulDeviceID, &ulRevisionID, &InstallIsr, IsrDll, IsrHandler, &Irq, &g_dwBusNumber, &g_IfcType))
        != ERROR_SUCCESS) {
        DEBUGMSG(ZONE_ERROR,
            (TEXT("WAVEDEV.DLL : GetRegistryConfig failed %d\r\n"),
            dwRet));
        return FALSE;
    }

    //
    // Create an ES1371 object to control the hardware 
    //
    if (pCES1371 == NULL) {
        pCES1371 = new CES1371();
        if (pCES1371 == NULL) {
            DEBUGMSG(ZONE_ERROR, (TEXT("Unable to allocate CES1371 object")));
            return FALSE;
        }

        // Install ISR handler if there is one
        if (InstallIsr) {
            // Install ISR handler
            g_IsrHandle = LoadIntChainHandler(IsrDll, IsrHandler, (BYTE)Irq);

            if (!g_IsrHandle) {
                DEBUGMSG(ZONE_ERROR, (L"WAVEDEV: Couldn't install ISR handler\r\n"));
            } else {
                GIISR_INFO Info;
                PVOID PhysAddr;
                DWORD inIoSpace = 1;    // io space
                PHYSICAL_ADDRESS PortAddress = {ulIoBase, 0}; 
                
                if (!TransBusAddrToStatic(g_IfcType, g_dwBusNumber, PortAddress, ulIoLen, &inIoSpace, &PhysAddr)) {
                    DEBUGMSG(ZONE_ERROR, (L"WAVEDEV: Failed TransBusAddrToStatic\r\n"));
                    return FALSE;
                }
                
                DEBUGMSG(ZONE_PDD, (L"WAVEDEV: Installed ISR handler, Dll = '%s', Handler = '%s', Irq = %d, PhysAddr = 0x%x\r\n",
                    IsrDll, IsrHandler, Irq, PhysAddr));
                
                // Set up ISR handler
                Info.SysIntr = ulSysIntr;
                Info.CheckPort = TRUE;
                Info.PortIsIO = TRUE;
                Info.UseMaskReg = FALSE;
                Info.PortAddr = (DWORD)PhysAddr + ES1371_dSTATUS_OFF;
                Info.PortSize = sizeof(DWORD);
                Info.Mask = ES1371_INTSTAT_PENDING;
                
                if (!KernelLibIoControl(g_IsrHandle, IOCTL_GIISR_INFO, &Info, sizeof(Info), NULL, 0, NULL)) {
                    DEBUGMSG(ZONE_ERROR, (L"WAVEDEV: KernelLibIoControl call failed.\r\n"));
                }
            }
        }
        
        // first thing: see if the device is really there
        if (!pCES1371->MapHardware(ulSysIntr, ulIoBase, ulIoLen, ulDeviceID, ulRevisionID)) {
            DEBUGMSG(1, (TEXT("PDD_AudioInitialize: failed to map hardware \r\n")));
            delete pCES1371;
            pCES1371 = NULL;
            return FALSE;
        }
    }
    pCES1371->AddRef();

    // Set the global master volume to max 
	private_waveOutSetVolume(0xffffffff);

    // set default for input
    private_SetMixerValue(WPDMX_MIC_VOL,     0xAAAAAAAA);
    private_SetMixerValue(WPDMX_MIC_MUTE,    0);
    private_SetMixerValue(WPDMX_LINEIN_VOL,  0xAAAAAAAA);
    private_SetMixerValue(WPDMX_LINEIN_MUTE, 0);
    private_SetMixerValue(WPDMX_INPUT_MUX, WPDMX_LINE_MIC);

    //
    // Alocate DMA buffers 
    //

    DMA_ADAPTER_OBJECT AdapterObject;

    AdapterObject.ObjectSize = sizeof(AdapterObject);
    AdapterObject.InterfaceType = g_IfcType;
    AdapterObject.BusNumber = g_dwBusNumber;

    //
    // Allocate a single paged 4k Ouput buffer
    //
    g_dma_buffer[WAPI_OUT] = (PUCHAR) HalAllocateCommonBuffer(&AdapterObject, dma_buffer_size, &g_dma_logical_address[WAPI_OUT], FALSE);
    g_dma_buffer[WAPI_IN]  = (PUCHAR) HalAllocateCommonBuffer(&AdapterObject, dma_buffer_size, &g_dma_logical_address[WAPI_IN],  FALSE);
    if (g_dma_buffer[WAPI_IN] == NULL || g_dma_buffer[WAPI_OUT] == NULL)  {
		ERRMSG("DMA Buffer Page Allocation Failed");
		return FALSE;
    }

	g_dmachannel[WAPI_IN] = ES1371_ADC;
	g_dmachannel[WAPI_OUT] = ES1371_DAC0;

	g_pfnDmaTransfer[WAPI_IN] = private_AudioGetBuffer;
	g_pfnDmaTransfer[WAPI_OUT] = private_AudioCompleteAndFill;

    //
    // Allocate a single paged 4k Input buffer
    //
    //
    // Initialize the DMA channels with the allocated buffer addresses
    // 
    pCES1371->InitDMAChannel( ES1371_DAC0, g_dma_logical_address[WAPI_OUT].LowPart, dma_buffer_size);
    pCES1371->InitDMAChannel( ES1371_ADC,  g_dma_logical_address[WAPI_IN].LowPart,  dma_buffer_size);


    return TRUE;
}


// -----------------------------------------------------------------------------
//                              PDD_AudioMessage
// -----------------------------------------------------------------------------
DWORD
PDD_AudioMessage(
    UINT uMsg,
    DWORD dwParam1,
    DWORD dwParam2
    )
{
    //
    // Handle any custom WAVEIN or WAVEOUT messages here
    //
    return MMSYSERR_NOTSUPPORTED;
}


// -----------------------------------------------------------------------------
//                          PDD_AudioDeinitialize
// -----------------------------------------------------------------------------
VOID 
PDD_AudioDeinitialize(
    VOID
    )
{
    DMA_ADAPTER_OBJECT AdapterObject;
    //
    // The driver is being unloaded. Deinitialize. Free up memory, etc.
    //

    if ( pCES1371 != NULL ) {
        if (0 == pCES1371->Release()) {
            pCES1371 = NULL;
        }
    }

    if (g_IsrHandle) {
        FreeIntChainHandler(g_IsrHandle);
        g_IsrHandle = NULL;
    }

    AdapterObject.ObjectSize = sizeof(AdapterObject);
    AdapterObject.InterfaceType = g_IfcType;
    AdapterObject.BusNumber = g_dwBusNumber;
    HalFreeCommonBuffer(&AdapterObject, dma_buffer_size, g_dma_logical_address[WAPI_OUT], g_dma_buffer[WAPI_OUT], FALSE);
    HalFreeCommonBuffer(&AdapterObject, dma_buffer_size, g_dma_logical_address[WAPI_IN], g_dma_buffer[WAPI_IN], FALSE);
}


// -----------------------------------------------------------------------------
//                              PDD_WaveProc
// -----------------------------------------------------------------------------
MMRESULT
PDD_WaveProc(
    WAPI_INOUT apidir,
    DWORD      dwCode,
    DWORD      dwParam1,
    DWORD      dwParam2
    )
{
    MMRESULT mmRet = MMSYSERR_NOERROR;

    if ((apidir != WAPI_IN) && (apidir != WAPI_OUT)) {
        // guard against the remote possibility that the MDD might passin a bogus apidir
        return MMSYSERR_ERROR;
    }

    switch (dwCode) {
        case WPDM_CLOSE:
			if (apidir == WAPI_IN) {
				private_WaveStop(apidir); // capture DMA must be shut down before closing
			}
            g_fInUse[apidir] = FALSE;
            break;

        case WPDM_CONTINUE:
            private_WaveContinue(apidir, (PWAVEHDR) dwParam1);
            break;

        case WPDM_GETDEVCAPS:
            mmRet = private_WaveGetDevCaps(apidir, (PVOID) dwParam1, (UINT) dwParam2);
            break;

        case WPDM_OPEN:
            mmRet = private_WaveOpen(apidir, (LPWAVEFORMATEX) dwParam1, (BOOL) dwParam2);
            break;

        case WPDM_STANDBY:
            private_WaveStandby (apidir);
            break;

        case WPDM_RESTART:
        case WPDM_START:
            private_WaveStart(apidir, (PWAVEHDR) dwParam1);
            break;

        case WPDM_ENDOFDATA:
        case WPDM_PAUSE:
        case WPDM_STOP:
            private_WaveStop(apidir);
            break;

        case WPDM_GETVOLUME:
            private_waveOutGetVolume((PULONG) dwParam1);
            break;

        case WPDM_SETVOLUME:
            private_waveOutSetVolume(dwParam1);
            break;

        case WPDM_SETMIXERVAL:
            mmRet = private_SetMixerValue(dwParam1, dwParam2);
            break;

        case WPDM_GETMIXERVAL:
            mmRet = private_GetMixerValue(dwParam1, (PULONG) dwParam2);
            break;



        default :
            mmRet = MMSYSERR_NOTSUPPORTED;
            break;
    }

    return mmRet;
}