miniport_dmus.cpp File Reference

#include "private.hpp"
#include <debug.h>

Include dependency graph for miniport_dmus.cpp:

Go to the source code of this file.

Classes
class	CMiniportDMusUART
class	CMiniportDMusUARTStream
struct	SYNCWRITECONTEXT

Macros
#define	NDEBUG
#define	kOneMillisec   (10 * 1000)
#define	MPU401_REG_STATUS   0x01
#define	MPU401_DRR   0x40
#define	MPU401_DSR   0x80
#define	MPU401_REG_DATA   0x00
#define	MPU401_REG_COMMAND   0x01
#define	MPU401_CMD_RESET   0xFF
#define	MPU401_CMD_UART   0x3F
#define	STR_MODULENAME   "DMusUART:Miniport: "
#define	UartFifoOkForWrite(status)   ((status & MPU401_DRR) == 0)
#define	UartFifoOkForRead(status)   ((status & MPU401_DSR) == 0)
#define	kMaxNumCaptureStreams   1
#define	kMaxNumLegacyRenderStreams   1
#define	kMaxNumDMusicRenderStreams   1
#define	CONST_PCNODE_DESCRIPTOR(n)   { 0, NULL, &n, NULL }
#define	CONST_PCNODE_DESCRIPTOR_AUTO(n, a)   { 0, &a, &n, NULL }
#define	kMPUPollTimeout   2

Typedefs
typedef struct SYNCWRITECONTEXT *	PSYNCWRITECONTEXT

Enumerations
enum	{ eSynthNode = 0 , eInputNode }
enum	{   eFilterInputPinLeg = 0 , eFilterInputPinDM , eBridgeOutputPin , eBridgeInputPin ,   eFilterOutputPin }

Functions
NTSTATUS NTAPI	InitMPU (IN PINTERRUPTSYNC InterruptSync, IN PVOID DynamicContext)
NTSTATUS	ResetHardware (PUCHAR portBase)
NTSTATUS	ValidatePropertyRequest (IN PPCPROPERTY_REQUEST pRequest, IN ULONG ulValueSize, IN BOOLEAN fValueRequired)
NTSTATUS NTAPI	PropertyHandler_Synth (IN PPCPROPERTY_REQUEST PropertyRequest)
NTSTATUS NTAPI	DMusMPUInterruptServiceRoutine (PINTERRUPTSYNC InterruptSync, PVOID DynamicContext)
VOID NTAPI	DMusUARTTimerDPC (PKDPC Dpc, PVOID DeferredContext, PVOID SystemArgument1, PVOID SystemArgument2)
NTSTATUS NTAPI	SynchronizedDMusMPUWrite (PINTERRUPTSYNC InterruptSync, PVOID syncWriteContext)
	DEFINE_PCAUTOMATION_TABLE_PROP (AutomationSynth, SynthProperties)
	DEFINE_PCAUTOMATION_TABLE_PROP (AutomationSynth2, SynthProperties)
BOOLEAN	TryMPU (IN PUCHAR PortBase)
NTSTATUS	WriteMPU (IN PUCHAR PortBase, IN BOOLEAN IsCommand, IN UCHAR Value)
NTSTATUS NTAPI	SynchronizedDMusMPUWrite (IN PINTERRUPTSYNC InterruptSync, IN PVOID syncWriteContext)
	SnapTimeStamp (PINTERRUPTSYNC InterruptSync, PVOID pStream)
NTSTATUS NTAPI	DMusMPUInterruptServiceRoutine (IN PINTERRUPTSYNC InterruptSync, IN PVOID DynamicContext)
NTSTATUS	NewMiniportDMusUART (OUT PMINIPORT *OutMiniport, IN REFCLSID ClassId)
VOID NTAPI	DMusUARTTimerDPC (IN PKDPC Dpc, IN PVOID DeferredContext, IN PVOID SystemArgument1, IN PVOID SystemArgument2)

Variables
const BOOLEAN	COMMAND = TRUE
const BOOLEAN	DATA = FALSE
const ULONG	kMPUInputBufferSize = 128
static KSDATARANGE_MUSIC	PinDataRangesStreamLegacy
static KSDATARANGE_MUSIC	PinDataRangesStreamDMusic
static PKSDATARANGE	PinDataRangePointersStreamLegacy []
static PKSDATARANGE	PinDataRangePointersStreamDMusic []
static PKSDATARANGE	PinDataRangePointersStreamCombined []
static KSDATARANGE	PinDataRangesBridge []
static PKSDATARANGE	PinDataRangePointersBridge []
static PCPROPERTY_ITEM	SynthProperties []
static PCPIN_DESCRIPTOR	MiniportPins []
static PCNODE_DESCRIPTOR	MiniportNodes []
static PCCONNECTION_DESCRIPTOR	MiniportConnections []
static GUID	MiniportCategories []
static PCFILTER_DESCRIPTOR	MiniportFilterDescriptor
const WCHAR	wszDescOut [] = L"DMusic MPU-401 Out "
const WCHAR	wszDescIn [] = L"DMusic MPU-401 In "

