CMiniport Class Reference

#include <miniport.h>

Inheritance diagram for CMiniport:

Collaboration diagram for CMiniport:

Public Member Functions
NTSTATUS	ProcessResources (IN PRESOURCELIST ResourceList)
NTSTATUS	TestDataFormat (IN PKSDATAFORMAT Format, IN WavePins Pin)
NTSTATUS	ValidateFormat (IN PKSDATAFORMAT DataFormat, IN WavePins Pin)
NTSTATUS	BuildDataRangeInformation (void)
	~CMiniport ()
	STDMETHODIMP_ (NTSTATUS) Init(_In_ PUNKNOWN UnknownAdapter
NTSTATUS	NonDelegatingQueryInterface (_In_ REFIID Interface, _COM_Outptr_ PVOID *Object, _In_ REFIID iMiniPort, _In_ PMINIPORT miniPort)

Static Public Member Functions
static NTSTATUS NTAPI	InterruptServiceRoutine (IN PINTERRUPTSYNC InterruptSync, IN PVOID StaticContext)
static NTSTATUS NTAPI	PropertyChannelConfig (IN PPCPROPERTY_REQUEST PropertyRequest)

Public Attributes
CMiniportStream *	Streams [PIN_MICIN_OFFSET+1]
PPORT_	Port
PADAPTERCOMMON	AdapterCommon
PINTERRUPTSYNC	InterruptSync
PDMACHANNEL	DmaChannel
DEVICE_POWER_STATE	m_PowerState
DWORD	m_dwChannelMask
WORD	m_wChannels
	IMP_IMiniport
	IMP_IPowerNotify
_In_ PRESOURCELIST	ResourceList
_In_ PRESOURCELIST _In_ PPORT	Port_

Detailed Description

Definition at line 26 of file miniport.h.

Constructor & Destructor Documentation

~CMiniport()

CMiniport::~CMiniport

(

)

Definition at line 1287 of file miniport.cpp.

{
    PAGED_CODE ();
 
    DOUT (DBG_PRINT, ("[CMiniport::~CMiniport]"));
 
    obj_Release((PVOID *)&DmaChannel);
    obj_Release((PVOID *)&InterruptSync);
    obj_Release((PVOID *)&AdapterCommon);
    obj_Release((PVOID *)&Port);
}

Member Function Documentation

BuildDataRangeInformation()

NTSTATUS CMiniport::BuildDataRangeInformation

(

void

)

Definition at line 401 of file miniport.cpp.

{
    PAGED_CODE ();
 
    NTSTATUS    ntStatus;
    int nWavePlaybackEntries = 0;
    int nWaveRecordingEntries = 0;
    int nMicEntries = 0;
    int nChannels;
    int nLoop;
 
    DOUT (DBG_PRINT, ("[CMiniport::BuildDataRangeInformation]"));
 
    //
    // Calculate the number of max. channels available in the codec.
    //
    if (AdapterCommon->GetPinConfig (PINC_SURROUND_PRESENT))
    {
        if (AdapterCommon->GetPinConfig (PINC_CENTER_LFE_PRESENT))
        {
            nChannels = 6;
        }
        else
        {
            nChannels = 4;
        }
    }
    else
    {
        nChannels = 2;
    }
 
    // Check for the render sample rates.
    for (nLoop = 0; nLoop < WAVE_SAMPLERATES_TESTED; nLoop++)
    {
        ntStatus = AdapterCommon->ProgramSampleRate (AC97REG_FRONT_SAMPLERATE,
                                                     dwWaveSampleRates[nLoop]);
 
        // We support the sample rate?
        if (NT_SUCCESS (ntStatus))
        {
            // Add it to the PinDataRange
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].DataRange.FormatSize = sizeof(KSDATARANGE_AUDIO);
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].DataRange.Flags      = 0;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].DataRange.SampleSize = nChannels * 2;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].DataRange.Reserved   = 0;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].DataRange.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].DataRange.SubFormat   = KSDATAFORMAT_SUBTYPE_PCM;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].DataRange.Specifier   = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].MaximumChannels = nChannels;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].MinimumBitsPerSample = 16;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].MaximumBitsPerSample = 16;
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].MinimumSampleFrequency = dwWaveSampleRates[nLoop];
            PinDataRangesPCMStreamRender[nWavePlaybackEntries].MaximumSampleFrequency = dwWaveSampleRates[nLoop];
 
            // Add it to the PinDataRangePointer
            PinDataRangePointersPCMStreamRender[nWavePlaybackEntries] = (PKSDATARANGE)&PinDataRangesPCMStreamRender[nWavePlaybackEntries];
 
            // Increase count
            nWavePlaybackEntries++;
        }
    }
 
    // Check for the capture sample rates.
    for (nLoop = 0; nLoop < WAVE_SAMPLERATES_TESTED; nLoop++)
    {
        ntStatus = AdapterCommon->ProgramSampleRate (AC97REG_RECORD_SAMPLERATE, dwWaveSampleRates[nLoop]);
 
        // We support the sample rate?
        if (NT_SUCCESS (ntStatus))
        {
            // Add it to the PinDataRange
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].DataRange.FormatSize = sizeof(KSDATARANGE_AUDIO);
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].DataRange.Flags      = 0;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].DataRange.SampleSize = 4;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].DataRange.Reserved   = 0;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].DataRange.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].DataRange.SubFormat   = KSDATAFORMAT_SUBTYPE_PCM;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].DataRange.Specifier   = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].MaximumChannels = 2;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].MinimumBitsPerSample = 16;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].MaximumBitsPerSample = 16;
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].MinimumSampleFrequency = dwWaveSampleRates[nLoop];
            PinDataRangesPCMStreamCapture[nWaveRecordingEntries].MaximumSampleFrequency = dwWaveSampleRates[nLoop];
 
            // Add it to the PinDataRangePointer
            PinDataRangePointersPCMStreamCapture[nWaveRecordingEntries] = (PKSDATARANGE)&PinDataRangesPCMStreamCapture[nWaveRecordingEntries];
 
            // Increase count
            nWaveRecordingEntries++;
        }
    }
 
    // Check for the MIC sample rates.
    for (nLoop = 0; nLoop < int(MIC_SAMPLERATES_TESTED); nLoop++)
    {
        ntStatus = AdapterCommon->ProgramSampleRate (AC97REG_MIC_SAMPLERATE, dwMicSampleRates[nLoop]);
 
        // We support the sample rate?
        if (NT_SUCCESS (ntStatus))
        {
            // Add it to the PinDataRange
            PinDataRangesMicStream[nMicEntries].DataRange.FormatSize = sizeof(KSDATARANGE_AUDIO);
            PinDataRangesMicStream[nMicEntries].DataRange.Flags      = 0;
            PinDataRangesMicStream[nMicEntries].DataRange.SampleSize = 2;
            PinDataRangesMicStream[nMicEntries].DataRange.Reserved   = 0;
            PinDataRangesMicStream[nMicEntries].DataRange.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
            PinDataRangesMicStream[nMicEntries].DataRange.SubFormat   = KSDATAFORMAT_SUBTYPE_PCM;
            PinDataRangesMicStream[nMicEntries].DataRange.Specifier   = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
            PinDataRangesMicStream[nMicEntries].MaximumChannels = 1;
            PinDataRangesMicStream[nMicEntries].MinimumBitsPerSample = 16;
            PinDataRangesMicStream[nMicEntries].MaximumBitsPerSample = 16;
            PinDataRangesMicStream[nMicEntries].MinimumSampleFrequency = dwMicSampleRates[nLoop];
            PinDataRangesMicStream[nMicEntries].MaximumSampleFrequency = dwMicSampleRates[nLoop];
 
            // Add it to the PinDataRangePointer
            PinDataRangePointersMicStream[nMicEntries] = (PKSDATARANGE)&PinDataRangesMicStream[nMicEntries];
 
            // Increase count
            nMicEntries++;
        }
    }
 
    // Now go through the pin descriptor list and change the data range entries to the actual number.
    for (nLoop = 0; nLoop < int(SIZEOF_ARRAY(MiniportPins)); nLoop++)
    {
        if (MiniportPins[nLoop].KsPinDescriptor.DataRanges == PinDataRangePointersPCMStreamRender)
            MiniportPins[nLoop].KsPinDescriptor.DataRangesCount = nWavePlaybackEntries;
        if (MiniportPins[nLoop].KsPinDescriptor.DataRanges == PinDataRangePointersPCMStreamCapture)
            MiniportPins[nLoop].KsPinDescriptor.DataRangesCount = nWaveRecordingEntries;
        if (MiniportPins[nLoop].KsPinDescriptor.DataRanges == PinDataRangePointersMicStream)
            MiniportPins[nLoop].KsPinDescriptor.DataRangesCount = nMicEntries;
    }
 
    return STATUS_SUCCESS;
}

