CMiniportWaveICHStream Class Reference

#include <wavepcistream.h>

Inheritance diagram for CMiniportWaveICHStream:

Collaboration diagram for CMiniportWaveICHStream:

Public Member Functions
	DECLARE_STD_UNKNOWN ()
	DEFINE_STD_CONSTRUCTOR (CMiniportWaveICHStream)
	~CMiniportWaveICHStream ()
NTSTATUS	Init_ ()
void	PowerChangeNotify_ (IN POWER_STATE NewState)
void	InterruptServiceRoutine ()
Public Member Functions inherited from CMiniportStream
	~CMiniportStream ()
void	ResetDMA (void)
void	PauseDMA (void)
void	ResumeDMA (ULONG state=DMA_ENGINE_ON)
int	GetBuffPos (DWORD *buffPos)
void	WriteReg8 (ULONG addr, UCHAR data)
void	WriteReg16 (ULONG addr, USHORT data)
void	WriteReg32 (ULONG addr, ULONG data)
UCHAR	ReadReg8 (ULONG addr)
USHORT	ReadReg16 (ULONG addr)
ULONG	ReadReg32 (ULONG addr)
	STDMETHODIMP_ (NTSTATUS) SetFormat(_In_ PKSDATAFORMAT Format)
void	PowerChangeNotify (IN POWER_STATE NewState)
ULONG	GetCurrentSampleRate (void)
NTSTATUS	Init (IN CMiniport *Miniport_, IN PUNKNOWN PortStream, IN WavePins Pin_, IN BOOLEAN Capture_, IN PKSDATAFORMAT DataFormat_, OUT PSERVICEGROUP *ServiceGroup_)
NTSTATUS	NonDelegatingQueryInterface (_In_ REFIID Interface, _COM_Outptr_ PVOID *Object, _In_ REFIID iStream, _In_ PUNKNOWN stream)
NTSTATUS	SetState (_In_ KSSTATE State)
NTSTATUS	NormalizePhysicalPosition (_Inout_ PLONGLONG PhysicalPosition)
PVOID	BDList_Alloc ()
void	BDList_Free ()
void	UpdateLviCyclic ()

Public Attributes
	IMP_IMiniportWavePciStream
Public Attributes inherited from CUnknown
union {
IUnknown   IUnknown
INonDelegatingUnknown   INonDelegatingUnknown
};
LONG	m_ref_count
PUNKNOWN	m_outer_unknown
Public Attributes inherited from CMiniportStream
CMiniport *	Miniport
WavePins	Pin
BOOL	Capture
WORD	NumberOfChannels
DEVICE_POWER_STATE	m_PowerState
PPORTSTREAM_	PortStream
PKSDATAFORMAT_WAVEFORMATEX	DataFormat
PSERVICEGROUP	ServiceGroup
ULONG	CurrentRate
ULONG	DMAEngineState
ULONG	m_ulBDAddr
PHYSICAL_ADDRESS	BDList_PhysAddr
tBDEntry *	BDList
	IMP_IDrmAudioStream

Private Member Functions
NTSTATUS	GetNewMappings (void)
NTSTATUS	ReleaseUsedMappings (void)
CMiniportWaveICH *	Wave ()

Private Attributes
KSPIN_LOCK	MapLock
ULONGLONG	TotalBytesMapped
ULONGLONG	TotalBytesReleased
BOOL	m_inGetMapping
tBDList	stBDList

Detailed Description

Definition at line 57 of file wavepcistream.h.

Constructor & Destructor Documentation

~CMiniportWaveICHStream()

CMiniportWaveICHStream::~CMiniportWaveICHStream

(

)

Definition at line 73 of file wavepcistream.cpp.

{
    PAGED_CODE ();


    DOUT (DBG_PRINT, ("[CMiniportWaveICHStream::~CMiniportWaveICHStream]"));

    //
    // Print information about the scatter gather list.
    //
    DOUT (DBG_DMA, ("Head %d, Tail %d, Entries %d.",
                   stBDList.nHead, stBDList.nTail,
                   stBDList.nBDEntries));

    // Release the scatter/gather table.
    BDList_Free();
}

Member Function Documentation

DECLARE_STD_UNKNOWN()

CMiniportWaveICHStream::DECLARE_STD_UNKNOWN

(

)

DEFINE_STD_CONSTRUCTOR()

CMiniportWaveICHStream::DEFINE_STD_CONSTRUCTOR

(

CMiniportWaveICHStream

)

GetNewMappings()

NTSTATUS CMiniportWaveICHStream::GetNewMappings ( void  )

private

Definition at line 553 of file wavepcistream.cpp.