Macro Definition Documentation

CONST_PCNODE_DESCRIPTOR

#define CONST_PCNODE_DESCRIPTOR

(

n

)

{ 0, NULL, &n, NULL }

Definition at line 517 of file miniport_dmus.cpp.

CONST_PCNODE_DESCRIPTOR_AUTO

#define CONST_PCNODE_DESCRIPTOR_AUTO	(		n,
			a
	)		{ 0, &a, &n, NULL }

Definition at line 518 of file miniport_dmus.cpp.

kMaxNumCaptureStreams

#define kMaxNumCaptureStreams   1

Definition at line 413 of file miniport_dmus.cpp.

kMaxNumDMusicRenderStreams

#define kMaxNumDMusicRenderStreams   1

Definition at line 415 of file miniport_dmus.cpp.

kMaxNumLegacyRenderStreams

#define kMaxNumLegacyRenderStreams   1

Definition at line 414 of file miniport_dmus.cpp.

kMPUPollTimeout

#define kMPUPollTimeout   2

Definition at line 873 of file miniport_dmus.cpp.

kOneMillisec

#define kOneMillisec   (10 * 1000)

Definition at line 17 of file miniport_dmus.cpp.

MPU401_CMD_RESET

#define MPU401_CMD_RESET   0xFF

Definition at line 30 of file miniport_dmus.cpp.

MPU401_CMD_UART

#define MPU401_CMD_UART   0x3F

Definition at line 31 of file miniport_dmus.cpp.

MPU401_DRR

#define MPU401_DRR   0x40

Definition at line 23 of file miniport_dmus.cpp.

MPU401_DSR

#define MPU401_DSR   0x80

Definition at line 25 of file miniport_dmus.cpp.

MPU401_REG_COMMAND

#define MPU401_REG_COMMAND   0x01

Definition at line 29 of file miniport_dmus.cpp.

MPU401_REG_DATA

#define MPU401_REG_DATA   0x00

Definition at line 28 of file miniport_dmus.cpp.

MPU401_REG_STATUS

#define MPU401_REG_STATUS   0x01

Definition at line 22 of file miniport_dmus.cpp.

NDEBUG

#define NDEBUG

Definition at line 12 of file miniport_dmus.cpp.

STR_MODULENAME

#define STR_MODULENAME   "DMusUART:Miniport: "

Definition at line 250 of file miniport_dmus.cpp.

UartFifoOkForRead

#define UartFifoOkForRead

(

status

)

((status & MPU401_DSR) == 0)

Definition at line 257 of file miniport_dmus.cpp.

UartFifoOkForWrite

#define UartFifoOkForWrite

(

status

)

((status & MPU401_DRR) == 0)

Definition at line 256 of file miniport_dmus.cpp.

Typedef Documentation

PSYNCWRITECONTEXT

typedef struct SYNCWRITECONTEXT * PSYNCWRITECONTEXT

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
eSynthNode
eInputNode

Definition at line 531 of file miniport_dmus.cpp.

     {
      eSynthNode  = 0
    , eInputNode
};

anonymous enum

anonymous enum

Enumerator
eFilterInputPinLeg
eFilterInputPinDM
eBridgeOutputPin
eBridgeInputPin
eFilterOutputPin

Definition at line 536 of file miniport_dmus.cpp.

     {
      eFilterInputPinLeg = 0,
      eFilterInputPinDM,
      eBridgeOutputPin,
      eBridgeInputPin,
      eFilterOutputPin
};

Function Documentation

DEFINE_PCAUTOMATION_TABLE_PROP() [1/2]

DEFINE_PCAUTOMATION_TABLE_PROP	(	AutomationSynth	,
		SynthProperties
	)

DEFINE_PCAUTOMATION_TABLE_PROP() [2/2]

DEFINE_PCAUTOMATION_TABLE_PROP	(	AutomationSynth2	,
		SynthProperties
	)

DMusMPUInterruptServiceRoutine() [1/2]

NTSTATUS NTAPI DMusMPUInterruptServiceRoutine	(	IN PINTERRUPTSYNC	InterruptSync,
		IN PVOID	DynamicContext
	)

Definition at line 1101 of file miniport_dmus.cpp.