InterruptServiceRoutine()

NTSTATUS CMiniport::InterruptServiceRoutine ( IN PINTERRUPTSYNC  InterruptSync, IN PVOID  StaticContext  )

static

Definition at line 1314 of file miniport.cpp.

{
    UNREFERENCED_PARAMETER(InterruptSync);
 
    ASSERT (InterruptSync);
    ASSERT (DynamicContext);
 
    ULONG   GlobalStatus;
    USHORT  DMAStatusRegister;
 
    //
    // Get our context which is a pointer to class CAC97MiniportWaveRT.
    //
    CMiniport *that = (CMiniport *)DynamicContext;
 
    //
    // Check for a valid AdapterCommon pointer.
    //
    if (!that->AdapterCommon)
    {
        //
        // In case we didn't handle the interrupt, unsuccessful tells the system
        // to call the next interrupt handler in the chain.
        //
        return STATUS_UNSUCCESSFUL;
    }
 
    //
    // From this point down, basically in the complete ISR, we cannot use
    // relative addresses (stream class base address + X_CR for example)
    // cause we might get called when the stream class is destroyed or
    // not existent. This doesn't make too much sense (that there is an
    // interrupt for a non-existing stream) but could happen and we have
    // to deal with the interrupt.
    //
 
    //
    // Read the global register to check the interrupt bits
    //
    GlobalStatus = that->AdapterCommon->ReadBMControlRegister32 (GLOB_STA);
 
    //
    // Check for weird return values. Could happen if the PCI device is already
    // disabled and another device that shares this interrupt generated an
    // interrupt.
    // The register should never have all bits cleared or set.
    //
    if (!GlobalStatus || (GlobalStatus == 0xFFFFFFFF))
    {
        return STATUS_UNSUCCESSFUL;
    }
 
    //
    // Check for PCM out interrupt.
    //
    NTSTATUS ntStatus = STATUS_UNSUCCESSFUL;
    if (GlobalStatus & GLOB_STA_POINT)
    {
        //
        // Read PCM out DMA status registers.
        //
        DMAStatusRegister = (USHORT)that->AdapterCommon->
            ReadBMControlRegister16 (PO_SR);
 
 
        //
        // We could now check for every possible error condition
        // (like FIFO error) and monitor the different errors, but currently
        // we have the same action for every INT and therefore we simplify
        // this routine enormous with just clearing the bits.
        //
        if (that->Streams[PIN_WAVEOUT_OFFSET])
        {
            //
            // ACK the interrupt.
            //
            that->AdapterCommon->WriteBMControlRegister (PO_SR, DMAStatusRegister);
            ntStatus = STATUS_SUCCESS;
 
            //
 
            that->Streams[PIN_WAVEOUT_OFFSET]->InterruptServiceRoutine();
        }
    }
 
    //
    // Check for PCM in interrupt.
    //
    if (GlobalStatus & GLOB_STA_PIINT)
    {
        //
        // Read PCM in DMA status registers.
        //
        DMAStatusRegister = (USHORT)that->AdapterCommon->
            ReadBMControlRegister16 (PI_SR);
 
        //
        // We could now check for every possible error condition
        // (like FIFO error) and monitor the different errors, but currently
        // we have the same action for every INT and therefore we simplify
        // this routine enormous with just clearing the bits.
        //
        if (that->Streams[PIN_WAVEIN_OFFSET])
        {
            //
            // ACK the interrupt.
            //
            that->AdapterCommon->WriteBMControlRegister (PI_SR, DMAStatusRegister);
            ntStatus = STATUS_SUCCESS;
 
            that->Streams[PIN_WAVEIN_OFFSET]->InterruptServiceRoutine();
        }
    }
 
    //
    // Check for MIC in interrupt.
    //
    if (GlobalStatus & GLOB_STA_MINT)
    {
        //
        // Read MIC in DMA status registers.
        //
        DMAStatusRegister = (USHORT)that->AdapterCommon->
            ReadBMControlRegister16 (MC_SR);
 
        //
        // We could now check for every possible error condition
        // (like FIFO error) and monitor the different errors, but currently
        // we have the same action for every INT and therefore we simplify
        // this routine enormous with just clearing the bits.
        //
        if (that->Streams[PIN_MICIN_OFFSET])
        {
            //
            // ACK the interrupt.
            //
            that->AdapterCommon->WriteBMControlRegister (MC_SR, DMAStatusRegister);
            ntStatus = STATUS_SUCCESS;
 
            that->Streams[PIN_MICIN_OFFSET]->InterruptServiceRoutine();
        }
    }
 
    return ntStatus;
}