{
    KIRQL OldIrql;

    NTSTATUS    ntStatus = STATUS_SUCCESS;
    ULONG       ulBytesMapped = 0;
    int         nInsertMappings = 0;
    int         nTail;                  // aut. variable

    DOUT (DBG_PRINT, ("[CMiniportWaveICHStream::GetNewMappings]"));

    // acquire the mapping spin lock
    KeAcquireSpinLock (&MapLock,&OldIrql);

    // detect reentrance
    if(m_inGetMapping) {
        m_inGetMapping = 2;
        KeReleaseSpinLock (&MapLock,OldIrql);
        return STATUS_SUCCESS;
    }

#if (DBG)
    if (ReadReg16 (X_SR) & SR_CELV)
    {
        //
        // We starve.  :-(
        //
        DOUT (DBG_DMA, ("[GetNewMappings] We starved ... Head %d, Tail %d, Entries %d.",
                stBDList.nHead, stBDList.nTail, stBDList.nBDEntries));
    }
#endif

    //
    // Get available mappings up to the max of 31 that we can hold in the BDL.
    //
    while (stBDList.nBDEntries < (MAX_BDL_ENTRIES - 1))
    {
        //
        // Get the information from the list.
        //
        ULONG               Flags;
        ULONG               ulTag = stBDList.nTail;
        ULONG               ulBufferLength;
        PHYSICAL_ADDRESS    PhysAddr;
        PVOID               VirtAddr;


        // Release the mapping spin lock
NEW_MAPPINGS_AVAILBLE_MAYBE:
        m_inGetMapping = TRUE;
        KeReleaseSpinLock (&MapLock,OldIrql);

        //
        // Try to get the mapping from the port.
        // Here comes the problem: When calling GetMapping or ReleaseMapping we
        // cannot hold our spin lock. So we need to buffer the return values and
        // stick the information into the structure later when we have the spin
        // lock acquired.
        //
        ntStatus = PortStream->GetMapping ((PVOID)ULongToPtr(ulTag),
                                           (PPHYSICAL_ADDRESS)&PhysAddr,
                                           &VirtAddr,
                                           &ulBufferLength,
                                           &Flags);

        // Acquire the mapping spin lock
        KeAcquireSpinLock (&MapLock,&OldIrql);

        //
        // Quit this loop when we run out of mappings.
        //
        if (!NT_SUCCESS (ntStatus))
        {
            if(m_inGetMapping == 2)
                goto NEW_MAPPINGS_AVAILBLE_MAYBE;
            break;
        }

        // Sanity check: The audio stack will not give you data
        // that you cannot handle, but an application could use
        // DirectKS and send bad buffer down.

        // One mapping needs to be <0x1FFFF bytes for mono
        // streams on the AC97.
        if (ulBufferLength > 0x1FFFE)
        {
            // That is a little too long. That should never happen.
            DOUT (DBG_ERROR, ("[GetNewMappings] Buffer length too long!"));
            ulBufferLength = 0x1FFFE;
        }

        // The AC97 can only handle WORD aligned buffers.
        if (PhysAddr.LowPart & 0x01)
        {
            // we cannot play that! Set the buffer length to 0 so
            // that the HW will skip the buffer.
            DOUT (DBG_WARNING, ("[GetNewMappings] Buffer address unaligned!"));
            ulBufferLength = 0;
        }

        // The AC97 cannot handle unaligned mappings with respect
        // to the frame size (eg. 42 bytes on 4ch playback).
        if (ulBufferLength % NumberOfChannels)
        {
            // modify the length (don't play the rest of the bytes)
            DOUT (DBG_WARNING, ("[GetNewMappings] Buffer length unaligned!"));
            ulBufferLength -= ulBufferLength % NumberOfChannels;
        }

        //
        // Save the mapping.
        //
        nTail = stBDList.nTail;
        stBDList.pMapData[nTail].ulBufferLength = ulBufferLength;
        stBDList.pMapData[nTail].ulState = 1;
        ulBytesMapped += ulBufferLength;

        //
        // Fill in the BDL entry with pointer to physical address and length.
        //
        BDList[nTail].dwPtrToPhyAddress = PhysAddr.LowPart;
        BDList[nTail].wLength = (WORD)(ulBufferLength >> 1);
        BDList[nTail].wPolicyBits = BUP_SET;

        //
        // Generate an interrupt when portcls tells us to or roughly every 10ms.
        //
        if (Flags || (ulBytesMapped > (CurrentRate * NumberOfChannels * 2) / 100))
        {
            BDList[nTail].wPolicyBits |= IOC_ENABLE;
            ulBytesMapped = 0;
        }

        //
        // Take the new mapping into account.
        //
        stBDList.nTail = (stBDList.nTail + 1) & BDL_MASK;
        stBDList.nBDEntries++;
        TotalBytesMapped += (ULONGLONG)ulBufferLength;
        nInsertMappings++;

        //
        // Set last valid index (LVI) register! We need to do this here to avoid inconsistency
        // of the BDList with the HW. Note that we need to release spin locks every time
        // we call into portcls, that means we can be interrupted by ReleaseUsedMappings.
        //
        WriteReg8 (X_LVI, (UCHAR)nTail);
    }

    //
    // If there were processed mappings, print out some debug messages and eventually try to
    // restart DMA engine.
    //
    if (nInsertMappings)
    {
        //
        // Print debug information ...
        //
        DOUT (DBG_DMA, ("[GetNewMappings] Got %d mappings.", nInsertMappings));
        DOUT (DBG_DMA, ("[GetNewMappings] Head %d, Tail %d, Entries %d.",
                stBDList.nHead, stBDList.nTail, stBDList.nBDEntries));

        if(stBDList.nBDEntries >= 2)
            ResumeDMA (DMA_ENGINE_PAUSE);
    }

    // Release the mapping spin lock
    m_inGetMapping = FALSE;
    KeReleaseSpinLock (&MapLock,OldIrql);

    return ntStatus;
}