{
    DPRINT("DMusMPUInterruptServiceRoutine");
    ULONGLONG   startTime;
 
    ASSERT(DynamicContext);
 
    NTSTATUS            ntStatus;
    BOOL                newBytesAvailable;
    CMiniportDMusUART   *that;
    NTSTATUS            clockStatus;
 
    that = (CMiniportDMusUART *) DynamicContext;
    newBytesAvailable = FALSE;
    ntStatus = STATUS_UNSUCCESSFUL;
 
    UCHAR portStatus = 0xff;
 
    //
    // Read the MPU status byte.
    //
    if (that->m_pPortBase)
    {
        portStatus =
            READ_PORT_UCHAR(that->m_pPortBase + MPU401_REG_STATUS);
 
        //
        // If there is outstanding work to do and there is a port-driver for
        // the MPU miniport...
        //
        if (UartFifoOkForRead(portStatus) && that->m_pPort)
        {
            startTime = PcGetTimeInterval(0);
            while ( (PcGetTimeInterval(startTime) < GTI_MILLISECONDS(50))
                &&  (UartFifoOkForRead(portStatus)) )
            {
                UCHAR uDest = READ_PORT_UCHAR(that->m_pPortBase + MPU401_REG_DATA);
                if (    (that->m_KSStateInput == KSSTATE_RUN)
                    &&  (that->m_NumCaptureStreams)
                   )
                {
                    ULONG    buffHead = that->m_MPUInputBufferHead;
                    if (   (that->m_MPUInputBufferTail + 1 == buffHead)
                        || (that->m_MPUInputBufferTail + 1 - kMPUInputBufferSize == buffHead))
                    {
                        DPRINT("*****MPU Input Buffer Overflow*****");
                    }
                    else
                    {
                        if (!that->m_InputTimeStamp)
                        {
                            clockStatus = that->m_MasterClock->GetTime(&that->m_InputTimeStamp);
                            if (STATUS_SUCCESS != clockStatus)
                            {
                                DPRINT("GetTime failed for clock 0x%08x",that->m_MasterClock);
                            }
                        }
                        newBytesAvailable = TRUE;
                        //  ...place the data in our FIFO...
                        that->m_MPUInputBuffer[that->m_MPUInputBufferTail] = uDest;
                        ASSERT(that->m_MPUInputBufferTail < kMPUInputBufferSize);
 
                        that->m_MPUInputBufferTail++;
                        if (that->m_MPUInputBufferTail >= kMPUInputBufferSize)
                        {
                            that->m_MPUInputBufferTail = 0;
                        }
                    }
                }
                //
                // Look for more MIDI data.
                //
                portStatus =
                    READ_PORT_UCHAR(that->m_pPortBase + MPU401_REG_STATUS);
            }   //  either there's no data or we ran too long
            if (newBytesAvailable)
            {
                //
                // ...notify the MPU port driver that we have bytes.
                //
                that->m_pPort->Notify(that->m_pServiceGroup);
            }
            ntStatus = STATUS_SUCCESS;
        }
    }
 
    return ntStatus;
}

DMusMPUInterruptServiceRoutine() [2/2]

NTSTATUS NTAPI DMusMPUInterruptServiceRoutine	(	PINTERRUPTSYNC	InterruptSync,
		PVOID	DynamicContext
	)

Referenced by SynchronizedDMusMPUWrite().

DMusUARTTimerDPC() [1/2]

VOID NTAPI DMusUARTTimerDPC	(	IN PKDPC	Dpc,
		IN PVOID	DeferredContext,
		IN PVOID	SystemArgument1,
		IN PVOID	SystemArgument2
	)

Definition at line 2390 of file miniport_dmus.cpp.

{
    ASSERT(DeferredContext);
 
    CMiniportDMusUARTStream *aStream;
    aStream = (CMiniportDMusUARTStream *) DeferredContext;
    if (aStream)
    {
        DPRINT("DMusUARTTimerDPC");
        if (false == aStream->m_fCapture)
        {
            (void) aStream->ConsumeEvents();
        }
        //  ignores return value!
    }
}

DMusUARTTimerDPC() [2/2]

VOID NTAPI DMusUARTTimerDPC	(	PKDPC	Dpc,
		PVOID	DeferredContext,
		PVOID	SystemArgument1,
		PVOID	SystemArgument2
	)

InitMPU()

NTSTATUS NTAPI InitMPU	(	IN PINTERRUPTSYNC	InterruptSync,
		IN PVOID	DynamicContext
	)

Definition at line 659 of file miniport_dmus.cpp.