Referenced by ProcessResources().

NonDelegatingQueryInterface()

NTSTATUS CMiniport::NonDelegatingQueryInterface	(	_In_ REFIID	Interface,
		_COM_Outptr_ PVOID *	Object,
		_In_ REFIID	iMiniPort,
		_In_ PMINIPORT	miniPort
	)

Definition at line 1143 of file miniport.cpp.

{
    PAGED_CODE ();
 
    ASSERT (Object);
 
    DOUT (DBG_PRINT, ("[CMiniport::NonDelegatingQueryInterface]"));
 
    // Is it IID_IUnknown?
    if (IsEqualGUIDAligned (Interface, IID_IUnknown))
    {
        *Object = (PVOID)miniPort;
    }
    // or IID_IMiniport ...
    else if (IsEqualGUIDAligned (Interface, IID_IMiniport))
    {
        *Object = (PVOID)miniPort;
    }
    // or IID_IMiniportWavePci ...
    else if (IsEqualGUIDAligned (Interface, iMiniPort))
    {
        *Object = (PVOID)miniPort;
    }
    // or IID_IPowerNotify ...
    else if (IsEqualGUIDAligned (Interface, IID_IPowerNotify))
    {
        *Object = (PVOID)(PPOWERNOTIFY)this;
    }
    else
    {
        // nothing found, must be an unknown interface.
        *Object = NULL;
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // We reference the interface for the caller.
    //
    ((PUNKNOWN)(*Object))->AddRef();
    return STATUS_SUCCESS;
}

ProcessResources()

NTSTATUS CMiniport::ProcessResources

(

IN PRESOURCELIST

ResourceList

)

Definition at line 1074 of file miniport.cpp.

{
    PAGED_CODE ();
 
    ASSERT (ResourceList);
 
 
    DOUT (DBG_PRINT, ("[CMiniport::ProcessResources]"));
 
 
    ULONG countIRQ = ResourceList->NumberOfInterrupts ();
    if (countIRQ < 1)
    {
        DOUT (DBG_ERROR, ("Unknown configuration for wave miniport!"));
        return STATUS_DEVICE_CONFIGURATION_ERROR;
    }
 
    //
    // Create an interrupt sync object
    //
    NTSTATUS ntStatus = STATUS_SUCCESS;
    ntStatus = PcNewInterruptSync (&InterruptSync,
                                   NULL,
                                   ResourceList,
                                   0,
                                   InterruptSyncModeNormal);
 
    if (!NT_SUCCESS (ntStatus) || !InterruptSync)
    {
        DOUT (DBG_ERROR, ("Failed to create an interrupt sync!"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }
 
    //
    // Register our ISR.
    //
    ntStatus = InterruptSync->RegisterServiceRoutine (InterruptServiceRoutine,
                                                      (PVOID)this, FALSE);
    if (!NT_SUCCESS (ntStatus))
    {
        DOUT (DBG_ERROR, ("Failed to register ISR!"));
        return ntStatus;
    }
 
    //
    // Connect the interrupt.
    //
    ntStatus = InterruptSync->Connect ();
    if (!NT_SUCCESS (ntStatus))
    {
        DOUT (DBG_ERROR, ("Failed to connect the ISR with InterruptSync!"));
        return ntStatus;
    }
 
    //
    // On failure object is destroyed which cleans up.
    //
    return STATUS_SUCCESS;
}

PropertyChannelConfig()

NTSTATUS CMiniport::PropertyChannelConfig ( IN PPCPROPERTY_REQUEST  PropertyRequest )

static

Definition at line 313 of file miniport.cpp.

{
    PAGED_CODE ();
 
    ASSERT (PropertyRequest);
 
    DOUT (DBG_PRINT, ("[CMiniport::PropertyChannelConfig]"));
 
    NTSTATUS        ntStatus = STATUS_INVALID_PARAMETER;
    
    // The major target is the object pointer to the wave miniport.
    // HACK ALERT - unsafe pointer cast - HACK ALERT
    CMiniport *that = (CMiniport *)(CMiniportWaveICH*)
        (PMINIPORTWAVEPCI)PropertyRequest->MajorTarget;
 
    ASSERT (that);
 
    // We only have a set defined.
    if (PropertyRequest->Verb & KSPROPERTY_TYPE_SET)
    {
        // validate buffer size.
        if (PropertyRequest->ValueSize < sizeof(LONG))
            return ntStatus;
 
        // The "Value" is the input buffer with the channel config.
        if (PropertyRequest->Value)
        {
            // We can accept different channel configurations, depending
            // on the number of channels we can play.
            if (that->AdapterCommon->GetPinConfig (PINC_SURROUND_PRESENT))
            {
                if (that->AdapterCommon->GetPinConfig (PINC_CENTER_LFE_PRESENT))
                {
                    // we accept 5.1
                    if (*(PLONG)PropertyRequest->Value == KSAUDIO_SPEAKER_5POINT1)
                    {
                        that->m_dwChannelMask =  *(PLONG)PropertyRequest->Value;
                        that->m_wChannels = 6;
                        that->AdapterCommon->WriteChannelConfigDefault (that->m_dwChannelMask);
                        ntStatus = STATUS_SUCCESS;
                    }
                }
 
                // accept also surround or quad.
                if ((*(PLONG)PropertyRequest->Value == KSAUDIO_SPEAKER_QUAD) ||
                    (*(PLONG)PropertyRequest->Value == KSAUDIO_SPEAKER_SURROUND))
                {
                    that->m_dwChannelMask =  *(PLONG)PropertyRequest->Value;
                    that->m_wChannels = 4;
                    that->AdapterCommon->WriteChannelConfigDefault (that->m_dwChannelMask);
                    ntStatus = STATUS_SUCCESS;
                }
            }
 
            // accept also stereo speakers.
            if (*(PLONG)PropertyRequest->Value == KSAUDIO_SPEAKER_STEREO)
            {
                that->m_dwChannelMask =  *(PLONG)PropertyRequest->Value;
                that->m_wChannels = 2;
                that->AdapterCommon->WriteChannelConfigDefault (that->m_dwChannelMask);
                ntStatus = STATUS_SUCCESS;
            }
        }
    }
 
    return ntStatus;
}

STDMETHODIMP_()

CMiniport::STDMETHODIMP_

(

NTSTATUS

)

TestDataFormat()

NTSTATUS CMiniport::TestDataFormat	(	IN PKSDATAFORMAT	Format,
		IN WavePins	Pin
	)

Definition at line 826 of file miniport.cpp.

{
    PAGED_CODE ();
 
    ASSERT (Format);
 
    DOUT (DBG_PRINT, ("[CMiniport::TestDataFormat]"));
 
    //
    // KSDATAFORMAT contains three GUIDs to support extensible format.  The
    // first two GUIDs identify the type of data.  The third indicates the
    // type of specifier used to indicate format specifics.  We are only
    // supporting PCM audio formats that use WAVEFORMATEX.
    //
    if (!IsEqualGUIDAligned (Format->MajorFormat, KSDATAFORMAT_TYPE_AUDIO) ||
        !IsEqualGUIDAligned (Format->SubFormat, KSDATAFORMAT_SUBTYPE_PCM)  ||
        !IsEqualGUIDAligned (Format->Specifier, KSDATAFORMAT_SPECIFIER_WAVEFORMATEX))
    {
        DOUT (DBG_ERROR, ("[TestDataFormat] Invalid format type!"));
        return STATUS_INVALID_PARAMETER;
    }
 
    PWAVEFORMATPCMEX waveFormat = (PWAVEFORMATPCMEX)(Format + 1);
 
    //
    // If the size doesn't match, then something is messed up.
    //
    if (Format->FormatSize < (sizeof(KSDATAFORMAT) + sizeof(WAVEFORMATEX)))
    {
        DOUT (DBG_WARNING, ("[TestDataFormat] Invalid FormatSize!"));
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // We only support PCM, 16-bit.
    //
    if (waveFormat->Format.wBitsPerSample != 16)
    {
        DOUT (DBG_WARNING, ("[TestDataFormat] Bits Per Sample must be 16!"));
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // We support WaveFormatPCMEX (=WAVEFORMATEXTENSIBLE) or WaveFormatPCM.
    //
    if ((waveFormat->Format.wFormatTag != WAVE_FORMAT_EXTENSIBLE) &&
        (waveFormat->Format.wFormatTag != WAVE_FORMAT_PCM))
    {
        DOUT (DBG_WARNING, ("[TestDataFormat] Invalid Format Tag!"));
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // Make additional checks for the WAVEFORMATEXTENSIBLE
    //
    if (waveFormat->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE)
    {
        //
        // If the size doesn't match, then something is messed up.
        //
        if (Format->FormatSize < (sizeof(KSDATAFORMAT) + sizeof(WAVEFORMATPCMEX)))
        {
            DOUT (DBG_WARNING, ("[TestDataFormat] Invalid FormatSize!"));
            return STATUS_INVALID_PARAMETER;
        }
 
        //
        // Check also the subtype (PCM) and the size of the extended data.
        //
        if (!IsEqualGUIDAligned (waveFormat->SubFormat, KSDATAFORMAT_SUBTYPE_PCM) ||
            (waveFormat->Format.cbSize < (sizeof(WAVEFORMATPCMEX) - sizeof(WAVEFORMATEX))))
        {
            DOUT (DBG_WARNING, ("[TestDataFormat] Unsupported WAVEFORMATEXTENSIBLE!"));
            return STATUS_INVALID_PARAMETER;
        }
 
        //
        // Check the channel mask. We support 1, 2 channels or whatever was set
        // with the Speaker config dialog.
        //
        if (((waveFormat->Format.nChannels == 1) &&
             (waveFormat->dwChannelMask != KSAUDIO_SPEAKER_MONO)) ||
            ((waveFormat->Format.nChannels == 2) &&
             (waveFormat->dwChannelMask != KSAUDIO_SPEAKER_STEREO)) ||
            ((waveFormat->Format.nChannels == m_wChannels) &&
             (waveFormat->dwChannelMask != m_dwChannelMask)))
        {
            DOUT (DBG_WARNING, ("[TestDataFormat] Channel Mask!"));
            return STATUS_INVALID_PARAMETER;
        }
    }
 
    //
    // Check the number of channels.
    //
    switch (Pin)
    {
        case PIN_MICIN:     // 1 channel
            if (waveFormat->Format.nChannels != 1)
            {
                DOUT (DBG_WARNING, ("[TestDataFormat] Invalid Number of Channels for PIN_MICIN!"));
                return STATUS_INVALID_PARAMETER;
            }
            break;
        case PIN_WAVEIN:    // 2 channels
            if (waveFormat->Format.nChannels != 2)
            {
                DOUT (DBG_WARNING, ("[TestDataFormat] Invalid Number of Channels for PIN_WAVEIN!"));
                return STATUS_INVALID_PARAMETER;
            }
            break;
        case PIN_WAVEOUT:   // channel and mask from PropertyChannelConfig or standard.
            if (waveFormat->Format.nChannels != m_wChannels)
            {
                DOUT (DBG_WARNING, ("[TestDataFormat] Invalid Number of Channels for PIN_WAVEOUT!"));
                return STATUS_INVALID_PARAMETER;
            }
            break;
    }
 
    //
    // Print the information.
    //
    if (waveFormat->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE)
    {
        DOUT (DBG_STREAM, ("[TestDataFormat] PCMEX - Frequency: %d, Channels: %d, bps: %d, ChannelMask: %X",
              waveFormat->Format.nSamplesPerSec, waveFormat->Format.nChannels,
              waveFormat->Format.wBitsPerSample, waveFormat->dwChannelMask));
    }
    else
    {
        DOUT (DBG_STREAM, ("[TestDataFormat] PCM - Frequency: %d, Channels: %d, bps: %d",
              waveFormat->Format.nSamplesPerSec, waveFormat->Format.nChannels,
              waveFormat->Format.wBitsPerSample));
    }
 
    return STATUS_SUCCESS;
}

Referenced by ValidateFormat().

ValidateFormat()

NTSTATUS CMiniport::ValidateFormat	(	IN PKSDATAFORMAT	DataFormat,
		IN WavePins	Pin
	)

Definition at line 780 of file miniport.cpp.

{
    //
    // Validate the channel (pin id).
    //
    if ((Pin != PIN_WAVEOUT) && (Pin != PIN_WAVEIN) &&
       (Pin != PIN_MICIN))
    {
        DOUT (DBG_ERROR, ("[NewStream] Invalid channel passed!"));
        return STATUS_INVALID_PARAMETER;
    }
 
    //
    // Check if the pin is already in use
    //
    if (Streams[Pin/2])
    {
        DOUT (DBG_ERROR, ("[NewStream] Pin is already in use!"));
        return STATUS_UNSUCCESSFUL;
    }
 
    //
    // Check parameters.
    //
    NTSTATUS ntStatus = TestDataFormat (DataFormat, Pin);
    if (!NT_SUCCESS (ntStatus))
    {
        DOUT (DBG_VSR, ("[NewStream] TestDataFormat failed!"));
        return ntStatus;
    }
 
    return ntStatus;
}

Member Data Documentation

AdapterCommon

PADAPTERCOMMON CMiniport::AdapterCommon

Definition at line 31 of file miniport.h.

Referenced by BuildDataRangeInformation(), InterruptServiceRoutine(), CMiniportStream::PowerChangeNotify_(), PropertyChannelConfig(), CMiniportStream::ReadReg16(), CMiniportStream::ReadReg32(), CMiniportStream::ReadReg8(), STDMETHODIMP_(), CMiniportStream::WriteReg16(), CMiniportStream::WriteReg32(), CMiniportStream::WriteReg8(), ~CMiniport(), and CMiniportStream::~CMiniportStream().

DmaChannel

PDMACHANNEL CMiniport::DmaChannel

Definition at line 33 of file miniport.h.

Referenced by CMiniportStream::BDList_Alloc(), CMiniportStream::BDList_Free(), CMiniportWaveCyclicStream::ResizeBuffer(), STDMETHODIMP_(), and ~CMiniport().

IMP_IMiniport

CMiniport::IMP_IMiniport

Definition at line 72 of file miniport.h.

IMP_IPowerNotify

CMiniport::IMP_IPowerNotify

Definition at line 77 of file miniport.h.

InterruptSync

PINTERRUPTSYNC CMiniport::InterruptSync

Definition at line 32 of file miniport.h.

Referenced by InterruptServiceRoutine(), ProcessResources(), STDMETHODIMP_(), and ~CMiniport().

m_dwChannelMask

DWORD CMiniport::m_dwChannelMask

Definition at line 35 of file miniport.h.

Referenced by PropertyChannelConfig(), and TestDataFormat().

m_PowerState

DEVICE_POWER_STATE CMiniport::m_PowerState

Definition at line 34 of file miniport.h.

Referenced by STDMETHODIMP_().

m_wChannels

WORD CMiniport::m_wChannels

Definition at line 36 of file miniport.h.

Referenced by PropertyChannelConfig(), and TestDataFormat().

Port

PPORT_ CMiniport::Port

Definition at line 30 of file miniport.h.

Referenced by CMiniportWaveCyclicStream::InterruptServiceRoutine(), STDMETHODIMP_(), and ~CMiniport().

Port_

_In_ PRESOURCELIST _In_ PPORT CMiniport::Port_

Definition at line 97 of file miniport.h.

Referenced by STDMETHODIMP_().

ResourceList

_In_ PRESOURCELIST CMiniport::ResourceList

Definition at line 96 of file miniport.h.

Streams

CMiniportStream* CMiniport::Streams[PIN_MICIN_OFFSET+1]

Definition at line 29 of file miniport.h.

Referenced by CMiniportStream::Init(), InterruptServiceRoutine(), STDMETHODIMP_(), ValidateFormat(), and CMiniportStream::~CMiniportStream().

---

The documentation for this class was generated from the following files:

• drivers/wdm/audio/drivers/ac97/miniport.h
• drivers/wdm/audio/drivers/ac97/miniport.cpp