Referenced by STDMETHODIMP_().

Init_()

NTSTATUS CMiniportWaveICHStream::Init_ ( )

virtual

Reimplemented from CMiniportStream.

Definition at line 99 of file wavepcistream.cpp.

{
    PAGED_CODE ();

    DOUT (DBG_PRINT, ("[CMiniportWaveICHStream::Init]"));

    //
    // The rule here is that we return when we fail without a cleanup.
    // The destructor will relase the allocated memory.
    //

    //
    // Initialize the BDL spinlock.
    //
    KeInitializeSpinLock (&MapLock);

    //
    // Setup the Buffer Descriptor List (BDL)
    // Allocate 32 entries of 8 bytes (one BDL entry).
    // The pointer is aligned on a 8 byte boundary (that's what we need).
    //

    if (!BDList_Alloc())
    {
        DOUT (DBG_ERROR, ("Failed AllocateCommonBuffer!"));
        return STATUS_INSUFFICIENT_RESOURCES;
    }

    PPREFETCHOFFSET PreFetchOffset;
    //
    // Query for the new interface "PreFetchOffset" and use
    // function offered there in case the interface is offered.
    //
    if (NT_SUCCESS(PortStream->QueryInterface(IID_IPreFetchOffset, (PVOID *)&PreFetchOffset)))
    {
        // why don't we pad by 32 sample frames
        PreFetchOffset->SetPreFetchOffset(32 * (DataFormat->WaveFormatEx.nChannels * 2));
        PreFetchOffset->Release();
    }

    return STATUS_SUCCESS;
}

InterruptServiceRoutine()

void CMiniportWaveICHStream::InterruptServiceRoutine ( )

virtual

Reimplemented from CMiniportStream.

Definition at line 417 of file rtstream.cpp.

{
    //
    // Update the LVI so that we cycle around in the scatter gather list.
    //
    UpdateLviCyclic();
}

PowerChangeNotify_()

void CMiniportWaveICHStream::PowerChangeNotify_ ( IN POWER_STATE  NewState )

virtual

Reimplemented from CMiniportStream.

Definition at line 203 of file wavepcistream.cpp.

{
    KIRQL       OldIrql;

    KeAcquireSpinLock (&MapLock,&OldIrql);

    if(NewState.DeviceState == PowerDeviceD0)
    {
        ResetDMA ();

        // Restore the remaining DMA registers, that is last valid index
        // only if the index is not pointing to 0. Note that the index is
        // equal to head + entries.
        if (stBDList.nTail)
        {
            WriteReg8 (X_LVI, (UCHAR)((stBDList.nTail - 1) & BDL_MASK));
        }
    }
    else
    {

        // Disable interrupts and stop DMA just in case.
        WriteReg8 (X_CR, (UCHAR)0);

        // Get current index
       // int nCurrentIndex = (int)ReadReg8 (X_CIV);
    }

    KeReleaseSpinLock (&MapLock,OldIrql);
}

ReleaseUsedMappings()

NTSTATUS CMiniportWaveICHStream::ReleaseUsedMappings ( void  )

private

Definition at line 735 of file wavepcistream.cpp.