{
    DPRINT("InitMPU");
    if (!DynamicContext)
    {
        return STATUS_INVALID_PARAMETER_2;
    }
 
    PUCHAR      portBase = PUCHAR(DynamicContext);
    UCHAR       status;
    ULONGLONG   startTime;
    BOOLEAN     success;
    NTSTATUS    ntStatus = STATUS_SUCCESS;
 
    //
    // Reset the card (puts it into "smart mode")
    //
    ntStatus = WriteMPU(portBase,COMMAND,MPU401_CMD_RESET);
 
    // wait for the acknowledgement
    // NOTE: When the Ack arrives, it will trigger an interrupt.
    //       Normally the DPC routine would read in the ack byte and we
    //       would never see it, however since we have the hardware locked (HwEnter),
    //       we can read the port before the DPC can and thus we receive the Ack.
    startTime = PcGetTimeInterval(0);
    success = FALSE;
    while(PcGetTimeInterval(startTime) < GTI_MILLISECONDS(50))
    {
        status = READ_PORT_UCHAR(portBase + MPU401_REG_STATUS);
 
        if (UartFifoOkForRead(status))                      // Is data waiting?
        {
            READ_PORT_UCHAR(portBase + MPU401_REG_DATA);    // yep.. read ACK
            success = TRUE;                                 // don't need to do more
            break;
        }
        KeStallExecutionProcessor(25);  //  microseconds
    }
#if (DBG)
    if (!success)
    {
        DPRINT("First attempt to reset the MPU didn't get ACKed.\n");
    }
#endif  //  (DBG)
 
    // NOTE: We cannot check the ACK byte because if the card was already in
    // UART mode it will not send an ACK but it will reset.
 
    // reset the card again
    (void) WriteMPU(portBase,COMMAND,MPU401_CMD_RESET);
 
                                    // wait for ack (again)
    startTime = PcGetTimeInterval(0); // This might take a while
    BYTE dataByte = 0;
    success = FALSE;
    while (PcGetTimeInterval(startTime) < GTI_MILLISECONDS(50))
    {
        status = READ_PORT_UCHAR(portBase + MPU401_REG_STATUS);
        if (UartFifoOkForRead(status))                              // Is data waiting?
        {
            dataByte = READ_PORT_UCHAR(portBase + MPU401_REG_DATA); // yep.. read ACK
            success = TRUE;                                         // don't need to do more
            break;
        }
        KeStallExecutionProcessor(25);
    }
 
    if ((0xFE != dataByte) || !success)   // Did we succeed? If no second ACK, something is hosed
    {
        DPRINT("Second attempt to reset the MPU didn't get ACKed.\n");
        DPRINT("Init Reset failure error. Ack = %X", ULONG(dataByte));
 
        ntStatus = STATUS_IO_DEVICE_ERROR;
    }
 
    return ntStatus;
}

Referenced by CMiniportDMusUART::InitializeHardware(), and CMiniportDMusUART::~CMiniportDMusUART().

NewMiniportDMusUART()

NTSTATUS NewMiniportDMusUART	(	OUT PMINIPORT *	OutMiniport,
		IN REFCLSID	ClassId
	)

Definition at line 1222 of file miniport_dmus.cpp.

{
    CMiniportDMusUART * This;
    NTSTATUS Status;
 
    This= new(NonPagedPool, TAG_PORTCLASS) CMiniportDMusUART(NULL);
    if (!This)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = This->QueryInterface(IID_IMiniport, (PVOID*)OutMiniport);
 
    if (!NT_SUCCESS(Status))
    {
        delete This;
    }
 
    DPRINT("NewMiniportDMusUART %p Status %x\n", *OutMiniport, Status);
    return Status;
}

Referenced by PcNewMiniport().

PropertyHandler_Synth()

NTSTATUS NTAPI PropertyHandler_Synth

(

IN PPCPROPERTY_REQUEST

PropertyRequest

)

Definition at line 2429 of file miniport_dmus.cpp.

