#include <wavepcistream.h>

Inheritance diagram for CMiniportWaveICHStream:

[legend]

Collaboration diagram for CMiniportWaveICHStream:

[legend]

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)

virtual 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_)

virtual void	InterruptServiceRoutine () PURE

virtual NTSTATUS	Init_ () PURE

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 202 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;
}