{
    KIRQL OldIrql;
    int   nMappingsReleased = 0;

    DOUT (DBG_PRINT, ("[CMiniportWaveICHStream::ReleaseUsedMappings]"));

    // acquire the mapping spin lock
    KeAcquireSpinLock (&MapLock,&OldIrql);

    //
    // Clean up everything to that index.
    //
    while (stBDList.nBDEntries)
    {
        //
        // Get current index
        //
        int nCurrentIndex = (int)ReadReg8 (X_CIV);

        //
        // When CIV is == Head -1 we released all mappings.
        //
        if (nCurrentIndex == ((stBDList.nHead - 1) & BDL_MASK))
        {
           break;
        }

        //
        // Check if CIV is between head and tail.
        //
        if (nCurrentIndex < stBDList.nHead)
        {
            //
            // Check for CIV being outside range.
            //
            if ((nCurrentIndex + MAX_BDL_ENTRIES) >=
                (stBDList.nHead + stBDList.nBDEntries))
            {
                DOUT (DBG_ERROR, ("[ReleaseUsedMappings] CIV out of range!"));
                break;
            }
        }
        else
        {
            //
            // Check for CIV being outside range.
            //
            if (nCurrentIndex >= (stBDList.nHead + stBDList.nBDEntries))
            {
                DOUT (DBG_ERROR, ("[ReleaseUsedMappings] CIV out of range!"));
                break;
            }
        }

        //
        // Check to see if we've released all the buffers.
        //
        if (stBDList.nHead == nCurrentIndex)
        {
            if (nCurrentIndex == ((stBDList.nTail - 1) & BDL_MASK))
            {
                //
                // A special case is starvation or stop of stream, when the
                // DMA engine finished playing the buffers, CVI is equal LVI
                // and SR_CELV is set.
                //
                if (!(ReadReg16 (X_SR) & SR_CELV))
                {
                    // It is still playing the last buffer.
                    break;
                }

                //
                // In case the CVI=LVI bit is set, nBDEntries should be 1
                //
                if (stBDList.nBDEntries != 1)
                {
                    DOUT (DBG_ERROR, ("[ReleaseUsedMappings] Inconsitency: Tail reached and Entries != 1."));
                }
            }
            else
            {
                //
                // Bail out. Current Index did not move.
                //
                break;
            }
        }

        //
        // Save the tag and remove the entry from the list.
        //
        ULONG   ulTag = stBDList.nHead;
        stBDList.nBDEntries--;
        stBDList.nHead = (stBDList.nHead + 1) & BDL_MASK;
        nMappingsReleased++;

        // if entry has not been revoked
        if(stBDList.pMapData[ulTag].ulState == 1)
        {
            TotalBytesReleased += (ULONGLONG)stBDList.pMapData[ulTag].ulBufferLength;

            // Release the mapping spin lock
            KeReleaseSpinLock (&MapLock,OldIrql);

            //
            // Release this entry.
            //
            PortStream->ReleaseMapping ((PVOID)ULongToPtr(ulTag));

            // acquire the mapping spin lock
            KeAcquireSpinLock (&MapLock,&OldIrql);
        }

        stBDList.pMapData[ulTag].ulState = 0;
    }


    // Print some debug information in case we released mappings.
    if (nMappingsReleased)
    {
        //
        // Print release information and return.
        //
        DOUT (DBG_DMA, ("[ReleaseUsedMappings] Head %d, Tail %d, Entries %d.",
                       stBDList.nHead, stBDList.nTail, stBDList.nBDEntries));
    }

    // Release the mapping spin lock
    KeReleaseSpinLock (&MapLock,OldIrql);

    return STATUS_SUCCESS;
}

Referenced by STDMETHODIMP_().

Wave()

CMiniportWaveICH* CMiniportWaveICHStream::Wave ( )

inlineprivate

Definition at line 91 of file wavepcistream.h.

                             {
      return (CMiniportWaveICH*)Miniport; }

Member Data Documentation

IMP_IMiniportWavePciStream

CMiniportWaveICHStream::IMP_IMiniportWavePciStream

Definition at line 114 of file wavepcistream.h.

m_inGetMapping

BOOL CMiniportWaveICHStream::m_inGetMapping

private

Definition at line 68 of file wavepcistream.h.

Referenced by GetNewMappings().

MapLock

KSPIN_LOCK CMiniportWaveICHStream::MapLock

private

Definition at line 65 of file wavepcistream.h.

Referenced by GetNewMappings(), Init_(), PowerChangeNotify_(), and ReleaseUsedMappings().

stBDList

tBDList CMiniportWaveICHStream::stBDList

private

Definition at line 70 of file wavepcistream.h.

Referenced by GetNewMappings(), PowerChangeNotify_(), ReleaseUsedMappings(), and ~CMiniportWaveICHStream().

TotalBytesMapped

ULONGLONG CMiniportWaveICHStream::TotalBytesMapped

private

Definition at line 66 of file wavepcistream.h.

Referenced by GetNewMappings().

TotalBytesReleased

ULONGLONG CMiniportWaveICHStream::TotalBytesReleased

private

Definition at line 67 of file wavepcistream.h.

Referenced by ReleaseUsedMappings().

---

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

• drivers/wdm/audio/drivers/ac97/wavepcistream.h
• drivers/wdm/audio/drivers/ac97/rtstream.cpp
• drivers/wdm/audio/drivers/ac97/wavepcistream.cpp