{
    NTSTATUS    ntStatus;
 
    PAGED_CODE();
 
    if (pRequest->Verb & KSPROPERTY_TYPE_BASICSUPPORT)
    {
        ntStatus = ValidatePropertyRequest(pRequest, sizeof(ULONG), TRUE);
        if (NT_SUCCESS(ntStatus))
        {
            // if return buffer can hold a ULONG, return the access flags
            PULONG AccessFlags = PULONG(pRequest->Value);
 
            *AccessFlags = KSPROPERTY_TYPE_BASICSUPPORT;
            switch (pRequest->PropertyItem->Id)
            {
                case KSPROPERTY_SYNTH_CAPS:
                case KSPROPERTY_SYNTH_CHANNELGROUPS:
                    *AccessFlags |= KSPROPERTY_TYPE_GET;
            }
            switch (pRequest->PropertyItem->Id)
            {
                case KSPROPERTY_SYNTH_CHANNELGROUPS:
                    *AccessFlags |= KSPROPERTY_TYPE_SET;
            }
            ntStatus = STATUS_SUCCESS;
            pRequest->ValueSize = sizeof(ULONG);
 
            switch (pRequest->PropertyItem->Id)
            {
                case KSPROPERTY_SYNTH_PORTPARAMETERS:
                    if (pRequest->MinorTarget)
                    {
                        *AccessFlags |= KSPROPERTY_TYPE_GET;
                    }
                    else
                    {
                        pRequest->ValueSize = 0;
                        ntStatus = STATUS_INVALID_DEVICE_REQUEST;
                    }
            }
        }
    }
    else
    {
        ntStatus = STATUS_SUCCESS;
        switch(pRequest->PropertyItem->Id)
        {
            case KSPROPERTY_SYNTH_CAPS:
                DPRINT("PropertyHandler_Synth:KSPROPERTY_SYNTH_CAPS");
 
                if (pRequest->Verb & KSPROPERTY_TYPE_SET)
                {
                    ntStatus = STATUS_INVALID_DEVICE_REQUEST;
                }
 
                if (NT_SUCCESS(ntStatus))
                {
                    ntStatus = ValidatePropertyRequest(pRequest, sizeof(SYNTHCAPS), TRUE);
 
                    if (NT_SUCCESS(ntStatus))
                    {
                        SYNTHCAPS *caps = (SYNTHCAPS*)pRequest->Value;
                        int increment;
                        RtlZeroMemory(caps, sizeof(SYNTHCAPS));
                        // XXX Different guids for different instances!
                        //
                        if (pRequest->Node == eSynthNode)
                        {
                            increment = sizeof(wszDescOut) - 2;
                            RtlCopyMemory( caps->Description,wszDescOut,increment);
                            caps->Guid           = CLSID_MiniportDriverDMusUART;
                        }
                        else
                        {
                            increment = sizeof(wszDescIn) - 2;
                            RtlCopyMemory( caps->Description,wszDescIn,increment);
                            caps->Guid           = CLSID_MiniportDriverDMusUARTCapture;
                        }
 
                        caps->Flags              = SYNTH_PC_EXTERNAL;
                        caps->MemorySize         = 0;
                        caps->MaxChannelGroups   = 1;
                        caps->MaxVoices          = 0xFFFFFFFF;
                        caps->MaxAudioChannels   = 0xFFFFFFFF;
 
                        caps->EffectFlags        = 0;
 
                        CMiniportDMusUART *aMiniport;
                        ASSERT(pRequest->MajorTarget);
                        aMiniport = (CMiniportDMusUART *)(PMINIPORTDMUS)(pRequest->MajorTarget);
                        WCHAR wszDesc2[16];
                        int cLen;
                        cLen = swprintf(wszDesc2,L"[%03x]\0",PtrToUlong(aMiniport->m_pPortBase));
 
                        cLen *= sizeof(WCHAR);
                        RtlCopyMemory((WCHAR *)((DWORD_PTR)(caps->Description) + increment),
                                       wszDesc2,
                                       cLen);
 
 
                        pRequest->ValueSize = sizeof(SYNTHCAPS);
                    }
                }
 
                break;
 
             case KSPROPERTY_SYNTH_PORTPARAMETERS:
                DPRINT("PropertyHandler_Synth:KSPROPERTY_SYNTH_PORTPARAMETERS");
    {
                CMiniportDMusUARTStream *aStream;
 
                aStream = (CMiniportDMusUARTStream*)(pRequest->MinorTarget);
                if (aStream)
                {
                    ntStatus = aStream->HandlePortParams(pRequest);
                }
                else
                {
                    ntStatus = STATUS_INVALID_DEVICE_REQUEST;
                }
               }
               break;
 
            case KSPROPERTY_SYNTH_CHANNELGROUPS:
                DPRINT("PropertyHandler_Synth:KSPROPERTY_SYNTH_CHANNELGROUPS");
 
                ntStatus = ValidatePropertyRequest(pRequest, sizeof(ULONG), TRUE);
                if (NT_SUCCESS(ntStatus))
                {
                    *(PULONG)(pRequest->Value) = 1;
                    pRequest->ValueSize = sizeof(ULONG);
                }
                break;
 
            case KSPROPERTY_SYNTH_LATENCYCLOCK:
                DPRINT("PropertyHandler_Synth:KSPROPERTY_SYNTH_LATENCYCLOCK");
 
                if(pRequest->Verb & KSPROPERTY_TYPE_SET)
                {
                    ntStatus = STATUS_INVALID_DEVICE_REQUEST;
                }
                else
                {
                    ntStatus = ValidatePropertyRequest(pRequest, sizeof(ULONGLONG), TRUE);
                    if(NT_SUCCESS(ntStatus))
                    {
                        REFERENCE_TIME rtLatency;
                        CMiniportDMusUARTStream *aStream;
 
                        aStream = (CMiniportDMusUARTStream*)(pRequest->MinorTarget);
                        if(aStream == NULL)
                        {
                            ntStatus = STATUS_INVALID_DEVICE_REQUEST;
                        }
                        else
                        {
                            aStream->m_pMiniport->m_MasterClock->GetTime(&rtLatency);
                            *((PULONGLONG)pRequest->Value) = rtLatency;
                            pRequest->ValueSize = sizeof(ULONGLONG);
                        }
                    }
                }
                break;
 
            default:
                DPRINT("Unhandled property in PropertyHandler_Synth");
                break;
        }
    }
    return ntStatus;
}

ResetHardware()

NTSTATUS ResetHardware

(

PUCHAR

portBase

)

Definition at line 602 of file miniport_dmus.cpp.

{
    PAGED_CODE();
 
    return WriteMPU(portBase,COMMAND,MPU401_CMD_UART);
}

Referenced by CMiniportDMusUART::InitializeHardware().

SnapTimeStamp()

SnapTimeStamp	(	PINTERRUPTSYNC	InterruptSync,
		PVOID	pStream
	)

Definition at line 983 of file miniport_dmus.cpp.

{
    CMiniportDMusUARTStream *pMPStream = (CMiniportDMusUARTStream *)pStream;
 
    //  cache the timestamp
    pMPStream->m_SnapshotTimeStamp = pMPStream->m_pMiniport->m_InputTimeStamp;
 
    //  if the window is closed, zero the timestamp
    if (pMPStream->m_pMiniport->m_MPUInputBufferHead ==
        pMPStream->m_pMiniport->m_MPUInputBufferTail)
    {
        pMPStream->m_pMiniport->m_InputTimeStamp = 0;
    }
 
    return STATUS_SUCCESS;
}

SynchronizedDMusMPUWrite() [1/2]

NTSTATUS NTAPI SynchronizedDMusMPUWrite	(	IN PINTERRUPTSYNC	InterruptSync,
		IN PVOID	syncWriteContext
	)

Definition at line 829 of file miniport_dmus.cpp.

{
    PSYNCWRITECONTEXT context;
    context = (PSYNCWRITECONTEXT)syncWriteContext;
    ASSERT(context->Miniport);
    ASSERT(context->PortBase);
    ASSERT(context->BufferAddress);
    ASSERT(context->Length);
    ASSERT(context->BytesRead);
 
    PUCHAR  pChar = PUCHAR(context->BufferAddress);
    NTSTATUS ntStatus; // , readStatus
    ntStatus = STATUS_SUCCESS;
    //
    // while we're not there yet, and
    // while we don't have to wait on an aligned byte (including 0)
    // (we never wait on a byte.  Better to come back later)
    /*readStatus = */ DMusMPUInterruptServiceRoutine(InterruptSync,PVOID(context->Miniport));
    while (  (*(context->BytesRead) < context->Length)
          && (  TryMPU(context->PortBase)
             || (*(context->BytesRead)%3)
          )  )
    {
        ntStatus = WriteMPU(context->PortBase,DATA,*pChar);
        if (NT_SUCCESS(ntStatus))
        {
            pChar++;
            *(context->BytesRead) = *(context->BytesRead) + 1;
//            readStatus = DMusMPUInterruptServiceRoutine(InterruptSync,PVOID(context->Miniport));
        }
        else
        {
            DPRINT("SynchronizedDMusMPUWrite failed (0x%08x)",ntStatus);
            break;
        }
    }
    /*readStatus = */ DMusMPUInterruptServiceRoutine(InterruptSync,PVOID(context->Miniport));
    return ntStatus;
}

SynchronizedDMusMPUWrite() [2/2]

NTSTATUS NTAPI SynchronizedDMusMPUWrite	(	PINTERRUPTSYNC	InterruptSync,
		PVOID	syncWriteContext
	)

TryMPU()

BOOLEAN TryMPU

(

IN PUCHAR

PortBase

)

Definition at line 885 of file miniport_dmus.cpp.

{
    BOOLEAN success;
    USHORT  numPolls;
    UCHAR   status;
 
    DPRINT("TryMPU");
    numPolls = 0;
 
    while (numPolls < kMPUPollTimeout)
    {
        status = READ_PORT_UCHAR(PortBase + MPU401_REG_STATUS);
 
        if (UartFifoOkForWrite(status)) // Is this a good time to write data?
        {
            break;
        }
        numPolls++;
    }
    if (numPolls >= kMPUPollTimeout)
    {
        success = FALSE;
        DPRINT("TryMPU failed");
    }
    else
    {
        success = TRUE;
    }
 
    return success;
}

Referenced by SynchronizedDMusMPUWrite().

ValidatePropertyRequest()

NTSTATUS ValidatePropertyRequest	(	IN PPCPROPERTY_REQUEST	pRequest,
		IN ULONG	ulValueSize,
		IN BOOLEAN	fValueRequired
	)

Definition at line 2616 of file miniport_dmus.cpp.

{
    NTSTATUS    ntStatus;
 
    if (pRequest->ValueSize >= ulValueSize)
    {
        if (fValueRequired && NULL == pRequest->Value)
        {
            ntStatus = STATUS_INVALID_PARAMETER;
        }
        else
        {
            ntStatus = STATUS_SUCCESS;
        }
    }
    else  if (0 == pRequest->ValueSize)
    {
        ntStatus = STATUS_BUFFER_OVERFLOW;
    }
    else
    {
        ntStatus = STATUS_BUFFER_TOO_SMALL;
    }
 
    if (STATUS_BUFFER_OVERFLOW == ntStatus)
    {
        pRequest->ValueSize = ulValueSize;
    }
    else
    {
        pRequest->ValueSize = 0;
    }
 
    return ntStatus;
} // ValidatePropertyRequest

Referenced by CMiniportDMusUARTStream::HandlePortParams().

WriteMPU()

NTSTATUS WriteMPU	(	IN PUCHAR	PortBase,
		IN BOOLEAN	IsCommand,
		IN UCHAR	Value
	)

Definition at line 930 of file miniport_dmus.cpp.

{
    DPRINT("WriteMPU");
    NTSTATUS ntStatus = STATUS_IO_DEVICE_ERROR;
 
    if (!PortBase)
    {
        DPRINT("O: PortBase is zero\n");
        return ntStatus;
    }
    PUCHAR deviceAddr = PortBase + MPU401_REG_DATA;
 
    if (IsCommand)
    {
        deviceAddr = PortBase + MPU401_REG_COMMAND;
    }
 
    ULONGLONG startTime = PcGetTimeInterval(0);
 
    while (PcGetTimeInterval(startTime) < GTI_MILLISECONDS(50))
    {
        UCHAR status
        = READ_PORT_UCHAR(PortBase + MPU401_REG_STATUS);
 
        if (UartFifoOkForWrite(status)) // Is this a good time to write data?
        {                               // yep (Jon comment)
            WRITE_PORT_UCHAR(deviceAddr,Value);
            DPRINT("WriteMPU emitted 0x%02x",Value);
            ntStatus = STATUS_SUCCESS;
            break;
        }
    }
    return ntStatus;
}

Referenced by InitMPU(), ResetHardware(), and SynchronizedDMusMPUWrite().

Variable Documentation

COMMAND

const BOOLEAN COMMAND = TRUE

Definition at line 49 of file miniport_dmus.cpp.

DATA

const BOOLEAN DATA = FALSE

Definition at line 50 of file miniport_dmus.cpp.

kMPUInputBufferSize

const ULONG kMPUInputBufferSize = 128

Definition at line 51 of file miniport_dmus.cpp.

Referenced by DMusMPUInterruptServiceRoutine().

MiniportCategories

GUID MiniportCategories[]

static

Initial value:

=
{
    {STATICGUIDOF(KSCATEGORY_AUDIO)},
    {STATICGUIDOF(KSCATEGORY_RENDER)},
    {STATICGUIDOF(KSCATEGORY_CAPTURE)}
}

Definition at line 561 of file miniport_dmus.cpp.

MiniportConnections

PCCONNECTION_DESCRIPTOR MiniportConnections[]

static

Initial value:

=
{  
   
    { PCFILTER_NODE, eFilterInputPinLeg,     PCFILTER_NODE, eBridgeOutputPin }      
  , { PCFILTER_NODE, eFilterInputPinDM,      eSynthNode,    KSNODEPIN_STANDARD_IN } 
  , { eSynthNode,    KSNODEPIN_STANDARD_OUT, PCFILTER_NODE, eBridgeOutputPin }      
  , { PCFILTER_NODE, eBridgeInputPin,        eInputNode,    KSNODEPIN_STANDARD_IN } 
  , { eInputNode,    KSNODEPIN_STANDARD_OUT, PCFILTER_NODE, eFilterOutputPin }      
}

Definition at line 545 of file miniport_dmus.cpp.

MiniportFilterDescriptor

PCFILTER_DESCRIPTOR MiniportFilterDescriptor

static

Initial value:

=
{
    0,                                  
    NULL,                               
    sizeof(PCPIN_DESCRIPTOR),           
    SIZEOF_ARRAY(MiniportPins),         
    MiniportPins,                       
    sizeof(PCNODE_DESCRIPTOR),          
    SIZEOF_ARRAY(MiniportNodes),        
    MiniportNodes,                      
    SIZEOF_ARRAY(MiniportConnections),  
    MiniportConnections,                
    SIZEOF_ARRAY(MiniportCategories),   
    MiniportCategories                  
}

Definition at line 574 of file miniport_dmus.cpp.

Referenced by CMiniportDMusUART::GetDescription(), and STDMETHODIMP_().

MiniportNodes

PCNODE_DESCRIPTOR MiniportNodes[]

static

Initial value:

=
{
 
    , CONST_PCNODE_DESCRIPTOR_AUTO(KSNODETYPE_SYNTHESIZER, AutomationSynth2)
}

Definition at line 520 of file miniport_dmus.cpp.

MiniportPins

PCPIN_DESCRIPTOR MiniportPins[]

static

Definition at line 423 of file miniport_dmus.cpp.

Referenced by CMiniport::BuildDataRangeInformation().

PinDataRangePointersBridge

PKSDATARANGE PinDataRangePointersBridge[]

static

Initial value:

=
{
    &PinDataRangesBridge[0]
}

Definition at line 367 of file miniport_dmus.cpp.

PinDataRangePointersStreamCombined

PKSDATARANGE PinDataRangePointersStreamCombined[]

static

Initial value:

=
{
 
   ,PKSDATARANGE(&PinDataRangesStreamDMusic)
}

Definition at line 333 of file miniport_dmus.cpp.

PinDataRangePointersStreamDMusic

PKSDATARANGE PinDataRangePointersStreamDMusic[]

static

Initial value:

=
{
 
}

Definition at line 328 of file miniport_dmus.cpp.

PinDataRangePointersStreamLegacy

PKSDATARANGE PinDataRangePointersStreamLegacy[]

static

Initial value:

=
{
 
}

Definition at line 323 of file miniport_dmus.cpp.

PinDataRangesBridge

KSDATARANGE PinDataRangesBridge[]

static

Initial value:

=
{
    {
        {
            sizeof(KSDATARANGE),
            0,
            0,
            0,
            {STATICGUIDOF(KSDATAFORMAT_TYPE_MUSIC)},
            {STATICGUIDOF(KSDATAFORMAT_SUBTYPE_MIDI_BUS)},
            {STATICGUIDOF(KSDATAFORMAT_SPECIFIER_NONE)}
        }
   }
}

Definition at line 345 of file miniport_dmus.cpp.

PinDataRangesStreamDMusic

KSDATARANGE_MUSIC PinDataRangesStreamDMusic

static

Initial value:

=
{
    {
        {
            sizeof(KSDATARANGE_MUSIC),
            0,
            0,
            0,
            {STATICGUIDOF(KSDATAFORMAT_TYPE_MUSIC)},
            {STATICGUIDOF(KSDATAFORMAT_SUBTYPE_DIRECTMUSIC)},
            {STATICGUIDOF(KSDATAFORMAT_SPECIFIER_NONE)}
        }
    },
    {STATICGUIDOF(KSMUSIC_TECHNOLOGY_PORT)},
    0,
    0,
    0xFFFF
}

Definition at line 295 of file miniport_dmus.cpp.

PinDataRangesStreamLegacy

KSDATARANGE_MUSIC PinDataRangesStreamLegacy

static

Initial value:

=
{
    {
        {
            sizeof(KSDATARANGE_MUSIC),
            0,
            0,
            0,
            {STATICGUIDOF(KSDATAFORMAT_TYPE_MUSIC)},
            {STATICGUIDOF(KSDATAFORMAT_SUBTYPE_MIDI)},
            {STATICGUIDOF(KSDATAFORMAT_SPECIFIER_NONE)}
        }
    },
    {STATICGUIDOF(KSMUSIC_TECHNOLOGY_PORT)},
    0,
    0,
    0xFFFF
}

Definition at line 276 of file miniport_dmus.cpp.

SynthProperties

PCPROPERTY_ITEM SynthProperties[]

static

Definition at line 379 of file miniport_dmus.cpp.

wszDescIn

const WCHAR wszDescIn[] = L"DMusic MPU-401 In "

Definition at line 2425 of file miniport_dmus.cpp.

wszDescOut

const WCHAR wszDescOut[] = L"DMusic MPU-401 Out "

Definition at line 2424 of file miniport_dmus.cpp.