+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS
- * FILE: drivers/multimedia/portcls/helpers/ResourceList.c
- * PURPOSE: Port Class driver / ResourceList implementation
- * PROGRAMMER: Andrew Greenwood
- *
- * HISTORY:
- * 27 Jan 07 Created
- */
-
-#include "private.h"
-#include <portcls.h>
-#include <stdunk.h>
-
-typedef struct CResourceList
-{
- union
- {
- IUnknown IUnknown;
- IResourceList IResourceList;
- };
-
- LONG m_ref_count;
- PUNKNOWN m_outer_unknown;
-
- PCM_RESOURCE_LIST translated_resources;
- PCM_RESOURCE_LIST untranslated_resources;
-} CResourceList;
-
-
-/*
- Basic IUnknown methods
-*/
-
-NTSTATUS
-STDMETHODCALLTYPE
-ResourceList_QueryInterface(
- IResourceList* this_container,
- IN REFIID refiid,
- OUT PVOID* output)
-{
- /* TODO */
- return STATUS_SUCCESS;
-}
-
-ULONG
-STDMETHODCALLTYPE
-ResourceList_AddRef(
- IResourceList* this_container)
-{
- struct CUnknown* this = CONTAINING_RECORD(this_container, struct CUnknown, IUnknown);
-
-/* fixme */
-/* ExInterlockedIncrement(&this->m_ref_count); */
- return this->m_ref_count;
-}
-
-ULONG
-STDMETHODCALLTYPE
-ResourceList_Release(
- IResourceList* this_container)
-{
- struct CUnknown* this = CONTAINING_RECORD(this_container, struct CUnknown, IUnknown);
-
-/* fixme */
-/* ExInterlockedDecrement(&this->m_ref_count); */
-
- if ( this->m_ref_count == 0 )
- {
- ExFreePool(this);
- return 0;
- }
-
- return this->m_ref_count;
-}
-
-
-/*
- IResourceList methods
-*/
-
-ULONG
-STDMETHODCALLTYPE
-ResourceList_NumberOfEntries(IResourceList* this_container)
-{
- return 0;
-}
-
-ULONG
-STDMETHODCALLTYPE
-ResourceList_NumberOfEntriesOfType(
- IResourceList* this_container,
- IN CM_RESOURCE_TYPE type)
-{
- /* I guess the translated and untranslated lists will be same length? */
-
- CResourceList* this = CONTAINING_RECORD(this_container, CResourceList, IResourceList);
- ULONG index, count = 0;
-
- for ( index = 0; index < this->translated_resources->Count; index ++ )
- {
- PCM_FULL_RESOURCE_DESCRIPTOR full_desc = &this->translated_resources->List[index];
- ULONG sub_index;
-
- for ( sub_index = 0; sub_index < full_desc->PartialResourceList.Count; sub_index ++ )
- {
- PCM_PARTIAL_RESOURCE_DESCRIPTOR partial_desc;
- partial_desc = &full_desc->PartialResourceList.PartialDescriptors[sub_index];
-
- if ( partial_desc->Type == type )
- {
- /* Yay! Finally found one that matches! */
- count ++;
- }
- }
- }
-
- DPRINT("Found %d\n", count);
- return count;
-}
-
-PCM_PARTIAL_RESOURCE_DESCRIPTOR
-STDMETHODCALLTYPE
-ResourceList_FindTranslatedEntry(
- IResourceList* this_container,
- IN CM_RESOURCE_TYPE Type,
- IN ULONG Index)
-{
- return NULL;
-}
-
-PCM_PARTIAL_RESOURCE_DESCRIPTOR
-STDMETHODCALLTYPE
-ResourceList_FindUntranslatedEntry(
- IResourceList* this_container,
- IN CM_RESOURCE_TYPE Type,
- IN ULONG Index)
-{
- return NULL;
-}
-
-NTSTATUS
-STDMETHODCALLTYPE
-ResourceList_AddEntry(
- IResourceList* this_container,
- IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Translated,
- IN PCM_PARTIAL_RESOURCE_DESCRIPTOR Untranslated)
-{
- return STATUS_SUCCESS;
-}
-
-NTSTATUS
-STDMETHODCALLTYPE
-ResourceList_AddEntryFromParent(
- IResourceList* this_container,
- IN IResourceList* Parent,
- IN CM_RESOURCE_TYPE Type,
- IN ULONG Index)
-{
- return STATUS_SUCCESS;
-}
-
-PCM_RESOURCE_LIST
-STDMETHODCALLTYPE
-ResourceList_TranslatedList(
- IResourceList* this_container)
-{
- return NULL;
-}
-
-PCM_RESOURCE_LIST
-STDMETHODCALLTYPE
-ResourceList_UntranslatedList(
- IResourceList* this_container)
-{
- return NULL;
-}
-
-
-/*
- ResourceList V-Table
-*/
-static const IResourceListVtbl ResourceListVtbl =
-{
- /* IUnknown */
- ResourceList_QueryInterface,
- ResourceList_AddRef,
- ResourceList_Release,
-
- /* IResourceList */
- ResourceList_NumberOfEntries,
- ResourceList_NumberOfEntriesOfType,
- ResourceList_FindTranslatedEntry,
- ResourceList_FindUntranslatedEntry,
- ResourceList_AddEntry,
- ResourceList_AddEntryFromParent,
- ResourceList_TranslatedList,
- ResourceList_UntranslatedList
-};
-
-
-/*
- Factory for creating a resource list
-*/
-PORTCLASSAPI NTSTATUS NTAPI
-PcNewResourceList(
- OUT PRESOURCELIST* OutResourceList,
- IN PUNKNOWN OuterUnknown OPTIONAL,
- IN POOL_TYPE PoolType,
- IN PCM_RESOURCE_LIST TranslatedResources,
- IN PCM_RESOURCE_LIST UntranslatedResources)
-{
- IResourceList* new_list = NULL;
- CResourceList* this = NULL;
-
- /* TODO: Validate parameters */
-
- DPRINT("PcNewResourceList\n");
-
- new_list = ExAllocatePoolWithTag(sizeof(IResourceList), PoolType, TAG_PORTCLASS);
-
- if ( ! new_list )
- {
- DPRINT("ExAllocatePoolWithTag failed\n");
- return STATUS_INSUFFICIENT_RESOURCES;
- }
-
- /* Obtain our private data */
- this = CONTAINING_RECORD(new_list, CResourceList, IResourceList);
-
- ASSERT(this);
-
- /* Initialize */
- this->m_outer_unknown = OuterUnknown;
- this->translated_resources = TranslatedResources;
- this->untranslated_resources = UntranslatedResources;
-
- /* Increment our usage count and set the pointer to this object */
- *OutResourceList = new_list;
- ResourceListVtbl.AddRef(*OutResourceList);
-
- return STATUS_SUCCESS;
-}
-
-PORTCLASSAPI NTSTATUS NTAPI
-PcNewResourceSublist(
- OUT PRESOURCELIST* OutResourceList,
- IN PUNKNOWN OuterUnknown OPTIONAL,
- IN POOL_TYPE PoolType,
- IN PRESOURCELIST ParentList,
- IN ULONG MaximumEntries)
-{
- return STATUS_UNSUCCESSFUL;
-}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/api.c
+ * FILE: drivers/wdm/audio/backpln/portcls/api.cpp
* PURPOSE: Port Class driver / DriverEntry and IRP handlers
* PROGRAMMER: Andrew Greenwood
- *
+ * Johannes Anderwald
* HISTORY:
* 27 Jan 07 Created
*/
-#include "private.h"
-
-/*
- This is called from DriverEntry so that PortCls can take care of some
- IRPs and map some others to the main KS driver. In most cases this will
- be the first function called by an audio driver.
-
- First 2 parameters are from DriverEntry.
-
- The AddDevice parameter is a driver-supplied pointer to a function which
- typically then calls PcAddAdapterDevice (see below.)
-*/
-NTSTATUS NTAPI
+#include "private.hpp"
+
+//
+// This is called from DriverEntry so that PortCls can take care of some
+// IRPs and map some others to the main KS driver. In most cases this will
+// be the first function called by an audio driver.
+//
+// First 2 parameters are from DriverEntry.
+//
+// The AddDevice parameter is a driver-supplied pointer to a function which
+// typically then calls PcAddAdapterDevice (see below.)
+//
+NTSTATUS
+NTAPI
PcInitializeAdapterDriver(
IN PDRIVER_OBJECT DriverObject,
IN PUNICODE_STRING RegistryPathName,
IN PDRIVER_ADD_DEVICE AddDevice)
{
- /*
- (* = implement here, otherwise KS default)
- IRP_MJ_CLOSE
- * IRP_MJ_CREATE
- IRP_MJ_DEVICE_CONTROL
- IRP_MJ_FLUSH_BUFFERS
- * IRP_MJ_PNP
- * IRP_MJ_POWER
- IRP_MJ_QUERY_SECURITY
- IRP_MJ_READ
- IRP_MJ_SET_SECURITY
- * IRP_MJ_SYSTEM_CONTROL
- IRP_MJ_WRITE
- */
-
- //NTSTATUS status;
- //ULONG i;
-
DPRINT1("PcInitializeAdapterDriver\n");
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
- /* Our IRP handlers */
+ // Our IRP handlers
DPRINT1("Setting IRP handlers\n");
DriverObject->MajorFunction[IRP_MJ_CREATE] = PcDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_PNP] = PcDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SYSTEM_CONTROL] = PcDispatchIrp;
DriverObject->MajorFunction[IRP_MJ_SHUTDOWN] = PcDispatchIrp;
- /* The driver-supplied AddDevice */
+ // The driver-supplied AddDevice
DriverObject->DriverExtension->AddDevice = AddDevice;
- /* KS handles these */
+ // KS handles these
DPRINT("Setting KS function handlers\n");
KsSetMajorFunctionHandler(DriverObject, IRP_MJ_CLOSE);
KsSetMajorFunctionHandler(DriverObject, IRP_MJ_DEVICE_CONTROL);
return STATUS_SUCCESS;
}
-/*
- Typically called by a driver's AddDevice function, which is set when
- calling PcInitializeAdapterDriver. This performs some common driver
- operations, such as creating a device extension.
-
- The StartDevice parameter is a driver-supplied function which gets
- called in response to IRP_MJ_PNP / IRP_MN_START_DEVICE.
-*/
-NTSTATUS NTAPI
+//
+// Typically called by a driver's AddDevice function, which is set when
+// calling PcInitializeAdapterDriver. This performs some common driver
+// operations, such as creating a device extension.
+//
+// The StartDevice parameter is a driver-supplied function which gets
+// called in response to IRP_MJ_PNP / IRP_MN_START_DEVICE.
+//
+NTSTATUS
+NTAPI
PcAddAdapterDevice(
IN PDRIVER_OBJECT DriverObject,
IN PDEVICE_OBJECT PhysicalDeviceObject,
PPCLASS_DEVICE_EXTENSION portcls_ext = NULL;
DPRINT1("PcAddAdapterDevice called\n");
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
if (!DriverObject || !PhysicalDeviceObject || !StartDevice)
{
return STATUS_INVALID_PARAMETER;
}
- /* check if the DeviceExtensionSize is provided */
+ // check if the DeviceExtensionSize is provided
if ( DeviceExtensionSize < PORT_CLASS_DEVICE_EXTENSION_SIZE )
{
- /* driver does not need a device extension */
+ // driver does not need a device extension
if ( DeviceExtensionSize != 0 )
{
- /* DeviceExtensionSize must be zero*/
+ // DeviceExtensionSize must be zero
return STATUS_INVALID_PARAMETER;
}
- /* set size to our extension size */
+ // set size to our extension size
DeviceExtensionSize = PORT_CLASS_DEVICE_EXTENSION_SIZE;
}
- /* create the device */
+ // create the device
status = IoCreateDevice(DriverObject,
DeviceExtensionSize,
NULL,
return status;
}
- /* Obtain the new device extension */
+ // Obtain the new device extension
portcls_ext = (PPCLASS_DEVICE_EXTENSION) fdo->DeviceExtension;
- /* initialize the device extension */
+ // initialize the device extension
RtlZeroMemory(portcls_ext, DeviceExtensionSize);
- /* allocate create item */
- portcls_ext->CreateItems = AllocateItem(NonPagedPool, MaxObjects * sizeof(KSOBJECT_CREATE_ITEM), TAG_PORTCLASS);
+ // allocate create item
+ portcls_ext->CreateItems = (PKSOBJECT_CREATE_ITEM)AllocateItem(NonPagedPool, MaxObjects * sizeof(KSOBJECT_CREATE_ITEM), TAG_PORTCLASS);
if (!portcls_ext->CreateItems)
{
- /* not enough resources */
+ // not enough resources
status = STATUS_INSUFFICIENT_RESOURCES;
goto cleanup;
}
- /* store max subdevice count */
+ // store max subdevice count
portcls_ext->MaxSubDevices = MaxObjects;
- /* store the physical device object */
+ // store the physical device object
portcls_ext->PhysicalDeviceObject = PhysicalDeviceObject;
- /* set up the start device function */
+ // set up the start device function
portcls_ext->StartDevice = StartDevice;
- /* prepare the subdevice list */
+ // prepare the subdevice list
InitializeListHead(&portcls_ext->SubDeviceList);
- /* prepare the physical connection list */
+ // prepare the physical connection list
InitializeListHead(&portcls_ext->PhysicalConnectionList);
- /* initialize timer lock */
+ // initialize timer lock
KeInitializeSpinLock(&portcls_ext->TimerListLock);
- /* initialize timer list */
+ // initialize timer list
InitializeListHead(&portcls_ext->TimerList);
- /* initialize io timer */
+ // initialize io timer
IoInitializeTimer(fdo, PcIoTimerRoutine, NULL);
- /* start the io timer */
+ // start the io timer
IoStartTimer(fdo);
- /* set io flags */
+ // set io flags
fdo->Flags |= DO_DIRECT_IO | DO_POWER_PAGABLE;
- /* clear initializing flag */
+ // clear initializing flag
fdo->Flags &= ~ DO_DEVICE_INITIALIZING;
- /* allocate the device header */
+ // allocate the device header
status = KsAllocateDeviceHeader(&portcls_ext->KsDeviceHeader, MaxObjects, portcls_ext->CreateItems);
- /* did we succeed */
+ // did we succeed
if (!NT_SUCCESS(status))
{
goto cleanup;
}
- /* attach device to device stack */
+ // attach device to device stack
PrevDeviceObject = IoAttachDeviceToDeviceStack(fdo, PhysicalDeviceObject);
- /* did we succeed */
+ // did we succeed
if (PrevDeviceObject)
{
- /* store the device object in the device header */
+ // store the device object in the device header
//KsSetDevicePnpBaseObject(portcls_ext->KsDeviceHeader, fdo, PrevDeviceObject);
portcls_ext->PrevDeviceObject = PrevDeviceObject;
}
else
{
- /* return error code */
+ // return error code
status = STATUS_UNSUCCESSFUL;
goto cleanup;
}
- /* register shutdown notification */
+ // register shutdown notification
IoRegisterShutdownNotification(PhysicalDeviceObject);
return status;
if (portcls_ext->KsDeviceHeader)
{
- /* free the device header */
+ // free the device header
KsFreeDeviceHeader(portcls_ext->KsDeviceHeader);
}
if (portcls_ext->CreateItems)
{
- /* free previously allocated create items */
+ // free previously allocated create items
FreeItem(portcls_ext->CreateItems, TAG_PORTCLASS);
}
- /* delete created fdo */
+ // delete created fdo
IoDeleteDevice(fdo);
PSYMBOLICLINK_ENTRY SymEntry;
DPRINT1("PcRegisterSubdevice DeviceObject %p Name %S Unknown %p\n", DeviceObject, Name, Unknown);
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
- /* check if all parameters are valid */
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+
+ // check if all parameters are valid
if (!DeviceObject || !Name || !Unknown)
{
DPRINT("PcRegisterSubdevice invalid parameter\n");
return STATUS_INVALID_PARAMETER;
}
- /* get device extension */
+ // get device extension
DeviceExt = (PPCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
if (!DeviceExt)
{
- /* should not happen */
+ // should not happen
KeBugCheck(0);
return STATUS_UNSUCCESSFUL;
}
- /* look up our undocumented interface */
- Status = Unknown->lpVtbl->QueryInterface(Unknown, &IID_ISubdevice, (LPVOID)&SubDevice);
+ // look up our undocumented interface
+ Status = Unknown->QueryInterface(IID_ISubdevice, (LPVOID*)&SubDevice);
if (!NT_SUCCESS(Status))
{
DPRINT1("No ISubdevice interface\n");
- /* the provided port driver doesnt support ISubdevice */
+ // the provided port driver doesnt support ISubdevice
return STATUS_INVALID_PARAMETER;
}
- /* get the subdevice descriptor */
- Status = SubDevice->lpVtbl->GetDescriptor(SubDevice, &SubDeviceDescriptor);
+ // get the subdevice descriptor
+ Status = SubDevice->GetDescriptor(&SubDeviceDescriptor);
if (!NT_SUCCESS(Status))
{
DPRINT1("Failed to get subdevice descriptor %x\n", Status);
- SubDevice->lpVtbl->Release(SubDevice);
+ SubDevice->Release();
return STATUS_UNSUCCESSFUL;
}
- /* allocate subdevice entry */
- Entry = AllocateItem(NonPagedPool, sizeof(SUBDEVICE_ENTRY), TAG_PORTCLASS);
+ // allocate subdevice entry
+ Entry = (PSUBDEVICE_ENTRY)AllocateItem(NonPagedPool, sizeof(SUBDEVICE_ENTRY), TAG_PORTCLASS);
if (!Entry)
{
- /* Insufficient memory */
- SubDevice->lpVtbl->Release(SubDevice);
+ // Insufficient memory
+ SubDevice->Release();
return STATUS_INSUFFICIENT_RESOURCES;
}
- /* add an create item to the device header */
+ // add an create item to the device header
Status = KsAddObjectCreateItemToDeviceHeader(DeviceExt->KsDeviceHeader, PcCreateItemDispatch, (PVOID)SubDevice, Name, NULL);
if (!NT_SUCCESS(Status))
{
- /* failed to attach */
- SubDevice->lpVtbl->Release(SubDevice);
+ // failed to attach
+ SubDevice->Release();
FreeItem(Entry, TAG_PORTCLASS);
DPRINT1("KsAddObjectCreateItemToDeviceHeader failed with %x\n", Status);
return Status;
}
- /* initialize reference string */
+ // initialize reference string
RtlInitUnicodeString(&RefName, Name);
- /* initialize subdevice entry */
+ // initialize subdevice entry
Entry->SubDevice = SubDevice;
RtlInitUnicodeString(&Entry->Name, Name);
InitializeListHead(&Entry->SymbolicLinkList);
- /* store subdevice entry */
+ // store subdevice entry
InsertTailList(&DeviceExt->SubDeviceList, &Entry->Entry);
for(Index = 0; Index < SubDeviceDescriptor->InterfaceCount; Index++)
{
- /* FIXME
- * check if reference string with that name already exists
- */
+ // FIXME
+ // check if reference string with that name already exists
+
Status = IoRegisterDeviceInterface(DeviceExt->PhysicalDeviceObject,
&SubDeviceDescriptor->Interfaces[Index],
&RefName,
if (NT_SUCCESS(Status))
{
- /* activate device interface */
+ // activate device interface
IoSetDeviceInterfaceState(&SymbolicLinkName, TRUE);
- /* allocate symbolic link entry */
- SymEntry = AllocateItem(NonPagedPool, sizeof(SYMBOLICLINK_ENTRY), TAG_PORTCLASS);
+ // allocate symbolic link entry
+ SymEntry = (PSYMBOLICLINK_ENTRY)AllocateItem(NonPagedPool, sizeof(SYMBOLICLINK_ENTRY), TAG_PORTCLASS);
if (SymEntry)
{
- /* initialize symbolic link item */
+ // initialize symbolic link item
RtlInitUnicodeString(&SymEntry->SymbolicLink, SymbolicLinkName.Buffer);
- /* store item */
+ // store item
InsertTailList(&Entry->SymbolicLinkList, &SymEntry->Entry);
}
else
{
- /* allocating failed */
+ // allocating failed
RtlFreeUnicodeString(&SymbolicLinkName);
}
}
}
- /* release SubDevice reference */
- SubDevice->lpVtbl->Release(SubDevice);
+ // release SubDevice reference
+ SubDevice->Release();
return STATUS_SUCCESS;
}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/api.c
+ * FILE: drivers/wdm/audio/backpln/portcls/api.cpp
* PURPOSE: Port api functions
* PROGRAMMER: Johannes Anderwald
*/
-#include "private.h"
+#include "private.hpp"
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcGetDeviceProperty(
{
PPCLASS_DEVICE_EXTENSION DeviceExtension;
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
DeviceExtension = (PPCLASS_DEVICE_EXTENSION)((PDEVICE_OBJECT)DeviceObject)->DeviceExtension;
return IoGetDeviceProperty(DeviceExtension->PhysicalDeviceObject, DeviceProperty, BufferLength, PropertyBuffer, ResultLength);
}
-/*
- * @implemented
- */
ULONGLONG
NTAPI
PcGetTimeInterval(
return (CurrentTime.QuadPart - Since);
}
-/*
- * @implemented
- */
-
VOID
NTAPI
PcIoTimerRoutine(
KeReleaseSpinLock(&DeviceExtension->TimerListLock, OldIrql);
}
-/*
- * @implemented
- */
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
PcRegisterIoTimeout(
IN PDEVICE_OBJECT pDeviceObject,
IN PIO_TIMER_ROUTINE pTimerRoutine,
BOOLEAN bFound;
PPCLASS_DEVICE_EXTENSION DeviceExtension;
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
if (!pDeviceObject || !pDeviceObject->DeviceExtension)
return STATUS_INVALID_PARAMETER;
DeviceExtension = (PPCLASS_DEVICE_EXTENSION)pDeviceObject->DeviceExtension;
- TimerContext = AllocateItem(NonPagedPool, sizeof(TIMER_CONTEXT), TAG_PORTCLASS);
+ TimerContext = (PTIMER_CONTEXT)AllocateItem(NonPagedPool, sizeof(TIMER_CONTEXT), TAG_PORTCLASS);
if (!TimerContext)
{
DPRINT1("Failed to allocate memory\n");
return Status;
}
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcUnregisterIoTimeout(
BOOLEAN bFound;
PPCLASS_DEVICE_EXTENSION DeviceExtension;
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
if (!pDeviceObject || !pDeviceObject->DeviceExtension)
return STATUS_INVALID_PARAMETER;
}
-/*
- * @implemented
- */
+
NTSTATUS
NTAPI
PcCompletePendingPropertyRequest(
IN PPCPROPERTY_REQUEST PropertyRequest,
IN NTSTATUS NtStatus)
{
- /* sanity checks */
- ASSERT_IRQL(DISPATCH_LEVEL);
+ // sanity checks
+ PC_ASSERT_IRQL(DISPATCH_LEVEL);
- if (!PropertyRequest)
+ if (!PropertyRequest || !PropertyRequest->Irp || NtStatus == STATUS_PENDING)
return STATUS_INVALID_PARAMETER;
- ASSERT(PropertyRequest->Irp);
- ASSERT(NtStatus != STATUS_PENDING);
-
- /* set the final status code */
+ // set the final status code
PropertyRequest->Irp->IoStatus.Status = NtStatus;
- /* complete the irp */
+ // complete the irp
IoCompleteRequest(PropertyRequest->Irp, IO_SOUND_INCREMENT);
- /* free the property request */
+ // free the property request
ExFreePool(PropertyRequest);
- /* return success */
+ // return success
return STATUS_SUCCESS;
}
-
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcDmaMasterDescription(
return STATUS_SUCCESS;
}
-/*
- * @implemented
- */
+
NTSTATUS
NTAPI
PcDmaSlaveDescription(
*/
-#include "private.h"
+#include "private.hpp"
-typedef struct
-{
- IUnregisterPhysicalConnectionVtbl *lpVtbl;
- LONG ref;
+extern
+"C"
+NTSYSAPI
+BOOLEAN
+NTAPI
+RtlCreateUnicodeString(
+ PUNICODE_STRING DestinationString,
+ PCWSTR SourceString
+);
-}IUnregisterPhysicalConnectionImpl;
-NTSTATUS
-NTAPI
-IUnregisterPhysicalConnection_fnQueryInterface(
- IUnregisterPhysicalConnection* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
+class CUnregisterPhysicalConnection : public IUnregisterPhysicalConnection
{
- IUnregisterPhysicalConnectionImpl * This = (IUnregisterPhysicalConnectionImpl*)iface;
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
- if (IsEqualGUIDAligned(refiid, &IID_IUnregisterPhysicalConnection) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
+ STDMETHODIMP_(ULONG) AddRef()
{
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
}
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
- return STATUS_UNSUCCESSFUL;
-}
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IUnregisterPhysicalConnection;
-ULONG
-NTAPI
-IUnregisterPhysicalConnection_fnAddRef(
- IUnregisterPhysicalConnection* iface)
-{
- IUnregisterPhysicalConnectionImpl * This = (IUnregisterPhysicalConnectionImpl*)iface;
+ CUnregisterPhysicalConnection(IUnknown *OuterUnknown){}
- return InterlockedIncrement(&This->ref);
-}
+ virtual ~CUnregisterPhysicalConnection(){}
-ULONG
-NTAPI
-IUnregisterPhysicalConnection_fnRelease(
- IUnregisterPhysicalConnection* iface)
-{
- IUnregisterPhysicalConnectionImpl * This = (IUnregisterPhysicalConnectionImpl*)iface;
+protected:
+ LONG m_Ref;
- InterlockedDecrement(&This->ref);
+};
- if (This->ref == 0)
+NTSTATUS
+NTAPI
+CUnregisterPhysicalConnection::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+ if (IsEqualGUIDAligned(refiid, IID_IUnregisterPhysicalConnection) ||
+ IsEqualGUIDAligned(refiid, IID_IUnknown))
{
- FreeItem(This, TAG_PORTCLASS);
- return 0;
+ *Output = PVOID(PUNKNOWN(this));
+
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
}
- return This->ref;
+
+ return STATUS_UNSUCCESSFUL;
}
static
if (FromUnknown)
{
- /* get our private interface */
- Status = FromUnknown->lpVtbl->QueryInterface(FromUnknown, &IID_ISubdevice, (PVOID*)&FromSubDevice);
+ // get our private interface
+ Status = FromUnknown->QueryInterface(IID_ISubdevice, (PVOID*)&FromSubDevice);
if (!NT_SUCCESS(Status))
return STATUS_INVALID_PARAMETER;
}
if (ToUnknown)
{
- Status = ToUnknown->lpVtbl->QueryInterface(ToUnknown, &IID_ISubdevice, (PVOID*)&ToSubDevice);
+ Status = ToUnknown->QueryInterface(IID_ISubdevice, (PVOID*)&ToSubDevice);
if (!NT_SUCCESS(Status))
goto cleanup;
}
Entry = DeviceExt->PhysicalConnectionList.Flink;
bFound = FALSE;
- /* loop physical connection list */
+ // loop physical connection list
while(Entry != &DeviceExt->PhysicalConnectionList)
{
Connection = (PPHYSICAL_CONNECTION)CONTAINING_RECORD(Entry, PHYSICAL_CONNECTION, Entry);
- /* compare current entry */
+ // compare current entry
if (Connection->FromPin == FromPin && Connection->ToPin == ToPin &&
Connection->FromSubDevice == FromSubDevice && Connection->ToSubDevice == ToSubDevice)
{
{
if (!RtlCompareUnicodeString(FromString, &Connection->FromUnicodeString, TRUE))
{
- /* UnregisterPhysicalConnectionFromExternal */
+ // UnregisterPhysicalConnectionFromExternal
bFound = TRUE;
break;
}
{
if (!RtlCompareUnicodeString(ToString, &Connection->ToUnicodeString, TRUE))
{
- /* UnregisterPhysicalConnectionToExternal */
+ // UnregisterPhysicalConnectionToExternal
bFound = TRUE;
break;
}
}
else
{
- /* UnregisterPhysicalConnection */
+ // UnregisterPhysicalConnection
bFound = TRUE;
break;
}
if (!bFound)
{
- /* not found */
+ // not found
Status = STATUS_NOT_FOUND;
goto cleanup;
}
- /* remove list entry */
+ // remove list entry
RemoveEntryList(&Connection->Entry);
- /* release resources */
+ // release resources
if (Connection->FromSubDevice)
- Connection->FromSubDevice->lpVtbl->Release(Connection->FromSubDevice);
+ Connection->FromSubDevice->Release();
if (Connection->ToSubDevice)
- Connection->ToSubDevice->lpVtbl->Release(Connection->ToSubDevice);
+ Connection->ToSubDevice->Release();
if (Connection->FromUnicodeString.Buffer)
RtlFreeUnicodeString(&Connection->FromUnicodeString);
cleanup:
if (FromSubDevice)
- FromSubDevice->lpVtbl->Release(FromSubDevice);
+ FromSubDevice->Release();
if (ToSubDevice)
- ToSubDevice->lpVtbl->Release(ToSubDevice);
+ ToSubDevice->Release();
return Status;
NTSTATUS
NTAPI
-IUnregisterPhysicalConnection_fnUnregisterPhysicalConnection(
- IN IUnregisterPhysicalConnection* iface,
+CUnregisterPhysicalConnection::UnregisterPhysicalConnection(
IN PDEVICE_OBJECT DeviceObject,
IN PUNKNOWN FromUnknown,
IN ULONG FromPin,
NTSTATUS
NTAPI
-IUnregisterPhysicalConnection_fnUnregisterPhysicalConnectionToExternal(
- IN IUnregisterPhysicalConnection* iface,
+CUnregisterPhysicalConnection::UnregisterPhysicalConnectionToExternal(
IN PDEVICE_OBJECT DeviceObject,
IN PUNKNOWN FromUnknown,
IN ULONG FromPin,
NTSTATUS
NTAPI
-IUnregisterPhysicalConnection_fnUnregisterPhysicalConnectionFromExternal(
- IN IUnregisterPhysicalConnection* iface,
+CUnregisterPhysicalConnection::UnregisterPhysicalConnectionFromExternal(
IN PDEVICE_OBJECT DeviceObject,
IN PUNICODE_STRING FromString,
IN ULONG FromPin,
return UnRegisterConnection(DeviceObject, NULL, FromString, FromPin, ToUnknown, NULL, ToPin);
}
-static IUnregisterPhysicalConnectionVtbl vt_IUnregisterPhysicalConnection =
-{
- IUnregisterPhysicalConnection_fnQueryInterface,
- IUnregisterPhysicalConnection_fnAddRef,
- IUnregisterPhysicalConnection_fnRelease,
- IUnregisterPhysicalConnection_fnUnregisterPhysicalConnection,
- IUnregisterPhysicalConnection_fnUnregisterPhysicalConnectionToExternal,
- IUnregisterPhysicalConnection_fnUnregisterPhysicalConnectionFromExternal
-};
-
NTSTATUS
NTAPI
NewIUnregisterPhysicalConnection(
OUT PUNREGISTERPHYSICALCONNECTION *OutConnection)
{
- IUnregisterPhysicalConnectionImpl * This = (IUnregisterPhysicalConnectionImpl*)AllocateItem(NonPagedPool, sizeof(IUnregisterPhysicalConnectionImpl), TAG_PORTCLASS);
- if (!This)
+ CUnregisterPhysicalConnection *new_ptr = new(NonPagedPool, TAG_PORTCLASS) CUnregisterPhysicalConnection(NULL);
+
+ if (!new_ptr)
return STATUS_INSUFFICIENT_RESOURCES;
- This->lpVtbl = &vt_IUnregisterPhysicalConnection;
- This->ref = 1;
- *OutConnection = (PUNREGISTERPHYSICALCONNECTION)&This->lpVtbl;
+ new_ptr->AddRef();
+ *OutConnection = (PUNREGISTERPHYSICALCONNECTION)new_ptr;
return STATUS_SUCCESS;
}
-NTSYSAPI
-BOOLEAN
-NTAPI
-RtlCreateUnicodeString(
- PUNICODE_STRING DestinationString,
- PCWSTR SourceString
-);
-
-static
NTSTATUS
RegisterConnection(
IN OUT PDEVICE_OBJECT DeviceObject,
DeviceExt = (PPCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
- NewConnection = AllocateItem(NonPagedPool, sizeof(PHYSICAL_CONNECTION), TAG_PORTCLASS);
+ NewConnection = (PPHYSICAL_CONNECTION)AllocateItem(NonPagedPool, sizeof(PHYSICAL_CONNECTION), TAG_PORTCLASS);
if (!NewConnection)
{
return STATUS_INSUFFICIENT_RESOURCES;
if (FromUnknown)
{
- Status = FromUnknown->lpVtbl->QueryInterface(FromUnknown, &IID_ISubdevice, (PVOID*)&NewConnection->FromSubDevice);
+ Status = FromUnknown->QueryInterface(IID_ISubdevice, (PVOID*)&NewConnection->FromSubDevice);
if (!NT_SUCCESS(Status))
goto cleanup;
}
if (ToUnknown)
{
- Status = ToUnknown->lpVtbl->QueryInterface(ToUnknown, &IID_ISubdevice, (PVOID*)&NewConnection->ToSubDevice);
+ Status = ToUnknown->QueryInterface(IID_ISubdevice, (PVOID*)&NewConnection->ToSubDevice);
if (!NT_SUCCESS(Status))
goto cleanup;
}
cleanup:
if (NewConnection->FromSubDevice)
- NewConnection->FromSubDevice->lpVtbl->Release(NewConnection->FromSubDevice);
+ NewConnection->FromSubDevice->Release();
if (NewConnection->ToSubDevice)
- NewConnection->ToSubDevice->lpVtbl->Release(NewConnection->ToSubDevice);
+ NewConnection->ToSubDevice->Release();
if (NewConnection->FromUnicodeString.Buffer)
RtlFreeUnicodeString(&NewConnection->FromUnicodeString);
return Status;
}
-/*
- * @implemented
- */
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
PcRegisterPhysicalConnection(
IN PDEVICE_OBJECT DeviceObject,
IN PUNKNOWN FromUnknown,
IN ULONG ToPin)
{
DPRINT("PcRegisterPhysicalConnection\n");
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
if (!DeviceObject || !FromUnknown || !ToUnknown)
return STATUS_INVALID_PARAMETER;
return RegisterConnection(DeviceObject, FromUnknown, NULL, FromPin, ToUnknown, NULL, ToPin);
}
-/*
- * @implemented
- */
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
PcRegisterPhysicalConnectionFromExternal(
IN PDEVICE_OBJECT DeviceObject,
IN PUNICODE_STRING FromString,
IN PUNKNOWN ToUnknown,
IN ULONG ToPin)
{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
if (!DeviceObject || !FromString || !ToUnknown)
return STATUS_INVALID_PARAMETER;
return RegisterConnection(DeviceObject, NULL, FromString, FromPin, ToUnknown, NULL, ToPin);
}
-/*
- * @implemented
- */
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
PcRegisterPhysicalConnectionToExternal(
IN PDEVICE_OBJECT DeviceObject,
IN PUNKNOWN FromUnknown,
IN PUNICODE_STRING ToString,
IN ULONG ToPin)
{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
if (!DeviceObject || !FromUnknown || !ToString)
return STATUS_INVALID_PARAMETER;
*/
-#include "private.h"
+#include "private.hpp"
NTSTATUS
NTAPI
PIO_STACK_LOCATION IoStack;
IIrpTarget * IrpTarget;
- /* get current irp stack */
+ // get current irp stack
IoStack = IoGetCurrentIrpStackLocation(Irp);
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)IoStack->FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->DeviceIoControl(IrpTarget, DeviceObject, Irp);
+ // let IrpTarget handle request
+ return IrpTarget->DeviceIoControl(DeviceObject, Irp);
}
NTSTATUS
PIO_STACK_LOCATION IoStack;
IIrpTarget * IrpTarget;
- /* get current irp stack */
+ // get current irp stack
IoStack = IoGetCurrentIrpStackLocation(Irp);
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)IoStack->FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->Read(IrpTarget, DeviceObject, Irp);
+ // let IrpTarget handle request
+ return IrpTarget->Read(DeviceObject, Irp);
}
NTSTATUS
PIO_STACK_LOCATION IoStack;
IIrpTarget * IrpTarget;
- /* get current irp stack */
+ // get current irp stack
IoStack = IoGetCurrentIrpStackLocation(Irp);
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)IoStack->FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->Write(IrpTarget, DeviceObject, Irp);
+ // let IrpTarget handle request
+ return IrpTarget->Write(DeviceObject, Irp);
}
NTSTATUS
PIO_STACK_LOCATION IoStack;
IIrpTarget * IrpTarget;
- /* get current irp stack */
+ // get current irp stack
IoStack = IoGetCurrentIrpStackLocation(Irp);
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)IoStack->FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->Flush(IrpTarget, DeviceObject, Irp);
+ // let IrpTarget handle request
+ return IrpTarget->Flush(DeviceObject, Irp);
}
NTSTATUS
PIO_STACK_LOCATION IoStack;
IIrpTarget * IrpTarget;
- /* get current irp stack */
+ // get current irp stack
IoStack = IoGetCurrentIrpStackLocation(Irp);
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)IoStack->FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->Close(IrpTarget, DeviceObject, Irp);
+ // let IrpTarget handle request
+ return IrpTarget->Close(DeviceObject, Irp);
}
NTSTATUS
PIO_STACK_LOCATION IoStack;
IIrpTarget * IrpTarget;
- /* get current irp stack */
+ // get current irp stack
IoStack = IoGetCurrentIrpStackLocation(Irp);
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)IoStack->FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->QuerySecurity(IrpTarget, DeviceObject, Irp);
+ // let IrpTarget handle request
+ return IrpTarget->QuerySecurity(DeviceObject, Irp);
}
NTSTATUS
PIO_STACK_LOCATION IoStack;
IIrpTarget * IrpTarget;
- /* get current irp stack */
+ // get current irp stack
IoStack = IoGetCurrentIrpStackLocation(Irp);
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)IoStack->FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->SetSecurity(IrpTarget, DeviceObject, Irp);
+ // let IrpTarget handle request
+ return IrpTarget->SetSecurity(DeviceObject, Irp);
}
BOOLEAN
{
IIrpTarget * IrpTarget;
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->FastDeviceIoControl(IrpTarget, FileObject, Wait, InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength, IoControlCode, IoStatus, DeviceObject);
+ // let IrpTarget handle request
+ return IrpTarget->FastDeviceIoControl(FileObject, Wait, InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength, IoControlCode, IoStatus, DeviceObject);
}
{
IIrpTarget * IrpTarget;
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->FastRead(IrpTarget, FileObject, FileOffset, Length, Wait, LockKey, Buffer, IoStatus, DeviceObject);
+ // let IrpTarget handle request
+ return IrpTarget->FastRead(FileObject, FileOffset, Length, Wait, LockKey, Buffer, IoStatus, DeviceObject);
}
BOOLEAN
{
IIrpTarget * IrpTarget;
- /* access IrpTarget */
+ // access IrpTarget
IrpTarget = (IIrpTarget *)FileObject->FsContext2;
- /* let IrpTarget handle request */
- return IrpTarget->lpVtbl->FastWrite(IrpTarget, FileObject, FileOffset, Length, Wait, LockKey, Buffer, IoStatus, DeviceObject);
+ // let IrpTarget handle request
+ return IrpTarget->FastWrite(FileObject, FileOffset, Length, Wait, LockKey, Buffer, IoStatus, DeviceObject);
}
static KSDISPATCH_TABLE DispatchTable =
KSOBJECT_HEADER ObjectHeader;
PIO_STACK_LOCATION IoStack;
- /* get current irp stack location */
+ // get current irp stack location
IoStack = IoGetCurrentIrpStackLocation(Irp);
IoStack->FileObject->FsContext2 = (PVOID)Target;
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/dll.c
+ * FILE: drivers/wdm/audio/backpln/portcls/dll.cpp
* PURPOSE: portcls generic dispatcher
* PROGRAMMER: Andrew Greenwood
*/
-#include "private.h"
+#include "private.hpp"
-/*
- * @implemented
- */
ULONG
NTAPI
DllInitialize(ULONG Unknown)
return 0;
}
-/*
- * @implemented
- */
+
+extern
+"C"
+{
ULONG
NTAPI
-DllUnload(VOID)
+DllUnload()
{
return 0;
}
+}
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/dma_Init.c
- * PURPOSE: portcls dma support object
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-
-typedef struct
-{
- IDmaChannelInitVtbl *lpVtbl;
-
- LONG ref;
-
-
- PDEVICE_OBJECT pDeviceObject;
- PDMA_ADAPTER pAdapter;
-
- BOOL DmaStarted;
-
- ULONG MapSize;
- PVOID MapRegisterBase;
-
- ULONG LastTransferCount;
-
- ULONG MaximumBufferSize;
- ULONG MaxMapRegisters;
- ULONG AllocatedBufferSize;
- ULONG BufferSize;
-
- PHYSICAL_ADDRESS Address;
- PVOID Buffer;
- PMDL Mdl;
- BOOLEAN WriteToDevice;
-
-}IDmaChannelInitImpl;
-
-//---------------------------------------------------------------
-// IUnknown methods
-//
-
-extern GUID IID_IDmaChannelSlave;
-
-NTSTATUS
-NTAPI
-IDmaChannelInit_fnQueryInterface(
- IDmaChannelInit * iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IUnknown) ||
- IsEqualGUIDAligned(refiid, &IID_IDmaChannel) ||
- IsEqualGUIDAligned(refiid, &IID_IDmaChannelSlave))
- {
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- DPRINT1("No interface!!!\n");
- return STATUS_UNSUCCESSFUL;
-}
-
-ULONG
-NTAPI
-IDmaChannelInit_fnAddRef(
- IDmaChannelInit * iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_AddRef: This %p\n", This);
-
- return InterlockedIncrement(&This->ref);
-}
-
-ULONG
-NTAPI
-IDmaChannelInit_fnRelease(
- IDmaChannelInit* iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- DPRINT("IDmaChannelInit_Release: This %p new ref %u\n", This, This->ref);
-
- if (This->ref == 0)
- {
- This->pAdapter->DmaOperations->PutDmaAdapter(This->pAdapter);
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- /* Return new reference count */
- return This->ref;
-}
-
-//---------------------------------------------------------------
-// IDmaChannel methods
-//
-
-NTSTATUS
-NTAPI
-IDmaChannelInit_fnAllocateBuffer(
- IN IDmaChannelInit * iface,
- IN ULONG BufferSize,
- IN PPHYSICAL_ADDRESS PhysicalAddressConstraint OPTIONAL)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
-
- /* Did the caller already allocate a buffer ?*/
- if (This->Buffer)
- {
- DPRINT1("IDmaChannelInit_AllocateBuffer free common buffer first \n");
- return STATUS_UNSUCCESSFUL;
- }
-
- This->Buffer = This->pAdapter->DmaOperations->AllocateCommonBuffer(This->pAdapter, BufferSize, &This->Address, FALSE);
- if (!This->Buffer)
- {
- DPRINT1("IDmaChannelInit_AllocateBuffer fAllocateCommonBuffer failed \n");
- return STATUS_UNSUCCESSFUL;
- }
-
- This->BufferSize = BufferSize;
- This->AllocatedBufferSize = BufferSize;
- DPRINT1("IDmaChannelInit_fnAllocateBuffer Success Buffer %p BufferSize %u Address %x\n", This->Buffer, BufferSize, This->Address);
-
- return STATUS_SUCCESS;
-}
-
-ULONG
-NTAPI
-IDmaChannelInit_fnAllocatedBufferSize(
- IN IDmaChannelInit * iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_AllocatedBufferSize: This %p BufferSize %u\n", This, This->BufferSize);
- return This->AllocatedBufferSize;
-}
-
-VOID
-NTAPI
-IDmaChannelInit_fnCopyFrom(
- IN IDmaChannelInit * iface,
- IN PVOID Destination,
- IN PVOID Source,
- IN ULONG ByteCount
- )
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_CopyFrom: This %p Destination %p Source %p ByteCount %u\n", This, Destination, Source, ByteCount);
-
- iface->lpVtbl->CopyTo(iface, Destination, Source, ByteCount);
-}
-
-VOID
-NTAPI
-IDmaChannelInit_fnCopyTo(
- IN IDmaChannelInit * iface,
- IN PVOID Destination,
- IN PVOID Source,
- IN ULONG ByteCount
- )
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_CopyTo: This %p Destination %p Source %p ByteCount %u\n", This, Destination, Source, ByteCount);
- RtlCopyMemory(Destination, Source, ByteCount);
-}
-
-VOID
-NTAPI
-IDmaChannelInit_fnFreeBuffer(
- IN IDmaChannelInit * iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_FreeBuffer: This %p\n", This);
-
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
-
- if (!This->Buffer)
- {
- DPRINT1("IDmaChannelInit_FreeBuffer allocate common buffer first \n");
- return;
- }
-
- This->pAdapter->DmaOperations->FreeCommonBuffer(This->pAdapter, This->AllocatedBufferSize, This->Address, This->Buffer, FALSE);
- This->Buffer = NULL;
- This->AllocatedBufferSize = 0;
- This->Address.QuadPart = 0LL;
-
- if (This->Mdl)
- {
- IoFreeMdl(This->Mdl);
- This->Mdl = NULL;
- }
-}
-
-PADAPTER_OBJECT
-NTAPI
-IDmaChannelInit_fnGetAdapterObject(
- IN IDmaChannelInit * iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_GetAdapterObject: This %p\n", This);
- return (PADAPTER_OBJECT)This->pAdapter;
-}
-
-ULONG
-NTAPI
-IDmaChannelInit_fnMaximumBufferSize(
- IN IDmaChannelInit * iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_MaximumBufferSize: This %p\n", This);
- return This->MaximumBufferSize;
-}
-
-PHYSICAL_ADDRESS
-NTAPI
-IDmaChannelInit_fnPhysicalAdress(
- IN IDmaChannelInit * iface,
- PPHYSICAL_ADDRESS Address)
-{
- PHYSICAL_ADDRESS Result;
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
- DPRINT("IDmaChannelInit_PhysicalAdress: This %p Virtuell %p Physical High %x Low %x%\n", This, This->Buffer, This->Address.HighPart, This->Address.LowPart);
-
- Address->QuadPart = This->Address.QuadPart;
- Result.QuadPart = (PtrToUlong(Address));
- return Result;
-}
-
-VOID
-NTAPI
-IDmaChannelInit_fnSetBufferSize(
- IN IDmaChannelInit * iface,
- IN ULONG BufferSize)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_SetBufferSize: This %p\n", This);
- This->BufferSize = BufferSize;
-
-}
-
-ULONG
-NTAPI
-IDmaChannelInit_fnBufferSize(
- IN IDmaChannelInit * iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- return This->BufferSize;
-}
-
-
-PVOID
-NTAPI
-IDmaChannelInit_fnSystemAddress(
- IN IDmaChannelInit * iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_SystemAddress: This %p\n", This);
- return This->Buffer;
-}
-
-ULONG
-NTAPI
-IDmaChannelInit_fnTransferCount(
- IN IDmaChannelInit * iface)
-{
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_TransferCount: This %p\n", This);
- return This->LastTransferCount;
-}
-
-ULONG
-NTAPI
-IDmaChannelInit_fnReadCounter(
- IN IDmaChannelInit * iface)
-{
- ULONG Counter;
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- ASSERT_IRQL(DISPATCH_LEVEL);
-
- Counter = This->pAdapter->DmaOperations->ReadDmaCounter(This->pAdapter);
-
- if (!This->DmaStarted || Counter >= This->LastTransferCount) //FIXME
- Counter = 0;
-
- return Counter;
-}
-
-IO_ALLOCATION_ACTION
-NTAPI
-AdapterControl(
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN PVOID MapRegisterBase,
- IN PVOID Context)
-{
- ULONG Length;
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)Context;
-
- Length = This->MapSize;
- This->MapRegisterBase = MapRegisterBase;
-
- This->pAdapter->DmaOperations->MapTransfer(This->pAdapter,
- This->Mdl,
- MapRegisterBase,
- (PVOID)((ULONG_PTR)This->Mdl->StartVa + This->Mdl->ByteOffset),
- &Length,
- This->WriteToDevice);
-
- if (Length == This->BufferSize)
- {
- This->DmaStarted = TRUE;
- }
-
- return KeepObject;
-}
-
-NTSTATUS
-NTAPI
-IDmaChannelInit_fnStart(
- IN IDmaChannelInit * iface,
- ULONG MapSize,
- BOOLEAN WriteToDevice)
-{
- NTSTATUS Status;
- ULONG MapRegisters;
- KIRQL OldIrql;
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_Start: This %p\n", This);
-
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
-
- if (This->DmaStarted)
- return STATUS_UNSUCCESSFUL;
-
- if (!This->Mdl)
- {
- This->Mdl = IoAllocateMdl(This->Buffer, This->MaximumBufferSize, FALSE, FALSE, NULL);
- if (!This->Mdl)
- {
- return STATUS_INSUFFICIENT_RESOURCES;
- }
- MmBuildMdlForNonPagedPool(This->Mdl);
- }
-
- This->MapSize = MapSize;
- This->WriteToDevice = WriteToDevice;
- This->LastTransferCount = MapSize;
-
- //FIXME
- // synchronize access
- //
- KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
-
- MapRegisters = ADDRESS_AND_SIZE_TO_SPAN_PAGES(This->Buffer, MapSize);
- Status = This->pAdapter->DmaOperations->AllocateAdapterChannel(This->pAdapter, This->pDeviceObject, MapRegisters, AdapterControl, (PVOID)This);
- KeLowerIrql(OldIrql);
-
- if(!NT_SUCCESS(Status))
- This->LastTransferCount = 0;
-
- return Status;
-}
-
-NTSTATUS
-NTAPI
-IDmaChannelInit_fnStop(
- IN IDmaChannelInit * iface)
-{
- KIRQL OldIrql;
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- DPRINT("IDmaChannelInit_fnStop: This %p\n", This);
- ASSERT_IRQL(DISPATCH_LEVEL);
-
- if (!This->DmaStarted)
- return STATUS_SUCCESS;
-
- This->pAdapter->DmaOperations->FlushAdapterBuffers(This->pAdapter,
- This->Mdl,
- This->MapRegisterBase,
- (PVOID)((ULONG_PTR)This->Mdl->StartVa + This->Mdl->ByteOffset),
- This->MapSize,
- This->WriteToDevice);
-
- KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
-
- This->pAdapter->DmaOperations->FreeAdapterChannel(This->pAdapter);
-
- KeLowerIrql(OldIrql);
-
- This->DmaStarted = FALSE;
-
- IoFreeMdl(This->Mdl);
- This->Mdl = NULL;
-
- return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-IDmaChannelInit_fnWaitForTC(
- IN IDmaChannelInit * iface,
- ULONG Timeout)
-{
- ULONG RetryCount;
- ULONG BytesRemaining;
- ULONG PrevBytesRemaining;
-
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
-
- BytesRemaining = This->pAdapter->DmaOperations->ReadDmaCounter(This->pAdapter);
- if (!BytesRemaining)
- {
- return STATUS_SUCCESS;
- }
-
- RetryCount = Timeout / 10;
- PrevBytesRemaining = 0xFFFFFFFF;
- do
- {
- BytesRemaining = This->pAdapter->DmaOperations->ReadDmaCounter(This->pAdapter);
-
- if (!BytesRemaining)
- break;
-
- if (PrevBytesRemaining == BytesRemaining)
- break;
-
- KeStallExecutionProcessor(10);
- PrevBytesRemaining = BytesRemaining;
-
- }while(RetryCount-- >= 1);
-
- if (BytesRemaining)
- {
- return STATUS_UNSUCCESSFUL;
- }
-
- return STATUS_SUCCESS;
-
-}
-
-NTSTATUS
-NTAPI
-IDmaChannelInit_fnInit(
- IN IDmaChannelInit * iface,
- IN PDEVICE_DESCRIPTION DeviceDescription,
- IN PDEVICE_OBJECT DeviceObject)
-{
- INTERFACE_TYPE BusType;
- NTSTATUS Status;
- PDMA_ADAPTER Adapter;
- PPCLASS_DEVICE_EXTENSION DeviceExt;
- ULONG MapRegisters;
- ULONG ResultLength;
- IDmaChannelInitImpl * This = (IDmaChannelInitImpl*)iface;
-
- /* Get bus type */
- Status = IoGetDeviceProperty(DeviceObject, DevicePropertyLegacyBusType, sizeof(BusType), (PVOID)&BusType, &ResultLength);
- if (NT_SUCCESS(Status))
- {
- DeviceDescription->InterfaceType = BusType;
- }
- /* Fetch device extension */
- DeviceExt = (PPCLASS_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
- /* Acquire dma adapter */
- Adapter = IoGetDmaAdapter(DeviceExt->PhysicalDeviceObject, DeviceDescription, &MapRegisters);
- if (!Adapter)
- {
- FreeItem(This, TAG_PORTCLASS);
- return STATUS_DEVICE_CONFIGURATION_ERROR;
- }
-
- /* initialize object */
- This->ref = 1;
- This->pAdapter = Adapter;
- This->pDeviceObject = DeviceObject;
- This->MaximumBufferSize = DeviceDescription->MaximumLength;
- This->MaxMapRegisters = MapRegisters;
-
- return STATUS_SUCCESS;
-}
-
-
-IDmaChannelInitVtbl vt_IDmaChannelInitVtbl =
-{
- /* IUnknown methods */
- IDmaChannelInit_fnQueryInterface,
- IDmaChannelInit_fnAddRef,
- IDmaChannelInit_fnRelease,
- /* IDmaChannel methods */
- IDmaChannelInit_fnAllocateBuffer,
- IDmaChannelInit_fnFreeBuffer,
- IDmaChannelInit_fnTransferCount,
- IDmaChannelInit_fnMaximumBufferSize,
- IDmaChannelInit_fnAllocatedBufferSize,
- IDmaChannelInit_fnBufferSize,
- IDmaChannelInit_fnSetBufferSize,
- IDmaChannelInit_fnSystemAddress,
- IDmaChannelInit_fnPhysicalAdress,
- IDmaChannelInit_fnGetAdapterObject,
- IDmaChannelInit_fnCopyTo,
- IDmaChannelInit_fnCopyFrom,
- /* IDmaChannelSlave methods */
- IDmaChannelInit_fnStart,
- IDmaChannelInit_fnStop,
- IDmaChannelInit_fnReadCounter,
- IDmaChannelInit_fnWaitForTC,
- /* IDmaChannelInit methods */
- IDmaChannelInit_fnInit
-};
-
-
-/*
- * @unimplemented
- */
-NTSTATUS NTAPI
-PcNewDmaChannel(
- OUT PDMACHANNEL* OutDmaChannel,
- IN PUNKNOWN OuterUnknown OPTIONAL,
- IN POOL_TYPE PoolType,
- IN PDEVICE_DESCRIPTION DeviceDescription,
- IN PDEVICE_OBJECT DeviceObject)
-{
- NTSTATUS Status;
- IDmaChannelInitImpl * This;
-
- DPRINT("OutDmaChannel %p OuterUnknown %p PoolType %p DeviceDescription %p DeviceObject %p\n",
- OutDmaChannel, OuterUnknown, PoolType, DeviceDescription, DeviceObject);
-
- This = AllocateItem(PoolType, sizeof(IDmaChannelInitImpl), TAG_PORTCLASS);
- if (!This)
- {
- return STATUS_INSUFFICIENT_RESOURCES;
- }
-
- /* initialize object */
- Status = IDmaChannelInit_fnInit((IDmaChannelInit*)This, DeviceDescription, DeviceObject);
- if (NT_SUCCESS(Status))
- {
- /* store result */
- This->lpVtbl = &vt_IDmaChannelInitVtbl;
- *OutDmaChannel = (PVOID)(&This->lpVtbl);
- }
-
- return Status;
-
-}
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/dma_init.c
+ * PURPOSE: portcls dma support object
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+class CDmaChannelInit : public IDmaChannelInit
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IDmaChannelInit;
+ CDmaChannelInit(IUnknown * OuterUnknown){}
+ virtual ~CDmaChannelInit(){}
+
+protected:
+
+ PDEVICE_OBJECT m_pDeviceObject;
+ PDMA_ADAPTER m_pAdapter;
+
+ BOOL m_DmaStarted;
+
+ ULONG m_MapSize;
+ PVOID m_MapRegisterBase;
+
+ ULONG m_LastTransferCount;
+
+ ULONG m_MaximumBufferSize;
+ ULONG m_MaxMapRegisters;
+ ULONG m_AllocatedBufferSize;
+ ULONG m_BufferSize;
+
+ PHYSICAL_ADDRESS m_Address;
+ PVOID m_Buffer;
+ PMDL m_Mdl;
+ BOOLEAN m_WriteToDevice;
+
+ friend IO_ALLOCATION_ACTION NTAPI AdapterControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PVOID MapRegisterBase, IN PVOID Context);
+
+ LONG m_Ref;
+};
+
+
+
+//---------------------------------------------------------------
+// IUnknown methods
+//
+
+extern GUID IID_IDmaChannelSlave;
+
+NTSTATUS
+NTAPI
+CDmaChannelInit::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+ if (IsEqualGUIDAligned(refiid, IID_IUnknown) ||
+ IsEqualGUIDAligned(refiid, IID_IDmaChannel))
+ //IsEqualGUIDAligned(refiid, IID_IDmaChannelSlave)) // HACK
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+ DPRINT1("No interface!!!\n");
+ return STATUS_UNSUCCESSFUL;
+}
+
+//---------------------------------------------------------------
+// IDmaChannel methods
+//
+
+NTSTATUS
+NTAPI
+CDmaChannelInit::AllocateBuffer(
+ IN ULONG BufferSize,
+ IN PPHYSICAL_ADDRESS PhysicalAddressConstraint OPTIONAL)
+{
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+
+ // Did the caller already allocate a buffer ?*/
+ if (m_Buffer)
+ {
+ DPRINT1("CDmaChannelInit_AllocateBuffer free common buffer first \n");
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ m_Buffer = m_pAdapter->DmaOperations->AllocateCommonBuffer(m_pAdapter, BufferSize, &m_Address, FALSE);
+ if (!m_Buffer)
+ {
+ DPRINT1("CDmaChannelInit_AllocateBuffer fAllocateCommonBuffer failed \n");
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ m_BufferSize = BufferSize;
+ m_AllocatedBufferSize = BufferSize;
+ DPRINT1("CDmaChannelInit::AllocateBuffer Success Buffer %p BufferSize %u Address %x\n", m_Buffer, BufferSize, m_Address);
+
+ return STATUS_SUCCESS;
+}
+
+ULONG
+NTAPI
+CDmaChannelInit::AllocatedBufferSize()
+{
+ DPRINT("CDmaChannelInit_AllocatedBufferSize: this %p BufferSize %u\n", this, m_BufferSize);
+ return m_AllocatedBufferSize;
+}
+
+VOID
+NTAPI
+CDmaChannelInit::CopyFrom(
+ IN PVOID Destination,
+ IN PVOID Source,
+ IN ULONG ByteCount
+ )
+{
+ DPRINT("CDmaChannelInit_CopyFrom: this %p Destination %p Source %p ByteCount %u\n", this, Destination, Source, ByteCount);
+
+ CopyTo(Destination, Source, ByteCount);
+}
+
+VOID
+NTAPI
+CDmaChannelInit::CopyTo(
+ IN PVOID Destination,
+ IN PVOID Source,
+ IN ULONG ByteCount
+ )
+{
+ DPRINT("CDmaChannelInit_CopyTo: this %p Destination %p Source %p ByteCount %u\n", this, Destination, Source, ByteCount);
+ RtlCopyMemory(Destination, Source, ByteCount);
+}
+
+VOID
+NTAPI
+CDmaChannelInit::FreeBuffer()
+{
+ DPRINT("CDmaChannelInit_FreeBuffer: this %p\n", this);
+
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+
+ if (!m_Buffer)
+ {
+ DPRINT1("CDmaChannelInit_FreeBuffer allocate common buffer first \n");
+ return;
+ }
+
+ m_pAdapter->DmaOperations->FreeCommonBuffer(m_pAdapter, m_AllocatedBufferSize, m_Address, m_Buffer, FALSE);
+ m_Buffer = NULL;
+ m_AllocatedBufferSize = 0;
+ m_Address.QuadPart = 0LL;
+
+ if (m_Mdl)
+ {
+ IoFreeMdl(m_Mdl);
+ m_Mdl = NULL;
+ }
+}
+
+PADAPTER_OBJECT
+NTAPI
+CDmaChannelInit::GetAdapterObject()
+{
+ DPRINT("CDmaChannelInit_GetAdapterObject: this %p\n", this);
+ return (PADAPTER_OBJECT)m_pAdapter;
+}
+
+ULONG
+NTAPI
+CDmaChannelInit::MaximumBufferSize()
+{
+ DPRINT("CDmaChannelInit_MaximumBufferSize: this %p\n", this);
+ return m_MaximumBufferSize;
+}
+
+PHYSICAL_ADDRESS
+NTAPI
+CDmaChannelInit::PhysicalAddress()
+{
+ DPRINT("CDmaChannelInit_PhysicalAdress: this %p Virtuell %p Physical High %x Low %x%\n", this, m_Buffer, m_Address.HighPart, m_Address.LowPart);
+
+ return m_Address;
+}
+
+VOID
+NTAPI
+CDmaChannelInit::SetBufferSize(
+ IN ULONG BufferSize)
+{
+ DPRINT("CDmaChannelInit_SetBufferSize: this %p\n", this);
+ m_BufferSize = BufferSize;
+
+}
+
+ULONG
+NTAPI
+CDmaChannelInit::BufferSize()
+{
+ return m_BufferSize;
+}
+
+
+PVOID
+NTAPI
+CDmaChannelInit::SystemAddress()
+{
+ DPRINT("CDmaChannelInit_SystemAddress: this %p\n", this);
+ return m_Buffer;
+}
+
+ULONG
+NTAPI
+CDmaChannelInit::TransferCount()
+{
+ DPRINT("CDmaChannelInit_TransferCount: this %p\n", this);
+ return m_LastTransferCount;
+}
+
+ULONG
+NTAPI
+CDmaChannelInit::ReadCounter()
+{
+ ULONG Counter;
+
+ PC_ASSERT_IRQL(DISPATCH_LEVEL);
+
+ Counter = m_pAdapter->DmaOperations->ReadDmaCounter(m_pAdapter);
+
+ if (!m_DmaStarted || Counter >= m_LastTransferCount)
+ Counter = 0;
+
+ return Counter;
+}
+
+IO_ALLOCATION_ACTION
+NTAPI
+AdapterControl(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN PVOID MapRegisterBase,
+ IN PVOID Context)
+{
+ ULONG Length;
+ CDmaChannelInit * This = (CDmaChannelInit*)Context;
+
+ Length = This->m_MapSize;
+ This->m_MapRegisterBase = MapRegisterBase;
+
+ This->m_pAdapter->DmaOperations->MapTransfer(This->m_pAdapter,
+ This->m_Mdl,
+ MapRegisterBase,
+ (PVOID)((ULONG_PTR)This->m_Mdl->StartVa + This->m_Mdl->ByteOffset),
+ &Length,
+ This->m_WriteToDevice);
+
+ if (Length == This->m_BufferSize)
+ {
+ This->m_DmaStarted = TRUE;
+ }
+
+ return KeepObject;
+}
+
+NTSTATUS
+NTAPI
+CDmaChannelInit::Start(
+ ULONG MapSize,
+ BOOLEAN WriteToDevice)
+{
+ NTSTATUS Status;
+ ULONG MapRegisters;
+ KIRQL OldIrql;
+
+ DPRINT("CDmaChannelInit_Start: this %p\n", this);
+
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+
+ if (m_DmaStarted)
+ return STATUS_UNSUCCESSFUL;
+
+ if (!m_Mdl)
+ {
+ m_Mdl = IoAllocateMdl(m_Buffer, m_MaximumBufferSize, FALSE, FALSE, NULL);
+ if (!m_Mdl)
+ {
+ return STATUS_INSUFFICIENT_RESOURCES;
+ }
+ MmBuildMdlForNonPagedPool(m_Mdl);
+ }
+
+ m_MapSize = MapSize;
+ m_WriteToDevice = WriteToDevice;
+ m_LastTransferCount = MapSize;
+
+ //FIXME
+ // synchronize access
+ //
+ KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+
+ MapRegisters = ADDRESS_AND_SIZE_TO_SPAN_PAGES(m_Buffer, MapSize);
+ Status = m_pAdapter->DmaOperations->AllocateAdapterChannel(m_pAdapter, m_pDeviceObject, MapRegisters, AdapterControl, (PVOID)this);
+ KeLowerIrql(OldIrql);
+
+ if(!NT_SUCCESS(Status))
+ m_LastTransferCount = 0;
+
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+CDmaChannelInit::Stop()
+{
+ KIRQL OldIrql;
+
+ DPRINT("CDmaChannelInit::Stop: this %p\n", this);
+ PC_ASSERT_IRQL(DISPATCH_LEVEL);
+
+ if (!m_DmaStarted)
+ return STATUS_SUCCESS;
+
+ m_pAdapter->DmaOperations->FlushAdapterBuffers(m_pAdapter,
+ m_Mdl,
+ m_MapRegisterBase,
+ (PVOID)((ULONG_PTR)m_Mdl->StartVa + m_Mdl->ByteOffset),
+ m_MapSize,
+ m_WriteToDevice);
+
+ KeRaiseIrql(DISPATCH_LEVEL, &OldIrql);
+
+ m_pAdapter->DmaOperations->FreeAdapterChannel(m_pAdapter);
+
+ KeLowerIrql(OldIrql);
+
+ m_DmaStarted = FALSE;
+
+ IoFreeMdl(m_Mdl);
+ m_Mdl = NULL;
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NTAPI
+CDmaChannelInit::WaitForTC(
+ ULONG Timeout)
+{
+ ULONG RetryCount;
+ ULONG BytesRemaining;
+ ULONG PrevBytesRemaining;
+
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+
+ BytesRemaining = m_pAdapter->DmaOperations->ReadDmaCounter(m_pAdapter);
+ if (!BytesRemaining)
+ {
+ return STATUS_SUCCESS;
+ }
+
+ RetryCount = Timeout / 10;
+ PrevBytesRemaining = 0xFFFFFFFF;
+ do
+ {
+ BytesRemaining = m_pAdapter->DmaOperations->ReadDmaCounter(m_pAdapter);
+
+ if (!BytesRemaining)
+ break;
+
+ if (PrevBytesRemaining == BytesRemaining)
+ break;
+
+ KeStallExecutionProcessor(10);
+ PrevBytesRemaining = BytesRemaining;
+
+ }while(RetryCount-- >= 1);
+
+ if (BytesRemaining)
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ return STATUS_SUCCESS;
+
+}
+
+NTSTATUS
+NTAPI
+CDmaChannelInit::Init(
+ IN PDEVICE_DESCRIPTION DeviceDescription,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ INTERFACE_TYPE BusType;
+ NTSTATUS Status;
+ PDMA_ADAPTER Adapter;
+ PPCLASS_DEVICE_EXTENSION DeviceExt;
+ ULONG MapRegisters;
+ ULONG ResultLength;
+
+ // Get bus type
+ Status = IoGetDeviceProperty(DeviceObject, DevicePropertyLegacyBusType, sizeof(BusType), (PVOID)&BusType, &ResultLength);
+ if (NT_SUCCESS(Status))
+ {
+ DeviceDescription->InterfaceType = BusType;
+ }
+ // Fetch device extension
+ DeviceExt = (PPCLASS_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
+ // Acquire dma adapter
+ Adapter = IoGetDmaAdapter(DeviceExt->PhysicalDeviceObject, DeviceDescription, &MapRegisters);
+ if (!Adapter)
+ {
+ FreeItem(this, TAG_PORTCLASS);
+ return STATUS_DEVICE_CONFIGURATION_ERROR;
+ }
+
+ // initialize object
+ m_pAdapter = Adapter;
+ m_pDeviceObject = DeviceObject;
+ m_MaximumBufferSize = DeviceDescription->MaximumLength;
+ m_MaxMapRegisters = MapRegisters;
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NTAPI
+PcNewDmaChannel(
+ OUT PDMACHANNEL* OutDmaChannel,
+ IN PUNKNOWN OuterUnknown OPTIONAL,
+ IN POOL_TYPE PoolType,
+ IN PDEVICE_DESCRIPTION DeviceDescription,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ NTSTATUS Status;
+ CDmaChannelInit * This;
+
+ DPRINT("OutDmaChannel %p OuterUnknown %p PoolType %p DeviceDescription %p DeviceObject %p\n",
+ OutDmaChannel, OuterUnknown, PoolType, DeviceDescription, DeviceObject);
+
+ This = new(PoolType, TAG_PORTCLASS)CDmaChannelInit(OuterUnknown);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ Status = This->QueryInterface(IID_IDmaChannel, (PVOID*)OutDmaChannel);
+
+ if (!NT_SUCCESS(Status))
+ {
+ delete This;
+ return Status;
+ }
+
+ Status = This->Init(DeviceDescription, DeviceObject);
+
+ if (!NT_SUCCESS(Status))
+ {
+ delete This;
+ return Status;
+ }
+
+ return Status;
+}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/drm.c
+ * FILE: drivers/wdm/audio/backpln/portcls/drm.cpp
* PURPOSE: portcls drm functions
* PROGRAMMER: Andrew Greenwood
*/
-#include "private.h"
+#include "private.hpp"
+
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcAddContentHandlers(
IN PVOID *paHandlers,
IN ULONG NumHandlers)
{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
return DrmAddContentHandlers(ContentId, paHandlers, NumHandlers);
}
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcCreateContentMixed(
IN ULONG cContentId,
OUT PULONG pMixedContentId)
{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
return DrmCreateContentMixed(paContentId, cContentId, pMixedContentId);
}
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcDestroyContent(
IN ULONG ContentId)
{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
return DrmDestroyContent(ContentId);
}
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcForwardContentToDeviceObject(
IN PVOID Reserved,
IN PCDRMFORWARD DrmForward)
{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
return DrmForwardContentToDeviceObject(ContentId, Reserved, DrmForward);
}
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcForwardContentToFileObject(
IN ULONG ContentId,
IN PFILE_OBJECT FileObject)
{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
return DrmForwardContentToFileObject(ContentId, FileObject);
}
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcForwardContentToInterface(
return DrmForwardContentToInterface(ContentId, pUnknown, NumMethods);
}
-/*
- * @implemented
- */
NTSTATUS
NTAPI
PcGetContentRights(
IN ULONG ContentId,
OUT PDRMRIGHTS DrmRights)
{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
return DrmGetContentRights(ContentId, DrmRights);
}
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/drm_port.c
- * PURPOSE: portcls drm port object
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-typedef struct
-{
- IDrmPort2Vtbl *lpVtbl;
- LONG ref;
-}IDrmPort2Impl;
-
-ULONG
-NTAPI
-IDrmPort2_fnAddRef(
- IN IDrmPort2* iface)
-{
- IDrmPort2Impl * This = (IDrmPort2Impl*)iface;
-
- DPRINT("IDrmPort2_AddRef: This %p\n", This);
-
- return InterlockedIncrement(&This->ref);
-}
-
-ULONG
-NTAPI
-IDrmPort2_fnRelease(
- IN IDrmPort2* iface)
-{
- IDrmPort2Impl * This = (IDrmPort2Impl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- /* Return new reference count */
- return This->ref;
-}
-
-NTSTATUS
-NTAPI
-IDrmPort2_fnQueryInterface(
- IN IDrmPort2* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- UNICODE_STRING GuidString;
- IDrmPort2Impl * This = (IDrmPort2Impl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IDrmPort) ||
- IsEqualGUIDAligned(refiid, &IID_IDrmPort2) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = (PVOID)&This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
-
- if (RtlStringFromGUID(refiid, &GuidString) == STATUS_SUCCESS)
- {
- DPRINT1("IDrmPort2_QueryInterface no interface!!! iface %S\n", GuidString.Buffer);
- RtlFreeUnicodeString(&GuidString);
- }
- return STATUS_UNSUCCESSFUL;
-}
-
-NTSTATUS
-NTAPI
-IDrmPort2_fnCreateContentMixed(
- IN IDrmPort2 * iface,
- IN PULONG paContentId,
- IN ULONG cContentId,
- OUT PULONG pMixedContentId)
-{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
- return DrmCreateContentMixed(paContentId, cContentId, pMixedContentId);
-}
-
-NTSTATUS
-NTAPI
-IDrmPort2_fnDestroyContent(
- IN IDrmPort2 * iface,
- IN ULONG ContentId)
-{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
- return DrmDestroyContent(ContentId);
-}
-
-NTSTATUS
-NTAPI
-IDrmPort2_fnForwardContentToFileObject(
- IN IDrmPort2 * iface,
- IN ULONG ContentId,
- IN PFILE_OBJECT FileObject)
-{
- return DrmForwardContentToFileObject(ContentId, FileObject);
-}
-
-NTSTATUS
-NTAPI
-IDrmPort2_fnForwardContentToInterface(
- IN IDrmPort2 * iface,
- IN ULONG ContentId,
- IN PUNKNOWN pUnknown,
- IN ULONG NumMethods)
-{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
- return DrmForwardContentToInterface(ContentId, pUnknown, NumMethods);
-}
-
-NTSTATUS
-NTAPI
-IDrmPort2_fnGetContentRights(
- IN IDrmPort2 * iface,
- IN ULONG ContentId,
- OUT PDRMRIGHTS DrmRights)
-{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
- return DrmGetContentRights(ContentId, DrmRights);
-}
-
-NTSTATUS
-NTAPI
-IDrmPort2_fnAddContentHandlers(
- IN IDrmPort2 * iface,
- IN ULONG ContentId,
- IN PVOID * paHandlers,
- IN ULONG NumHandlers)
-{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
- return DrmAddContentHandlers(ContentId, paHandlers, NumHandlers);
-}
-
-NTSTATUS
-NTAPI
-IDrmPort2_fnForwardContentToDeviceObject(
- IN IDrmPort2 * iface,
- IN ULONG ContentId,
- IN PVOID Reserved,
- IN PCDRMFORWARD DrmForward)
-{
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
- return DrmForwardContentToDeviceObject(ContentId, Reserved, DrmForward);
-}
-
-static IDrmPort2Vtbl vt_IDrmPort2 =
-{
- /* IUnknown methods */
- IDrmPort2_fnQueryInterface,
- IDrmPort2_fnAddRef,
- IDrmPort2_fnRelease,
- IDrmPort2_fnCreateContentMixed,
- IDrmPort2_fnDestroyContent,
- IDrmPort2_fnForwardContentToFileObject,
- IDrmPort2_fnForwardContentToInterface,
- IDrmPort2_fnGetContentRights,
- IDrmPort2_fnAddContentHandlers,
- IDrmPort2_fnForwardContentToDeviceObject
-};
-
-NTSTATUS
-NewIDrmPort(
- OUT PDRMPORT2 *OutPort)
-{
- IDrmPort2Impl * This = AllocateItem(NonPagedPool, sizeof(IDrmPort2Impl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- This->lpVtbl = &vt_IDrmPort2;
- This->ref = 1;
-
- *OutPort = (PDRMPORT2)&This->lpVtbl;
- return STATUS_SUCCESS;
-}
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/drm_port.cpp
+ * PURPOSE: portcls drm port object
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+class CDrmPort2 : public IDrmPort2
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IDrmPort2;
+ CDrmPort2(IUnknown *OuterUnknown){}
+ virtual ~CDrmPort2(){}
+
+protected:
+ LONG m_Ref;
+
+};
+
+NTSTATUS
+NTAPI
+CDrmPort2::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+ UNICODE_STRING GuidString;
+
+ if (IsEqualGUIDAligned(refiid, IID_IDrmPort) ||
+ IsEqualGUIDAligned(refiid, IID_IDrmPort2) ||
+ IsEqualGUIDAligned(refiid, IID_IUnknown))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+
+ if (RtlStringFromGUID(refiid, &GuidString) == STATUS_SUCCESS)
+ {
+ DPRINT1("IDrmPort2_QueryInterface no interface!!! iface %S\n", GuidString.Buffer);
+ RtlFreeUnicodeString(&GuidString);
+ }
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CDrmPort2::CreateContentMixed(
+ IN PULONG paContentId,
+ IN ULONG cContentId,
+ OUT PULONG pMixedContentId)
+{
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ return DrmCreateContentMixed(paContentId, cContentId, pMixedContentId);
+}
+
+NTSTATUS
+NTAPI
+CDrmPort2::DestroyContent(
+ IN ULONG ContentId)
+{
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ return DrmDestroyContent(ContentId);
+}
+
+NTSTATUS
+NTAPI
+CDrmPort2::ForwardContentToFileObject(
+ IN ULONG ContentId,
+ IN PFILE_OBJECT FileObject)
+{
+ return DrmForwardContentToFileObject(ContentId, FileObject);
+}
+
+NTSTATUS
+NTAPI
+CDrmPort2::ForwardContentToInterface(
+ IN ULONG ContentId,
+ IN PUNKNOWN pUnknown,
+ IN ULONG NumMethods)
+{
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ return DrmForwardContentToInterface(ContentId, pUnknown, NumMethods);
+}
+
+NTSTATUS
+NTAPI
+CDrmPort2::GetContentRights(
+ IN ULONG ContentId,
+ OUT PDRMRIGHTS DrmRights)
+{
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ return DrmGetContentRights(ContentId, DrmRights);
+}
+
+NTSTATUS
+NTAPI
+CDrmPort2::AddContentHandlers(
+ IN ULONG ContentId,
+ IN PVOID * paHandlers,
+ IN ULONG NumHandlers)
+{
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ return DrmAddContentHandlers(ContentId, paHandlers, NumHandlers);
+}
+
+NTSTATUS
+NTAPI
+CDrmPort2::ForwardContentToDeviceObject(
+ IN ULONG ContentId,
+ IN PVOID Reserved,
+ IN PCDRMFORWARD DrmForward)
+{
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ return DrmForwardContentToDeviceObject(ContentId, Reserved, DrmForward);
+}
+
+NTSTATUS
+NewIDrmPort(
+ OUT PDRMPORT2 *OutPort)
+{
+ CDrmPort2 * This = new(NonPagedPool, TAG_PORTCLASS)CDrmPort2(NULL);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ This->AddRef();
+
+ *OutPort = (PDRMPORT2)This;
+ return STATUS_SUCCESS;
+}
+
+
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/filter_dmus.c
- * PURPOSE: portcls wave pci filter
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-typedef struct
-{
- IPortFilterDMusVtbl *lpVtbl;
-
- LONG ref;
-
- IPortDMus* Port;
- IPortPinDMus ** Pins;
- SUBDEVICE_DESCRIPTOR * Descriptor;
-
-}IPortFilterDMusImpl;
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnQueryInterface(
- IPortFilterDMus* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IIrpTarget) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- else if (IsEqualGUIDAligned(refiid, &IID_IPort))
- {
- *Output = This->Port;
- This->Port->lpVtbl->AddRef(This->Port);
- return STATUS_SUCCESS;
- }
-
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterDMus_fnAddRef(
- IPortFilterDMus* iface)
-{
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl*)iface;
-
- return InterlockedIncrement(&This->ref);
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterDMus_fnRelease(
- IPortFilterDMus* iface)
-{
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- return This->ref;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnNewIrpTarget(
- IN IPortFilterDMus* iface,
- OUT struct IIrpTarget **OutTarget,
- IN WCHAR * Name,
- IN PUNKNOWN Unknown,
- IN POOL_TYPE PoolType,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN KSOBJECT_CREATE *CreateObject)
-{
- NTSTATUS Status;
- IPortPinDMus * Pin;
- PKSPIN_CONNECT ConnectDetails;
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl *)iface;
-
- ASSERT(This->Port);
- ASSERT(This->Descriptor);
- ASSERT(This->Pins);
-
- DPRINT("IPortFilterDMus_fnNewIrpTarget entered\n");
-
- /* let's verify the connection request */
- Status = PcValidateConnectRequest(Irp, &This->Descriptor->Factory, &ConnectDetails);
- if (!NT_SUCCESS(Status))
- {
- return STATUS_UNSUCCESSFUL;
- }
-
- if (This->Pins[ConnectDetails->PinId] && This->Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount)
- {
- /* release existing instance */
- ASSERT(0);
- }
-
- /* now create the pin */
- Status = NewPortPinDMus(&Pin);
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
-
- /* initialize the pin */
- Status = Pin->lpVtbl->Init(Pin, This->Port, iface, ConnectDetails, &This->Descriptor->Factory.KsPinDescriptor[ConnectDetails->PinId], DeviceObject);
- if (!NT_SUCCESS(Status))
- {
- Pin->lpVtbl->Release(Pin);
- return Status;
- }
-
- /* release existing pin */
- if (This->Pins[ConnectDetails->PinId])
- {
- This->Pins[ConnectDetails->PinId]->lpVtbl->Release(This->Pins[ConnectDetails->PinId]);
- }
- /* store pin */
- This->Pins[ConnectDetails->PinId] = Pin;
-
- /* store result */
- *OutTarget = (IIrpTarget*)Pin;
-
- /* increment current instance count */
- This->Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount++;
-
- return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnDeviceIoControl(
- IN IPortFilterDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- PIO_STACK_LOCATION IoStack;
- ISubdevice *SubDevice = NULL;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- NTSTATUS Status;
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl *)iface;
-
- IoStack = IoGetCurrentIrpStackLocation(Irp);
- ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY);
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&SubDevice);
- ASSERT(Status == STATUS_SUCCESS);
- ASSERT(SubDevice != NULL);
-
- Status = SubDevice->lpVtbl->GetDescriptor(SubDevice, &Descriptor);
- ASSERT(Status == STATUS_SUCCESS);
- ASSERT(Descriptor != NULL);
-
- SubDevice->lpVtbl->Release(SubDevice);
-
- return PcPropertyHandler(Irp, Descriptor);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnRead(
- IN IPortFilterDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnWrite(
- IN IPortFilterDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnFlush(
- IN IPortFilterDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnClose(
- IN IPortFilterDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- ULONG Index;
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl *)iface;
-
- for(Index = 0; Index < This->Descriptor->Factory.PinDescriptorCount; Index++)
- {
- if (This->Pins[Index])
- {
- This->Pins[Index]->lpVtbl->Close(This->Pins[Index], DeviceObject, NULL);
- }
- }
-
-
- Irp->IoStatus.Status = STATUS_SUCCESS;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnQuerySecurity(
- IN IPortFilterDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnSetSecurity(
- IN IPortFilterDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterDMus_fnFastDeviceIoControl(
- IN IPortFilterDMus* iface,
- IN PFILE_OBJECT FileObject,
- IN BOOLEAN Wait,
- IN PVOID InputBuffer,
- IN ULONG InputBufferLength,
- OUT PVOID OutputBuffer,
- IN ULONG OutputBufferLength,
- IN ULONG IoControlCode,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- ULONG Index;
- PKSPROPERTY Property;
- NTSTATUS Status;
- ISubdevice * SubDevice = NULL;
- PSUBDEVICE_DESCRIPTOR Descriptor = NULL;
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl *)iface;
-
- Property = (PKSPROPERTY)InputBuffer;
-
- if (InputBufferLength < sizeof(KSPROPERTY))
- return FALSE;
-
-
- /* get private interface */
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&SubDevice);
- if (!NT_SUCCESS(Status))
- return FALSE;
-
- /* get descriptor */
- Status = SubDevice->lpVtbl->GetDescriptor(SubDevice, &Descriptor);
- if (!NT_SUCCESS(Status))
- {
- SubDevice->lpVtbl->Release(SubDevice);
- return FALSE;
- }
-
- for(Index = 0; Index < Descriptor->FilterPropertySet.FreeKsPropertySetOffset; Index++)
- {
- if (IsEqualGUIDAligned(&Property->Set, Descriptor->FilterPropertySet.Properties[Index].Set))
- {
- FastPropertyHandler(FileObject, (PKSPROPERTY)InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength, StatusBlock,
- 1,
- &Descriptor->FilterPropertySet.Properties[Index],
- Descriptor, SubDevice);
- }
- }
- return TRUE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterDMus_fnFastRead(
- IN IPortFilterDMus* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterDMus_fnFastWrite(
- IN IPortFilterDMus* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-static
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnInit(
- IN IPortFilterDMus* iface,
- IN IPortDMus* Port)
-{
- ISubdevice * ISubDevice;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- NTSTATUS Status;
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl*)iface;
-
- This->Port = Port;
-
- /* get our private interface */
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&ISubDevice);
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* get the subdevice descriptor */
- Status = ISubDevice->lpVtbl->GetDescriptor(ISubDevice, &Descriptor);
-
- /* release subdevice interface */
- ISubDevice->lpVtbl->Release(ISubDevice);
-
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* save descriptor */
- This->Descriptor = Descriptor;
-
- /* allocate pin array */
- This->Pins = AllocateItem(NonPagedPool, Descriptor->Factory.PinDescriptorCount * sizeof(IPortPinDMus*), TAG_PORTCLASS);
-
- if (!This->Pins)
- return STATUS_UNSUCCESSFUL;
-
- /* increment reference count */
- Port->lpVtbl->AddRef(Port);
-
- return STATUS_SUCCESS;
-}
-
-
-static
-NTSTATUS
-NTAPI
-IPortFilterDMus_fnFreePin(
- IN IPortFilterDMus* iface,
- IN struct IPortPinDMus* Pin)
-{
- ULONG Index;
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl*)iface;
-
- for(Index = 0; Index < This->Descriptor->Factory.PinDescriptorCount; Index++)
- {
- if (This->Pins[Index] == Pin)
- {
- This->Pins[Index]->lpVtbl->Release(This->Pins[Index]);
- This->Pins[Index] = NULL;
- return STATUS_SUCCESS;
- }
- }
- return STATUS_UNSUCCESSFUL;
-}
-
-static
-VOID
-NTAPI
-IPortFilterDMus_fnNotifyPins(
- IN IPortFilterDMus* iface)
-{
- ULONG Index;
- IPortFilterDMusImpl * This = (IPortFilterDMusImpl*)iface;
-
- DPRINT("Notifying %u pins\n", This->Descriptor->Factory.PinDescriptorCount);
-
- for(Index = 0; Index < This->Descriptor->Factory.PinDescriptorCount; Index++)
- {
- This->Pins[Index]->lpVtbl->Notify(This->Pins[Index]);
- }
-}
-
-static IPortFilterDMusVtbl vt_IPortFilterDMus =
-{
- IPortFilterDMus_fnQueryInterface,
- IPortFilterDMus_fnAddRef,
- IPortFilterDMus_fnRelease,
- IPortFilterDMus_fnNewIrpTarget,
- IPortFilterDMus_fnDeviceIoControl,
- IPortFilterDMus_fnRead,
- IPortFilterDMus_fnWrite,
- IPortFilterDMus_fnFlush,
- IPortFilterDMus_fnClose,
- IPortFilterDMus_fnQuerySecurity,
- IPortFilterDMus_fnSetSecurity,
- IPortFilterDMus_fnFastDeviceIoControl,
- IPortFilterDMus_fnFastRead,
- IPortFilterDMus_fnFastWrite,
- IPortFilterDMus_fnInit,
- IPortFilterDMus_fnFreePin,
- IPortFilterDMus_fnNotifyPins
-};
-
-NTSTATUS
-NewPortFilterDMus(
- OUT PPORTFILTERDMUS * OutFilter)
-{
- IPortFilterDMusImpl * This;
-
- This = AllocateItem(NonPagedPool, sizeof(IPortFilterDMusImpl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- /* initialize IPortFilterDMus */
- This->ref = 1;
- This->lpVtbl = &vt_IPortFilterDMus;
-
- /* return result */
- *OutFilter = (IPortFilterDMus*)&This->lpVtbl;
-
- return STATUS_SUCCESS;
-}
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/filter_dmus.cpp
+ * PURPOSE: portcls wave pci filter
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+class CPortFilterDMus : public IPortFilterDMus
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IPortFilterDMus;
+ CPortFilterDMus(IUnknown *OuterUnknown){}
+ virtual ~CPortFilterDMus(){}
+
+protected:
+ IPortDMus* m_Port;
+ IPortPinDMus ** m_Pins;
+ SUBDEVICE_DESCRIPTOR * m_Descriptor;
+ LONG m_Ref;
+};
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+
+ if (IsEqualGUIDAligned(refiid, IID_IIrpTarget) ||
+ IsEqualGUIDAligned(refiid, IID_IUnknown))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+ else if (IsEqualGUIDAligned(refiid, IID_IPort))
+ {
+ *Output = PUNKNOWN(m_Port);
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::NewIrpTarget(
+ OUT struct IIrpTarget **OutTarget,
+ IN WCHAR * Name,
+ IN PUNKNOWN Unknown,
+ IN POOL_TYPE PoolType,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN KSOBJECT_CREATE *CreateObject)
+{
+ NTSTATUS Status;
+ IPortPinDMus * Pin;
+ PKSPIN_CONNECT ConnectDetails;
+
+ PC_ASSERT(m_Port);
+ PC_ASSERT(m_Descriptor);
+ PC_ASSERT(m_Pins);
+
+ DPRINT("CPortFilterDMus::NewIrpTarget entered\n");
+
+ // let's verify the connection request
+ Status = PcValidateConnectRequest(Irp, &m_Descriptor->Factory, &ConnectDetails);
+ if (!NT_SUCCESS(Status))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ if (m_Pins[ConnectDetails->PinId] && m_Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount)
+ {
+ // release existing instance
+ PC_ASSERT(0);
+ }
+
+ // now create the pin
+ Status = NewPortPinDMus(&Pin);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+
+ // initialize the pin
+ Status = Pin->Init(m_Port, this, ConnectDetails, &m_Descriptor->Factory.KsPinDescriptor[ConnectDetails->PinId], DeviceObject);
+ if (!NT_SUCCESS(Status))
+ {
+ Pin->Release();
+ return Status;
+ }
+
+ // store pin
+ m_Pins[ConnectDetails->PinId] = Pin;
+
+ // store result
+ *OutTarget = (IIrpTarget*)Pin;
+
+ // increment current instance count
+ m_Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount++;
+
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::DeviceIoControl(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return PcPropertyHandler(Irp, m_Descriptor);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::Read(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::Write(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::Flush(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::Close(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::QuerySecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::SetSecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+BOOLEAN
+NTAPI
+CPortFilterDMus::FastDeviceIoControl(
+ IN PFILE_OBJECT FileObject,
+ IN BOOLEAN Wait,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferLength,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferLength,
+ IN ULONG IoControlCode,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterDMus::FastRead(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ UNIMPLEMENTED
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterDMus::FastWrite(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ UNIMPLEMENTED
+ return FALSE;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::Init(
+ IN IPortDMus* Port)
+{
+ ISubdevice * ISubDevice;
+ NTSTATUS Status;
+
+ m_Port = Port;
+
+ // get our private interface
+ Status = m_Port->QueryInterface(IID_ISubdevice, (PVOID*)&ISubDevice);
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // get the subdevice descriptor
+ Status = ISubDevice->GetDescriptor(&m_Descriptor);
+
+ // release subdevice interface
+ ISubDevice->Release();
+
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // allocate pin array
+ m_Pins = (IPortPinDMus**)AllocateItem(NonPagedPool, m_Descriptor->Factory.PinDescriptorCount * sizeof(IPortPinDMus*), TAG_PORTCLASS);
+
+ if (!m_Pins)
+ return STATUS_UNSUCCESSFUL;
+
+ // increment reference count
+ Port->AddRef();
+
+ return STATUS_SUCCESS;
+}
+
+
+NTSTATUS
+NTAPI
+CPortFilterDMus::FreePin(
+ IN struct IPortPinDMus* Pin)
+{
+ ULONG Index;
+
+ for(Index = 0; Index < m_Descriptor->Factory.PinDescriptorCount; Index++)
+ {
+ if (m_Pins[Index] == Pin)
+ {
+ m_Pins[Index]->Release();
+ m_Pins[Index] = NULL;
+ return STATUS_SUCCESS;
+ }
+ }
+ return STATUS_UNSUCCESSFUL;
+}
+
+VOID
+NTAPI
+CPortFilterDMus::NotifyPins()
+{
+ ULONG Index;
+
+ DPRINT("Notifying %u pins\n", m_Descriptor->Factory.PinDescriptorCount);
+
+ for(Index = 0; Index < m_Descriptor->Factory.PinDescriptorCount; Index++)
+ {
+ m_Pins[Index]->Notify();
+ }
+}
+
+
+NTSTATUS
+NewPortFilterDMus(
+ OUT PPORTFILTERDMUS * OutFilter)
+{
+ CPortFilterDMus * This;
+
+ This = new(NonPagedPool, TAG_PORTCLASS) CPortFilterDMus(NULL);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ This->AddRef();
+
+ // return result
+ *OutFilter = (CPortFilterDMus*)This;
+
+ return STATUS_SUCCESS;
+}
+
+
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/filter_topology.c
- * PURPOSE: portcls topology filter
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-typedef struct
-{
- IPortFilterTopologyVtbl *lpVtbl;
-
- LONG ref;
-
- IPortTopology* Port;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- ISubdevice *SubDevice;
-
-}IPortFilterTopologyImpl;
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnQueryInterface(
- IPortFilterTopology* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortFilterTopologyImpl * This = (IPortFilterTopologyImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IIrpTarget) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- else if (IsEqualGUIDAligned(refiid, &IID_IPort))
- {
- *Output = This->Port;
- This->Port->lpVtbl->AddRef(This->Port);
- return STATUS_SUCCESS;
- }
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterTopology_fnAddRef(
- IPortFilterTopology* iface)
-{
- IPortFilterTopologyImpl * This = (IPortFilterTopologyImpl*)iface;
-
- return InterlockedIncrement(&This->ref);
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterTopology_fnRelease(
- IPortFilterTopology* iface)
-{
- IPortFilterTopologyImpl * This = (IPortFilterTopologyImpl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- return This->ref;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnNewIrpTarget(
- IN IPortFilterTopology* iface,
- OUT struct IIrpTarget **OutTarget,
- IN WCHAR * Name,
- IN PUNKNOWN Unknown,
- IN POOL_TYPE PoolType,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN KSOBJECT_CREATE *CreateObject)
-{
- DPRINT("IPortFilterTopology_fnNewIrpTarget entered\n");
-
- return STATUS_NOT_SUPPORTED;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnDeviceIoControl(
- IN IPortFilterTopology* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- PIO_STACK_LOCATION IoStack;
- IPortFilterTopologyImpl * This = (IPortFilterTopologyImpl *)iface;
-
- IoStack = IoGetCurrentIrpStackLocation(Irp);
- ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY);
-
- return PcPropertyHandler(Irp, This->Descriptor);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnRead(
- IN IPortFilterTopology* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnWrite(
- IN IPortFilterTopology* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnFlush(
- IN IPortFilterTopology* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnClose(
- IN IPortFilterTopology* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- NTSTATUS Status = STATUS_SUCCESS;
- IPortFilterTopologyImpl * This = (IPortFilterTopologyImpl *)iface;
-
- /* FIXME handle DirectSound */
-
- if (This->ref == 1)
- {
- /* release reference to port */
- This->SubDevice->lpVtbl->Release(This->SubDevice);
-
- /* time to shutdown the audio system */
- Status = This->SubDevice->lpVtbl->ReleaseChildren(This->SubDevice);
- }
-
- Irp->IoStatus.Status = Status;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
- return STATUS_SUCCESS;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnQuerySecurity(
- IN IPortFilterTopology* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnSetSecurity(
- IN IPortFilterTopology* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterTopology_fnFastDeviceIoControl(
- IN IPortFilterTopology* iface,
- IN PFILE_OBJECT FileObject,
- IN BOOLEAN Wait,
- IN PVOID InputBuffer,
- IN ULONG InputBufferLength,
- OUT PVOID OutputBuffer,
- IN ULONG OutputBufferLength,
- IN ULONG IoControlCode,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- ULONG Index;
- PKSPROPERTY Property;
- IPortFilterTopologyImpl * This = (IPortFilterTopologyImpl*)iface;
-
- Property = (PKSPROPERTY)InputBuffer;
-
- if (InputBufferLength < sizeof(KSPROPERTY))
- return FALSE;
-
- for(Index = 0; Index < This->Descriptor->FilterPropertySet.FreeKsPropertySetOffset; Index++)
- {
- if (IsEqualGUIDAligned(&Property->Set, This->Descriptor->FilterPropertySet.Properties[Index].Set))
- {
- FastPropertyHandler(FileObject, (PKSPROPERTY)InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength, StatusBlock,
- 1,
- &This->Descriptor->FilterPropertySet.Properties[Index],
- This->Descriptor, This->SubDevice);
- }
- }
- return TRUE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterTopology_fnFastRead(
- IN IPortFilterTopology* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- return FALSE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterTopology_fnFastWrite(
- IN IPortFilterTopology* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- return FALSE;
-}
-
-/*
- * @implemented
- */
-static
-NTSTATUS
-NTAPI
-IPortFilterTopology_fnInit(
- IN IPortFilterTopology* iface,
- IN IPortTopology* Port)
-{
- ISubdevice * ISubDevice;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- NTSTATUS Status;
- IPortFilterTopologyImpl * This = (IPortFilterTopologyImpl*)iface;
-
- /* get our private interface */
- Status = Port->lpVtbl->QueryInterface(Port, &IID_ISubdevice, (PVOID*)&ISubDevice);
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* get the subdevice descriptor */
- Status = ISubDevice->lpVtbl->GetDescriptor(ISubDevice, &Descriptor);
-
- /* store subdevice interface */
- This->SubDevice = ISubDevice;
-
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* save descriptor */
- This->Descriptor = Descriptor;
-
- /* store port object */
- This->Port = Port;
-
- return STATUS_SUCCESS;
-}
-
-static IPortFilterTopologyVtbl vt_IPortFilterTopology =
-{
- IPortFilterTopology_fnQueryInterface,
- IPortFilterTopology_fnAddRef,
- IPortFilterTopology_fnRelease,
- IPortFilterTopology_fnNewIrpTarget,
- IPortFilterTopology_fnDeviceIoControl,
- IPortFilterTopology_fnRead,
- IPortFilterTopology_fnWrite,
- IPortFilterTopology_fnFlush,
- IPortFilterTopology_fnClose,
- IPortFilterTopology_fnQuerySecurity,
- IPortFilterTopology_fnSetSecurity,
- IPortFilterTopology_fnFastDeviceIoControl,
- IPortFilterTopology_fnFastRead,
- IPortFilterTopology_fnFastWrite,
- IPortFilterTopology_fnInit
-};
-
-NTSTATUS
-NewPortFilterTopology(
- OUT IPortFilterTopology ** OutFilter)
-{
- IPortFilterTopologyImpl * This;
-
- This = AllocateItem(NonPagedPool, sizeof(IPortFilterTopologyImpl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- /* initialize IPortFilterTopology */
- This->ref = 1;
- This->lpVtbl = &vt_IPortFilterTopology;
-
- /* return result */
- *OutFilter = (IPortFilterTopology*)&This->lpVtbl;
-
- return STATUS_SUCCESS;
-}
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/filter_topology.c
+ * PURPOSE: portcls topology filter
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+class CPortFilterTopology : public IPortFilterTopology
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IPortFilterTopology;
+ CPortFilterTopology(IUnknown *OuterUnknown){}
+ virtual ~CPortFilterTopology(){}
+
+protected:
+ IPortTopology * m_Port;
+ SUBDEVICE_DESCRIPTOR * m_Descriptor;
+ ISubdevice * m_SubDevice;
+ LONG m_Ref;
+};
+
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+
+ if (IsEqualGUIDAligned(refiid, IID_IIrpTarget) ||
+ IsEqualGUIDAligned(refiid, IID_IUnknown))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+ else if (IsEqualGUIDAligned(refiid, IID_IPort))
+ {
+ *Output = PVOID(PUNKNOWN(m_Port));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::NewIrpTarget(
+ OUT struct IIrpTarget **OutTarget,
+ IN WCHAR * Name,
+ IN PUNKNOWN Unknown,
+ IN POOL_TYPE PoolType,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN KSOBJECT_CREATE *CreateObject)
+{
+ DPRINT("CPortFilterTopology::NewIrpTarget entered\n");
+
+ return STATUS_NOT_SUPPORTED;
+}
+
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::DeviceIoControl(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ PIO_STACK_LOCATION IoStack;
+
+ IoStack = IoGetCurrentIrpStackLocation(Irp);
+ PC_ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY);
+
+ return PcPropertyHandler(Irp, m_Descriptor);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::Read(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::Write(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::Flush(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::Close(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ NTSTATUS Status = STATUS_SUCCESS;
+
+ // FIXME handle DirectSound
+
+#if 0
+//FIXME
+ if (m_ref == 1)
+ {
+ // release reference to port
+ This->SubDevice->lpVtbl->Release(This->SubDevice);
+
+ // time to shutdown the audio system
+ Status = This->SubDevice->lpVtbl->ReleaseChildren(This->SubDevice);
+ }
+#endif
+
+ Irp->IoStatus.Status = Status;
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::QuerySecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::SetSecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+BOOLEAN
+NTAPI
+CPortFilterTopology::FastDeviceIoControl(
+ IN PFILE_OBJECT FileObject,
+ IN BOOLEAN Wait,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferLength,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferLength,
+ IN ULONG IoControlCode,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterTopology::FastRead(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterTopology::FastWrite(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterTopology::Init(
+ IN IPortTopology* Port)
+{
+ ISubdevice * ISubDevice;
+ SUBDEVICE_DESCRIPTOR * Descriptor;
+ NTSTATUS Status;
+
+
+ // get our private interface
+ Status = Port->QueryInterface(IID_ISubdevice, (PVOID*)&ISubDevice);
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // get the subdevice descriptor
+ Status = ISubDevice->GetDescriptor(&Descriptor);
+
+ // store subdevice interface
+ m_SubDevice = ISubDevice;
+
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // save descriptor
+ m_Descriptor = Descriptor;
+
+ // store port object
+ m_Port = Port;
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NewPortFilterTopology(
+ OUT IPortFilterTopology ** OutFilter)
+{
+ CPortFilterTopology * This;
+
+ This = new(NonPagedPool, TAG_PORTCLASS)CPortFilterTopology(NULL);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ This->AddRef();
+
+ // return result
+ *OutFilter = (CPortFilterTopology*)This;
+
+ return STATUS_SUCCESS;
+}
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/filter_wavecyclic.c
- * PURPOSE: portcls wave cyclic filter
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-typedef struct
-{
- IPortFilterWaveCyclicVtbl *lpVtbl;
-
- LONG ref;
-
- IPortWaveCyclic* Port;
- IPortPinWaveCyclic ** Pins;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- ISubdevice * SubDevice;
-
-}IPortFilterWaveCyclicImpl;
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnQueryInterface(
- IPortFilterWaveCyclic* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortFilterWaveCyclicImpl * This = (IPortFilterWaveCyclicImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IIrpTarget) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- else if (IsEqualGUIDAligned(refiid, &IID_IPort))
- {
- *Output = This->Port;
- This->Port->lpVtbl->AddRef(This->Port);
- return STATUS_SUCCESS;
- }
-
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterWaveCyclic_fnAddRef(
- IPortFilterWaveCyclic* iface)
-{
- IPortFilterWaveCyclicImpl * This = (IPortFilterWaveCyclicImpl*)iface;
-
- return InterlockedIncrement(&This->ref);
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterWaveCyclic_fnRelease(
- IPortFilterWaveCyclic* iface)
-{
- IPortFilterWaveCyclicImpl * This = (IPortFilterWaveCyclicImpl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- return This->ref;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnNewIrpTarget(
- IN IPortFilterWaveCyclic* iface,
- OUT struct IIrpTarget **OutTarget,
- IN WCHAR * Name,
- IN PUNKNOWN Unknown,
- IN POOL_TYPE PoolType,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN KSOBJECT_CREATE *CreateObject)
-{
- NTSTATUS Status;
- IPortPinWaveCyclic * Pin;
- PKSPIN_CONNECT ConnectDetails;
- IPortFilterWaveCyclicImpl * This = (IPortFilterWaveCyclicImpl *)iface;
-
- ASSERT(This->Port);
- ASSERT(This->Descriptor);
- ASSERT(This->Pins);
-
- DPRINT("IPortFilterWaveCyclic_fnNewIrpTarget entered\n");
-
- /* let's verify the connection request */
- Status = PcValidateConnectRequest(Irp, &This->Descriptor->Factory, &ConnectDetails);
- if (!NT_SUCCESS(Status))
- {
- return STATUS_UNSUCCESSFUL;
- }
-
- if (This->Pins[ConnectDetails->PinId] &&
- (This->Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount == This->Descriptor->Factory.Instances[ConnectDetails->PinId].MaxFilterInstanceCount))
- {
- /* release existing instance */
- return STATUS_UNSUCCESSFUL;
- }
-
- /* now create the pin */
- Status = NewPortPinWaveCyclic(&Pin);
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
-
- /* initialize the pin */
- Status = Pin->lpVtbl->Init(Pin, This->Port, iface, ConnectDetails, &This->Descriptor->Factory.KsPinDescriptor[ConnectDetails->PinId]);
- if (!NT_SUCCESS(Status))
- {
- Pin->lpVtbl->Release(Pin);
- return Status;
- }
-
- /* store pin */
- This->Pins[ConnectDetails->PinId] = Pin;
-
- /* store result */
- *OutTarget = (IIrpTarget*)Pin;
-
- /* increment current instance count */
- This->Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount++;
-
- return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnDeviceIoControl(
- IN IPortFilterWaveCyclic* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- PIO_STACK_LOCATION IoStack;
- IPortFilterWaveCyclicImpl * This = (IPortFilterWaveCyclicImpl *)iface;
-
- IoStack = IoGetCurrentIrpStackLocation(Irp);
-
- if (IoStack->Parameters.DeviceIoControl.IoControlCode != IOCTL_KS_PROPERTY)
- {
- DPRINT1("Unhandled function %lx Length %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode, IoStack->Parameters.DeviceIoControl.InputBufferLength);
-
- Irp->IoStatus.Status = STATUS_SUCCESS;
-
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
- return STATUS_SUCCESS;
- }
-
-
- ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY);
-
- return PcPropertyHandler(Irp, This->Descriptor);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnRead(
- IN IPortFilterWaveCyclic* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnWrite(
- IN IPortFilterWaveCyclic* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnFlush(
- IN IPortFilterWaveCyclic* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnClose(
- IN IPortFilterWaveCyclic* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- ULONG Index;
- NTSTATUS Status = STATUS_SUCCESS;
- IPortFilterWaveCyclicImpl * This = (IPortFilterWaveCyclicImpl *)iface;
-
- DPRINT("IPortFilterWaveCyclic_fnClose ref %u\n", This->ref);
-
- if (This->ref == 1)
- {
- for(Index = 0; Index < This->Descriptor->Factory.PinDescriptorCount; Index++)
- {
- /* all pins should have been closed by now */
- ASSERT(This->Pins[Index] == NULL);
- }
-
- /* release reference to port */
- This->SubDevice->lpVtbl->Release(This->SubDevice);
-
- /* time to shutdown the audio system */
- Status = This->SubDevice->lpVtbl->ReleaseChildren(This->SubDevice);
- }
-
- Irp->IoStatus.Status = Status;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
- return STATUS_SUCCESS;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnQuerySecurity(
- IN IPortFilterWaveCyclic* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnSetSecurity(
- IN IPortFilterWaveCyclic* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWaveCyclic_fnFastDeviceIoControl(
- IN IPortFilterWaveCyclic* iface,
- IN PFILE_OBJECT FileObject,
- IN BOOLEAN Wait,
- IN PVOID InputBuffer,
- IN ULONG InputBufferLength,
- OUT PVOID OutputBuffer,
- IN ULONG OutputBufferLength,
- IN ULONG IoControlCode,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWaveCyclic_fnFastRead(
- IN IPortFilterWaveCyclic* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWaveCyclic_fnFastWrite(
- IN IPortFilterWaveCyclic* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-static
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnInit(
- IN IPortFilterWaveCyclic* iface,
- IN IPortWaveCyclic* Port)
-{
- ISubdevice * ISubDevice;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- NTSTATUS Status;
- IPortFilterWaveCyclicImpl * This = (IPortFilterWaveCyclicImpl*)iface;
-
- /* get our private interface */
- Status = Port->lpVtbl->QueryInterface(Port, &IID_ISubdevice, (PVOID*)&ISubDevice);
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* get the subdevice descriptor */
- Status = ISubDevice->lpVtbl->GetDescriptor(ISubDevice, &Descriptor);
-
- /* store subdevice interface */
- This->SubDevice = ISubDevice;
-
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* save descriptor */
- This->Descriptor = Descriptor;
-
- /* allocate pin array */
- This->Pins = AllocateItem(NonPagedPool, Descriptor->Factory.PinDescriptorCount * sizeof(IPortPinWaveCyclic*), TAG_PORTCLASS);
-
- if (!This->Pins)
- return STATUS_UNSUCCESSFUL;
-
- /* store port driver */
- This->Port = Port;
-
- return STATUS_SUCCESS;
-}
-
-
-static
-NTSTATUS
-NTAPI
-IPortFilterWaveCyclic_fnFreePin(
- IN IPortFilterWaveCyclic* iface,
- IN struct IPortPinWaveCyclic* Pin)
-{
- ULONG Index;
- IPortFilterWaveCyclicImpl * This = (IPortFilterWaveCyclicImpl*)iface;
-
- for(Index = 0; Index < This->Descriptor->Factory.PinDescriptorCount; Index++)
- {
- if (This->Pins[Index] == Pin)
- {
- This->Descriptor->Factory.Instances[Index].CurrentPinInstanceCount--;
- This->Pins[Index]->lpVtbl->Release(This->Pins[Index]);
- This->Pins[Index] = NULL;
- return STATUS_SUCCESS;
- }
- }
- return STATUS_UNSUCCESSFUL;
-}
-
-static IPortFilterWaveCyclicVtbl vt_IPortFilterWaveCyclic =
-{
- IPortFilterWaveCyclic_fnQueryInterface,
- IPortFilterWaveCyclic_fnAddRef,
- IPortFilterWaveCyclic_fnRelease,
- IPortFilterWaveCyclic_fnNewIrpTarget,
- IPortFilterWaveCyclic_fnDeviceIoControl,
- IPortFilterWaveCyclic_fnRead,
- IPortFilterWaveCyclic_fnWrite,
- IPortFilterWaveCyclic_fnFlush,
- IPortFilterWaveCyclic_fnClose,
- IPortFilterWaveCyclic_fnQuerySecurity,
- IPortFilterWaveCyclic_fnSetSecurity,
- IPortFilterWaveCyclic_fnFastDeviceIoControl,
- IPortFilterWaveCyclic_fnFastRead,
- IPortFilterWaveCyclic_fnFastWrite,
- IPortFilterWaveCyclic_fnInit,
- IPortFilterWaveCyclic_fnFreePin
-};
-
-NTSTATUS
-NewPortFilterWaveCyclic(
- OUT IPortFilterWaveCyclic ** OutFilter)
-{
- IPortFilterWaveCyclicImpl * This;
-
- This = AllocateItem(NonPagedPool, sizeof(IPortFilterWaveCyclicImpl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- /* initialize IPortFilterWaveCyclic */
- This->ref = 1;
- This->lpVtbl = &vt_IPortFilterWaveCyclic;
-
- /* return result */
- *OutFilter = (IPortFilterWaveCyclic*)&This->lpVtbl;
-
- return STATUS_SUCCESS;
-}
-
-
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/filter_wavecyclic.c
+ * PURPOSE: portcls wave cyclic filter
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+class CPortFilterWaveCyclic : public IPortFilterWaveCyclic
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IPortFilterWaveCyclic;
+ CPortFilterWaveCyclic(IUnknown *OuterUnknown){}
+ virtual ~CPortFilterWaveCyclic(){}
+
+protected:
+ IPortWaveCyclic* m_Port;
+ IPortPinWaveCyclic ** m_Pins;
+ SUBDEVICE_DESCRIPTOR * m_Descriptor;
+ ISubdevice * m_SubDevice;
+ LONG m_Ref;
+};
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+ if (IsEqualGUIDAligned(refiid, IID_IIrpTarget) ||
+ IsEqualGUIDAligned(refiid, IID_IUnknown))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+ else if (IsEqualGUIDAligned(refiid, IID_IPort))
+ {
+ *Output = PUNKNOWN(m_Port);
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::NewIrpTarget(
+ OUT struct IIrpTarget **OutTarget,
+ IN WCHAR * Name,
+ IN PUNKNOWN Unknown,
+ IN POOL_TYPE PoolType,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN KSOBJECT_CREATE *CreateObject)
+{
+ NTSTATUS Status;
+ IPortPinWaveCyclic * Pin;
+ PKSPIN_CONNECT ConnectDetails;
+
+#if 0
+ ASSERT(m_Port);
+ ASSERT(m_Descriptor);
+ ASSERT(m_Pins);
+#endif
+
+ DPRINT("CPortFilterWaveCyclic::NewIrpTarget entered\n");
+
+ // let's verify the connection request
+ Status = PcValidateConnectRequest(Irp, &m_Descriptor->Factory, &ConnectDetails);
+ if (!NT_SUCCESS(Status))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ if (m_Pins[ConnectDetails->PinId] &&
+ (m_Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount == m_Descriptor->Factory.Instances[ConnectDetails->PinId].MaxFilterInstanceCount))
+ {
+ // release existing instance
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ // now create the pin
+ Status = NewPortPinWaveCyclic(&Pin);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+
+ // initialize the pin
+ Status = Pin->Init(m_Port, this, ConnectDetails, &m_Descriptor->Factory.KsPinDescriptor[ConnectDetails->PinId]);
+ if (!NT_SUCCESS(Status))
+ {
+ Pin->Release();
+ return Status;
+ }
+
+ // store pin
+ m_Pins[ConnectDetails->PinId] = Pin;
+
+ // store result
+ *OutTarget = (IIrpTarget*)Pin;
+
+ // increment current instance count
+ m_Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount++;
+
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::DeviceIoControl(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ PIO_STACK_LOCATION IoStack;
+
+ IoStack = IoGetCurrentIrpStackLocation(Irp);
+
+ if (IoStack->Parameters.DeviceIoControl.IoControlCode != IOCTL_KS_PROPERTY)
+ {
+ DPRINT1("Unhandled function %lx Length %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode, IoStack->Parameters.DeviceIoControl.InputBufferLength);
+
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+ return STATUS_SUCCESS;
+ }
+
+ PC_ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY);
+
+ return PcPropertyHandler(Irp, m_Descriptor);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::Read(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::Write(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::Flush(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::Close(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ //ULONG Index;
+ NTSTATUS Status = STATUS_SUCCESS;
+
+#if 0
+ if (m_ref == 1)
+ {
+ for(Index = 0; Index < m_Descriptor->Factory.PinDescriptorCount; Index++)
+ {
+ // all pins should have been closed by now
+ ASSERT(m_Pins[Index] == NULL);
+ }
+
+ // release reference to port
+ m_SubDevice->Release(m_SubDevice);
+
+ // time to shutdown the audio system
+ Status = m_SubDevice->ReleaseChildren(m_SubDevice);
+ }
+#endif
+
+ Irp->IoStatus.Status = Status;
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::QuerySecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::SetSecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWaveCyclic::FastDeviceIoControl(
+ IN PFILE_OBJECT FileObject,
+ IN BOOLEAN Wait,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferLength,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferLength,
+ IN ULONG IoControlCode,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ UNIMPLEMENTED
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWaveCyclic::FastRead(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ UNIMPLEMENTED
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWaveCyclic::FastWrite(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ UNIMPLEMENTED
+ return FALSE;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::Init(
+ IN IPortWaveCyclic* Port)
+{
+ ISubdevice * ISubDevice;
+ SUBDEVICE_DESCRIPTOR * Descriptor;
+ NTSTATUS Status;
+
+ // get our private interface
+ Status = Port->QueryInterface(IID_ISubdevice, (PVOID*)&ISubDevice);
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // get the subdevice descriptor
+ Status = ISubDevice->GetDescriptor(&Descriptor);
+
+ // store subdevice interface
+ m_SubDevice = ISubDevice;
+
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // save descriptor
+ m_Descriptor = Descriptor;
+
+ // allocate pin array
+ m_Pins = (IPortPinWaveCyclic**)AllocateItem(NonPagedPool, Descriptor->Factory.PinDescriptorCount * sizeof(IPortPinWaveCyclic*), TAG_PORTCLASS);
+
+ if (!m_Pins)
+ return STATUS_UNSUCCESSFUL;
+
+ // store port driver
+ m_Port = Port;
+
+ return STATUS_SUCCESS;
+}
+
+
+NTSTATUS
+NTAPI
+CPortFilterWaveCyclic::FreePin(
+ IN struct IPortPinWaveCyclic* Pin)
+{
+ ULONG Index;
+
+ for(Index = 0; Index < m_Descriptor->Factory.PinDescriptorCount; Index++)
+ {
+ if (m_Pins[Index] == Pin)
+ {
+ m_Descriptor->Factory.Instances[Index].CurrentPinInstanceCount--;
+ m_Pins[Index]->Release();
+ m_Pins[Index] = NULL;
+ return STATUS_SUCCESS;
+ }
+ }
+ return STATUS_UNSUCCESSFUL;
+}
+
+
+NTSTATUS
+NewPortFilterWaveCyclic(
+ OUT IPortFilterWaveCyclic ** OutFilter)
+{
+ CPortFilterWaveCyclic * This;
+
+ This = new(NonPagedPool, TAG_PORTCLASS)CPortFilterWaveCyclic(NULL);
+
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ This->AddRef();
+
+ // return result
+ *OutFilter = (IPortFilterWaveCyclic*)This;
+
+ return STATUS_SUCCESS;
+}
+
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/filter_wavepci.c
- * PURPOSE: portcls wave pci filter
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-typedef struct
-{
- IPortFilterWavePciVtbl *lpVtbl;
-
- LONG ref;
-
- IPortWavePci* Port;
- IPortPinWavePci ** Pins;
- SUBDEVICE_DESCRIPTOR * Descriptor;
-
-}IPortFilterWavePciImpl;
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnQueryInterface(
- IPortFilterWavePci* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortFilterWavePciImpl * This = (IPortFilterWavePciImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IIrpTarget) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- else if (IsEqualGUIDAligned(refiid, &IID_IPort))
- {
- *Output = This->Port;
- This->Port->lpVtbl->AddRef(This->Port);
- return STATUS_SUCCESS;
- }
-
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterWavePci_fnAddRef(
- IPortFilterWavePci* iface)
-{
- IPortFilterWavePciImpl * This = (IPortFilterWavePciImpl*)iface;
-
- return InterlockedIncrement(&This->ref);
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterWavePci_fnRelease(
- IPortFilterWavePci* iface)
-{
- IPortFilterWavePciImpl * This = (IPortFilterWavePciImpl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- return This->ref;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnNewIrpTarget(
- IN IPortFilterWavePci* iface,
- OUT struct IIrpTarget **OutTarget,
- IN WCHAR * Name,
- IN PUNKNOWN Unknown,
- IN POOL_TYPE PoolType,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN KSOBJECT_CREATE *CreateObject)
-{
- NTSTATUS Status;
- IPortPinWavePci * Pin;
- PKSPIN_CONNECT ConnectDetails;
- IPortFilterWavePciImpl * This = (IPortFilterWavePciImpl *)iface;
-
- ASSERT(This->Port);
- ASSERT(This->Descriptor);
- ASSERT(This->Pins);
-
- DPRINT("IPortFilterWavePci_fnNewIrpTarget entered\n");
-
- /* let's verify the connection request */
- Status = PcValidateConnectRequest(Irp, &This->Descriptor->Factory, &ConnectDetails);
- if (!NT_SUCCESS(Status))
- {
- return STATUS_UNSUCCESSFUL;
- }
-
- if (This->Pins[ConnectDetails->PinId] && This->Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount)
- {
- /* release existing instance */
- ASSERT(0);
- This->Pins[ConnectDetails->PinId]->lpVtbl->Close(This->Pins[ConnectDetails->PinId], DeviceObject, NULL);
- }
-
- /* now create the pin */
- Status = NewPortPinWavePci(&Pin);
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
-
- /* initialize the pin */
- Status = Pin->lpVtbl->Init(Pin, This->Port, iface, ConnectDetails, &This->Descriptor->Factory.KsPinDescriptor[ConnectDetails->PinId], GetDeviceObjectFromPortWavePci(This->Port));
- if (!NT_SUCCESS(Status))
- {
- Pin->lpVtbl->Release(Pin);
- return Status;
- }
-
- /* store pin */
- This->Pins[ConnectDetails->PinId] = Pin;
-
- /* store result */
- *OutTarget = (IIrpTarget*)Pin;
-
- /* increment current instance count */
- This->Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount++;
-
- return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnDeviceIoControl(
- IN IPortFilterWavePci* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- PIO_STACK_LOCATION IoStack;
- ISubdevice *SubDevice = NULL;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- NTSTATUS Status;
- IPortFilterWavePciImpl * This = (IPortFilterWavePciImpl *)iface;
-
- IoStack = IoGetCurrentIrpStackLocation(Irp);
- ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY);
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&SubDevice);
- ASSERT(Status == STATUS_SUCCESS);
- ASSERT(SubDevice != NULL);
-
- Status = SubDevice->lpVtbl->GetDescriptor(SubDevice, &Descriptor);
- ASSERT(Status == STATUS_SUCCESS);
- ASSERT(Descriptor != NULL);
-
- SubDevice->lpVtbl->Release(SubDevice);
-
- return PcPropertyHandler(Irp, Descriptor);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnRead(
- IN IPortFilterWavePci* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnWrite(
- IN IPortFilterWavePci* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnFlush(
- IN IPortFilterWavePci* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnClose(
- IN IPortFilterWavePci* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- ULONG Index;
- IPortFilterWavePciImpl * This = (IPortFilterWavePciImpl *)iface;
-
- for(Index = 0; Index < This->Descriptor->Factory.PinDescriptorCount; Index++)
- {
- if (This->Pins[Index])
- {
- This->Pins[Index]->lpVtbl->Close(This->Pins[Index], DeviceObject, NULL);
- }
- }
-
-
- Irp->IoStatus.Status = STATUS_SUCCESS;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnQuerySecurity(
- IN IPortFilterWavePci* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnSetSecurity(
- IN IPortFilterWavePci* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWavePci_fnFastDeviceIoControl(
- IN IPortFilterWavePci* iface,
- IN PFILE_OBJECT FileObject,
- IN BOOLEAN Wait,
- IN PVOID InputBuffer,
- IN ULONG InputBufferLength,
- OUT PVOID OutputBuffer,
- IN ULONG OutputBufferLength,
- IN ULONG IoControlCode,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- ULONG Index;
- PKSPROPERTY Property;
- NTSTATUS Status;
- ISubdevice * SubDevice = NULL;
- PSUBDEVICE_DESCRIPTOR Descriptor = NULL;
- IPortFilterWavePciImpl * This = (IPortFilterWavePciImpl *)iface;
-
- Property = (PKSPROPERTY)InputBuffer;
-
- if (InputBufferLength < sizeof(KSPROPERTY))
- return FALSE;
-
-
- /* get private interface */
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&SubDevice);
- if (!NT_SUCCESS(Status))
- return FALSE;
-
- /* get descriptor */
- Status = SubDevice->lpVtbl->GetDescriptor(SubDevice, &Descriptor);
- if (!NT_SUCCESS(Status))
- {
- SubDevice->lpVtbl->Release(SubDevice);
- return FALSE;
- }
-
- for(Index = 0; Index < Descriptor->FilterPropertySet.FreeKsPropertySetOffset; Index++)
- {
- if (IsEqualGUIDAligned(&Property->Set, Descriptor->FilterPropertySet.Properties[Index].Set))
- {
- FastPropertyHandler(FileObject, (PKSPROPERTY)InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength, StatusBlock,
- 1,
- &Descriptor->FilterPropertySet.Properties[Index],
- Descriptor, SubDevice);
- }
- }
- return TRUE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWavePci_fnFastRead(
- IN IPortFilterWavePci* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWavePci_fnFastWrite(
- IN IPortFilterWavePci* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-static
-NTSTATUS
-NTAPI
-IPortFilterWavePci_fnInit(
- IN IPortFilterWavePci* iface,
- IN IPortWavePci* Port)
-{
- ISubdevice * ISubDevice;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- NTSTATUS Status;
- IPortFilterWavePciImpl * This = (IPortFilterWavePciImpl*)iface;
-
- This->Port = Port;
-
- /* get our private interface */
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&ISubDevice);
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* get the subdevice descriptor */
- Status = ISubDevice->lpVtbl->GetDescriptor(ISubDevice, &Descriptor);
-
- /* release subdevice interface */
- ISubDevice->lpVtbl->Release(ISubDevice);
-
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* save descriptor */
- This->Descriptor = Descriptor;
-
- /* allocate pin array */
- This->Pins = AllocateItem(NonPagedPool, Descriptor->Factory.PinDescriptorCount * sizeof(IPortPinWavePci*), TAG_PORTCLASS);
-
- if (!This->Pins)
- return STATUS_UNSUCCESSFUL;
-
- /* increment reference count */
- Port->lpVtbl->AddRef(Port);
-
- return STATUS_SUCCESS;
-}
-
-static IPortFilterWavePciVtbl vt_IPortFilterWavePci =
-{
- IPortFilterWavePci_fnQueryInterface,
- IPortFilterWavePci_fnAddRef,
- IPortFilterWavePci_fnRelease,
- IPortFilterWavePci_fnNewIrpTarget,
- IPortFilterWavePci_fnDeviceIoControl,
- IPortFilterWavePci_fnRead,
- IPortFilterWavePci_fnWrite,
- IPortFilterWavePci_fnFlush,
- IPortFilterWavePci_fnClose,
- IPortFilterWavePci_fnQuerySecurity,
- IPortFilterWavePci_fnSetSecurity,
- IPortFilterWavePci_fnFastDeviceIoControl,
- IPortFilterWavePci_fnFastRead,
- IPortFilterWavePci_fnFastWrite,
- IPortFilterWavePci_fnInit
-};
-
-NTSTATUS
-NewPortFilterWavePci(
- OUT IPortFilterWavePci ** OutFilter)
-{
- IPortFilterWavePciImpl * This;
-
- This = AllocateItem(NonPagedPool, sizeof(IPortFilterWavePciImpl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- /* initialize IPortFilterWavePci */
- This->ref = 1;
- This->lpVtbl = &vt_IPortFilterWavePci;
-
- /* return result */
- *OutFilter = (IPortFilterWavePci*)&This->lpVtbl;
-
- return STATUS_SUCCESS;
-}
-
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/filter_wavepci.cpp
+ * PURPOSE: portcls wave pci filter
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+class CPortFilterWavePci : public IPortFilterWavePci
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IPortFilterPci;
+ CPortFilterWavePci(IUnknown *OuterUnknown){}
+ virtual ~CPortFilterWavePci(){}
+
+protected:
+ IPortWavePci* m_Port;
+ IPortPinWavePci ** m_Pins;
+ SUBDEVICE_DESCRIPTOR * m_Descriptor;
+
+ LONG m_Ref;
+};
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::QueryInterface(
+
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+
+ if (IsEqualGUIDAligned(refiid, IID_IIrpTarget) ||
+ IsEqualGUIDAligned(refiid, IID_IUnknown))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+ else if (IsEqualGUIDAligned(refiid, IID_IPort))
+ {
+ *Output = PUNKNOWN(m_Port);
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::NewIrpTarget(
+ OUT struct IIrpTarget **OutTarget,
+ IN WCHAR * Name,
+ IN PUNKNOWN Unknown,
+ IN POOL_TYPE PoolType,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN KSOBJECT_CREATE *CreateObject)
+{
+ NTSTATUS Status;
+ IPortPinWavePci * Pin;
+ PKSPIN_CONNECT ConnectDetails;
+
+#if 0
+ ASSERT(m_Port);
+ ASSERT(m_Descriptor);
+ ASSERT(m_Pins);
+#endif
+
+ DPRINT("CPortFilterWavePci::NewIrpTarget entered\n");
+
+ // let's verify the connection request
+ Status = PcValidateConnectRequest(Irp, &m_Descriptor->Factory, &ConnectDetails);
+ if (!NT_SUCCESS(Status))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ if (m_Pins[ConnectDetails->PinId] && m_Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount)
+ {
+ // release existing instance
+ PC_ASSERT(0);
+ m_Pins[ConnectDetails->PinId]->Close(DeviceObject, NULL);
+ }
+
+ // now create the pin
+ Status = NewPortPinWavePci(&Pin);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+
+ // initialize the pin
+ Status = Pin->Init(m_Port, this, ConnectDetails, &m_Descriptor->Factory.KsPinDescriptor[ConnectDetails->PinId], GetDeviceObjectFromPortWavePci(m_Port));
+ if (!NT_SUCCESS(Status))
+ {
+ Pin->Release();
+ return Status;
+ }
+
+ // store pin
+ m_Pins[ConnectDetails->PinId] = Pin;
+
+ // store result
+ *OutTarget = (IIrpTarget*)Pin;
+
+ // increment current instance count
+ m_Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount++;
+
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::DeviceIoControl(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return PcPropertyHandler(Irp, m_Descriptor);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::Read(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::Write(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::Flush(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::Close(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::QuerySecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::SetSecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWavePci::FastDeviceIoControl(
+ IN PFILE_OBJECT FileObject,
+ IN BOOLEAN Wait,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferLength,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferLength,
+ IN ULONG IoControlCode,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWavePci::FastRead(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWavePci::FastWrite(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWavePci::Init(
+ IN IPortWavePci* Port)
+{
+ ISubdevice * ISubDevice;
+ SUBDEVICE_DESCRIPTOR * Descriptor;
+ NTSTATUS Status;
+
+ m_Port = Port;
+
+ // get our private interface
+ Status = m_Port->QueryInterface(IID_ISubdevice, (PVOID*)&ISubDevice);
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // get the subdevice descriptor
+ Status = ISubDevice->GetDescriptor(&Descriptor);
+
+ // release subdevice interface
+ ISubDevice->Release();
+
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // save descriptor
+ m_Descriptor = Descriptor;
+
+ // allocate pin array
+ m_Pins = (IPortPinWavePci**)AllocateItem(NonPagedPool, Descriptor->Factory.PinDescriptorCount * sizeof(IPortPinWavePci*), TAG_PORTCLASS);
+
+ if (!m_Pins)
+ return STATUS_UNSUCCESSFUL;
+
+ // increment reference count
+ Port->AddRef();
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NewPortFilterWavePci(
+ OUT IPortFilterWavePci ** OutFilter)
+{
+ CPortFilterWavePci * This;
+
+ This = new(NonPagedPool, TAG_PORTCLASS)CPortFilterWavePci(NULL);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ This->AddRef();
+
+ // return result
+ *OutFilter = (IPortFilterWavePci*)This;
+
+ return STATUS_SUCCESS;
+}
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/filter_wavert.c
- * PURPOSE: portcls wave RT filter
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-typedef struct
-{
- IPortFilterWaveRTVtbl *lpVtbl;
-
- LONG ref;
-
- IPortWaveRT* Port;
- IPortPinWaveRT ** Pins;
- SUBDEVICE_DESCRIPTOR * Descriptor;
-
-}IPortFilterWaveRTImpl;
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnQueryInterface(
- IPortFilterWaveRT* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortFilterWaveRTImpl * This = (IPortFilterWaveRTImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IIrpTarget) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- else if (IsEqualGUIDAligned(refiid, &IID_IPort))
- {
- *Output = This->Port;
- This->Port->lpVtbl->AddRef(This->Port);
- return STATUS_SUCCESS;
- }
-
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterWaveRT_fnAddRef(
- IPortFilterWaveRT* iface)
-{
- IPortFilterWaveRTImpl * This = (IPortFilterWaveRTImpl*)iface;
-
- return InterlockedIncrement(&This->ref);
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortFilterWaveRT_fnRelease(
- IPortFilterWaveRT* iface)
-{
- IPortFilterWaveRTImpl * This = (IPortFilterWaveRTImpl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- return This->ref;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnNewIrpTarget(
- IN IPortFilterWaveRT* iface,
- OUT struct IIrpTarget **OutTarget,
- IN WCHAR * Name,
- IN PUNKNOWN Unknown,
- IN POOL_TYPE PoolType,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN KSOBJECT_CREATE *CreateObject)
-{
- NTSTATUS Status;
- IPortPinWaveRT * Pin;
- PKSPIN_CONNECT ConnectDetails;
- IPortFilterWaveRTImpl * This = (IPortFilterWaveRTImpl *)iface;
-
- ASSERT(This->Port);
- ASSERT(This->Descriptor);
- ASSERT(This->Pins);
-
- DPRINT("IPortFilterWaveRT_fnNewIrpTarget entered\n");
-
- /* let's verify the connection request */
- Status = PcValidateConnectRequest(Irp, &This->Descriptor->Factory, &ConnectDetails);
- if (!NT_SUCCESS(Status))
- {
- return STATUS_UNSUCCESSFUL;
- }
-
- if (This->Pins[ConnectDetails->PinId] && This->Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount)
- {
- /* release existing instance */
- ASSERT(0);
- This->Pins[ConnectDetails->PinId]->lpVtbl->Close(This->Pins[ConnectDetails->PinId], DeviceObject, NULL);
- }
-
- /* now create the pin */
- Status = NewPortPinWaveRT(&Pin);
- if (!NT_SUCCESS(Status))
- {
- return Status;
- }
-
- /* initialize the pin */
- Status = Pin->lpVtbl->Init(Pin, This->Port, iface, ConnectDetails, &This->Descriptor->Factory.KsPinDescriptor[ConnectDetails->PinId], GetDeviceObjectFromPortWaveRT(This->Port));
- if (!NT_SUCCESS(Status))
- {
- Pin->lpVtbl->Release(Pin);
- return Status;
- }
-
- /* release existing pin */
- if (This->Pins[ConnectDetails->PinId])
- {
- This->Pins[ConnectDetails->PinId]->lpVtbl->Release(This->Pins[ConnectDetails->PinId]);
- }
- /* store pin */
- This->Pins[ConnectDetails->PinId] = Pin;
-
- /* store result */
- *OutTarget = (IIrpTarget*)Pin;
-
- /* increment current instance count */
- This->Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount++;
-
- return Status;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnDeviceIoControl(
- IN IPortFilterWaveRT* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- PIO_STACK_LOCATION IoStack;
- ISubdevice *SubDevice = NULL;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- NTSTATUS Status;
- IPortFilterWaveRTImpl * This = (IPortFilterWaveRTImpl *)iface;
-
- IoStack = IoGetCurrentIrpStackLocation(Irp);
- ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY);
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&SubDevice);
- ASSERT(Status == STATUS_SUCCESS);
- ASSERT(SubDevice != NULL);
-
- Status = SubDevice->lpVtbl->GetDescriptor(SubDevice, &Descriptor);
- ASSERT(Status == STATUS_SUCCESS);
- ASSERT(Descriptor != NULL);
-
- SubDevice->lpVtbl->Release(SubDevice);
-
- return PcPropertyHandler(Irp, Descriptor);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnRead(
- IN IPortFilterWaveRT* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnWrite(
- IN IPortFilterWaveRT* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnFlush(
- IN IPortFilterWaveRT* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnClose(
- IN IPortFilterWaveRT* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- ULONG Index;
- IPortFilterWaveRTImpl * This = (IPortFilterWaveRTImpl *)iface;
-
- for(Index = 0; Index < This->Descriptor->Factory.PinDescriptorCount; Index++)
- {
- if (This->Pins[Index])
- {
- This->Pins[Index]->lpVtbl->Close(This->Pins[Index], DeviceObject, NULL);
- }
- }
-
-
- Irp->IoStatus.Status = STATUS_SUCCESS;
- Irp->IoStatus.Information = 0;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnQuerySecurity(
- IN IPortFilterWaveRT* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnSetSecurity(
- IN IPortFilterWaveRT* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWaveRT_fnFastDeviceIoControl(
- IN IPortFilterWaveRT* iface,
- IN PFILE_OBJECT FileObject,
- IN BOOLEAN Wait,
- IN PVOID InputBuffer,
- IN ULONG InputBufferLength,
- OUT PVOID OutputBuffer,
- IN ULONG OutputBufferLength,
- IN ULONG IoControlCode,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- ULONG Index;
- PKSPROPERTY Property;
- NTSTATUS Status;
- ISubdevice * SubDevice = NULL;
- PSUBDEVICE_DESCRIPTOR Descriptor = NULL;
- IPortFilterWaveRTImpl * This = (IPortFilterWaveRTImpl *)iface;
-
- Property = (PKSPROPERTY)InputBuffer;
-
- if (InputBufferLength < sizeof(KSPROPERTY))
- return FALSE;
-
-
- /* get private interface */
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&SubDevice);
- if (!NT_SUCCESS(Status))
- return FALSE;
-
- /* get descriptor */
- Status = SubDevice->lpVtbl->GetDescriptor(SubDevice, &Descriptor);
- if (!NT_SUCCESS(Status))
- {
- SubDevice->lpVtbl->Release(SubDevice);
- return FALSE;
- }
-
- for(Index = 0; Index < Descriptor->FilterPropertySet.FreeKsPropertySetOffset; Index++)
- {
- if (IsEqualGUIDAligned(&Property->Set, Descriptor->FilterPropertySet.Properties[Index].Set))
- {
- FastPropertyHandler(FileObject, (PKSPROPERTY)InputBuffer, InputBufferLength, OutputBuffer, OutputBufferLength, StatusBlock,
- 1,
- &Descriptor->FilterPropertySet.Properties[Index],
- Descriptor, SubDevice);
- }
- }
- return TRUE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWaveRT_fnFastRead(
- IN IPortFilterWaveRT* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortFilterWaveRT_fnFastWrite(
- IN IPortFilterWaveRT* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-static
-NTSTATUS
-NTAPI
-IPortFilterWaveRT_fnInit(
- IN IPortFilterWaveRT* iface,
- IN IPortWaveRT* Port)
-{
- ISubdevice * ISubDevice;
- SUBDEVICE_DESCRIPTOR * Descriptor;
- NTSTATUS Status;
- IPortFilterWaveRTImpl * This = (IPortFilterWaveRTImpl*)iface;
-
- This->Port = Port;
-
- /* get our private interface */
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&ISubDevice);
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* get the subdevice descriptor */
- Status = ISubDevice->lpVtbl->GetDescriptor(ISubDevice, &Descriptor);
-
- /* release subdevice interface */
- ISubDevice->lpVtbl->Release(ISubDevice);
-
- if (!NT_SUCCESS(Status))
- return STATUS_UNSUCCESSFUL;
-
- /* save descriptor */
- This->Descriptor = Descriptor;
-
- /* allocate pin array */
- This->Pins = AllocateItem(NonPagedPool, Descriptor->Factory.PinDescriptorCount * sizeof(IPortPinWaveRT*), TAG_PORTCLASS);
-
- if (!This->Pins)
- return STATUS_UNSUCCESSFUL;
-
- /* increment reference count */
- Port->lpVtbl->AddRef(Port);
-
- return STATUS_SUCCESS;
-}
-
-static IPortFilterWaveRTVtbl vt_IPortFilterWaveRT =
-{
- IPortFilterWaveRT_fnQueryInterface,
- IPortFilterWaveRT_fnAddRef,
- IPortFilterWaveRT_fnRelease,
- IPortFilterWaveRT_fnNewIrpTarget,
- IPortFilterWaveRT_fnDeviceIoControl,
- IPortFilterWaveRT_fnRead,
- IPortFilterWaveRT_fnWrite,
- IPortFilterWaveRT_fnFlush,
- IPortFilterWaveRT_fnClose,
- IPortFilterWaveRT_fnQuerySecurity,
- IPortFilterWaveRT_fnSetSecurity,
- IPortFilterWaveRT_fnFastDeviceIoControl,
- IPortFilterWaveRT_fnFastRead,
- IPortFilterWaveRT_fnFastWrite,
- IPortFilterWaveRT_fnInit
-};
-
-NTSTATUS
-NewPortFilterWaveRT(
- OUT IPortFilterWaveRT ** OutFilter)
-{
- IPortFilterWaveRTImpl * This;
-
- This = AllocateItem(NonPagedPool, sizeof(IPortFilterWaveRTImpl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- /* initialize IPortFilterWaveRT */
- This->ref = 1;
- This->lpVtbl = &vt_IPortFilterWaveRT;
-
- /* return result */
- *OutFilter = (IPortFilterWaveRT*)&This->lpVtbl;
-
- return STATUS_SUCCESS;
-}
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/filter_wavert.cpp
+ * PURPOSE: portcls wave RT filter
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+class CPortFilterWaveRT : public IPortFilterWaveRT
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IPortFilterWaveRT;
+ CPortFilterWaveRT(IUnknown *OuterUnknown){}
+ virtual ~CPortFilterWaveRT(){}
+
+protected:
+
+
+ IPortWaveRT* m_Port;
+ IPortPinWaveRT ** m_Pins;
+ SUBDEVICE_DESCRIPTOR * m_Descriptor;
+ LONG m_Ref;
+};
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+ if (IsEqualGUIDAligned(refiid, IID_IIrpTarget) ||
+ IsEqualGUIDAligned(refiid, IID_IUnknown))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+ else if (IsEqualGUIDAligned(refiid, IID_IPort))
+ {
+ *Output = PUNKNOWN(m_Port);
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::NewIrpTarget(
+ OUT struct IIrpTarget **OutTarget,
+ IN WCHAR * Name,
+ IN PUNKNOWN Unknown,
+ IN POOL_TYPE PoolType,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp,
+ IN KSOBJECT_CREATE *CreateObject)
+{
+ NTSTATUS Status;
+ IPortPinWaveRT * Pin;
+ PKSPIN_CONNECT ConnectDetails;
+
+#if 0
+ ASSERT(m_Port);
+ ASSERT(m_Descriptor);
+ ASSERT(m_Pins);
+#endif
+
+ DPRINT("CPortFilterWaveRT::NewIrpTarget entered\n");
+
+ // let's verify the connection request
+ Status = PcValidateConnectRequest(Irp, &m_Descriptor->Factory, &ConnectDetails);
+ if (!NT_SUCCESS(Status))
+ {
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ if (m_Pins[ConnectDetails->PinId] && m_Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount)
+ {
+ // release existing instance
+ PC_ASSERT(0);
+ m_Pins[ConnectDetails->PinId]->Close(DeviceObject, NULL);
+ }
+
+ // now create the pin
+ Status = NewPortPinWaveRT(&Pin);
+ if (!NT_SUCCESS(Status))
+ {
+ return Status;
+ }
+
+ // initialize the pin
+ Status = Pin->Init(m_Port, this, ConnectDetails, &m_Descriptor->Factory.KsPinDescriptor[ConnectDetails->PinId], GetDeviceObjectFromPortWaveRT(m_Port));
+ if (!NT_SUCCESS(Status))
+ {
+ Pin->Release();
+ return Status;
+ }
+
+ // release existing pin
+ if (m_Pins[ConnectDetails->PinId])
+ {
+ m_Pins[ConnectDetails->PinId]->Release();
+ }
+ // store pin
+ m_Pins[ConnectDetails->PinId] = Pin;
+
+ // store result
+ *OutTarget = (IIrpTarget*)Pin;
+
+ // increment current instance count
+ m_Descriptor->Factory.Instances[ConnectDetails->PinId].CurrentPinInstanceCount++;
+
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::DeviceIoControl(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return PcPropertyHandler(Irp, m_Descriptor);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::Read(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::Write(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::Flush(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::Close(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+ Irp->IoStatus.Information = 0;
+ IoCompleteRequest(Irp, IO_NO_INCREMENT);
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::QuerySecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::SetSecurity(
+ IN PDEVICE_OBJECT DeviceObject,
+ IN PIRP Irp)
+{
+ return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWaveRT::FastDeviceIoControl(
+ IN PFILE_OBJECT FileObject,
+ IN BOOLEAN Wait,
+ IN PVOID InputBuffer,
+ IN ULONG InputBufferLength,
+ OUT PVOID OutputBuffer,
+ IN ULONG OutputBufferLength,
+ IN ULONG IoControlCode,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWaveRT::FastRead(
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+BOOLEAN
+NTAPI
+CPortFilterWaveRT::FastWrite(
+
+ IN PFILE_OBJECT FileObject,
+ IN PLARGE_INTEGER FileOffset,
+ IN ULONG Length,
+ IN BOOLEAN Wait,
+ IN ULONG LockKey,
+ IN PVOID Buffer,
+ OUT PIO_STATUS_BLOCK StatusBlock,
+ IN PDEVICE_OBJECT DeviceObject)
+{
+ return FALSE;
+}
+
+NTSTATUS
+NTAPI
+CPortFilterWaveRT::Init(
+ IN IPortWaveRT* Port)
+{
+ ISubdevice * ISubDevice;
+ SUBDEVICE_DESCRIPTOR * Descriptor;
+ NTSTATUS Status;
+
+ m_Port = Port;
+
+ // get our private interface
+ Status = m_Port->QueryInterface(IID_ISubdevice, (PVOID*)&ISubDevice);
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // get the subdevice descriptor
+ Status = ISubDevice->GetDescriptor(&Descriptor);
+
+ // release subdevice interface
+ ISubDevice->Release();
+
+ if (!NT_SUCCESS(Status))
+ return STATUS_UNSUCCESSFUL;
+
+ // save descriptor
+ m_Descriptor = Descriptor;
+
+ // allocate pin array
+ m_Pins = (IPortPinWaveRT**)AllocateItem(NonPagedPool, Descriptor->Factory.PinDescriptorCount * sizeof(IPortPinWaveRT*), TAG_PORTCLASS);
+
+ if (!m_Pins)
+ return STATUS_UNSUCCESSFUL;
+
+ // increment reference count
+ Port->AddRef();
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NewPortFilterWaveRT(
+ OUT IPortFilterWaveRT ** OutFilter)
+{
+ CPortFilterWaveRT * This;
+
+ This = new(NonPagedPool, TAG_PORTCLASS)CPortFilterWaveRT(NULL);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ This->AddRef();
+
+ // return result
+ *OutFilter = (CPortFilterWaveRT*)This;
+
+ return STATUS_SUCCESS;
+}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/guids.c
+ * FILE: drivers/wdm/audio/backpln/portcls/guids.cpp
* PURPOSE: portcls guid mess
* PROGRAMMER: Johannes Anderwald
*/
-#include "private.h"
+#include "private.hpp"
const GUID CLSID_PortTopology = {0xb4c90a32L, 0x5791, 0x11d0, {0x86, 0xf9, 0x00, 0xa0, 0xc9, 0x11, 0xb5, 0x44}};
const GUID CLSID_PortMidi = {0xb4c90a43L, 0x5791, 0x11d0, {0x86, 0xf9, 0x00, 0xa0, 0xc9, 0x11, 0xb5, 0x44}};
const GUID IID_IPortTopology = {0xb4c90a30L, 0x5791, 0x11d0, {0x86, 0xf9, 0x00, 0xa0, 0xc9, 0x11, 0xb5, 0x44}};
-const GUID CLSID_MiniportDriverDMusUART;
-const GUID CLSID_MiniportDriverUart;
-const GUID CLSID_MiniportDriverDMusUARTCapture;
-const GUID CLSID_MiniportDriverFmSynth;
-const GUID CLSID_MiniportDriverFmSynthWithVol;
+const GUID CLSID_MiniportDriverDMusUART = {0xd3f0ce1c, 0xfffc, 0x11d1, {0x81, 0xb0, 0x00, 0x60, 0x08, 0x33, 0x16, 0xc1}};
+const GUID CLSID_MiniportDriverDMusUARTCapture = {0xd3f0ce1d, 0xfffc, 0x11d1, {0x81, 0xb0, 0x00, 0x60, 0x08, 0x33, 0x16, 0xc1}};
+const GUID CLSID_MiniportDriverUart = {0xb4c90ae1L, 0x5791, 0x11d0, {0x86, 0xf9, 0x00, 0xa0, 0xc9, 0x11, 0xb5, 0x44}};
+
+const GUID CLSID_MiniportDriverFmSynth = {0xb4c90ae0L, 0x5791, 0x11d0, {0x86, 0xf9, 0x00, 0xa0, 0xc9, 0x11, 0xb5, 0x44}};
+const GUID CLSID_MiniportDriverFmSynthWithVol = {0xe5a3c139L, 0xf0f2, 0x11d1, {0x81, 0xaf, 0x00, 0x60, 0x08, 0x33, 0x16, 0xc1}};
+
const GUID IID_IPort = {0xb4c90a25L, 0x5791, 0x11d0, {0x86, 0xf9, 0x00, 0xa0, 0xc9, 0x11, 0xb5, 0x44}};
const GUID IID_IDrmPort = {0x286D3DF8L, 0xCA22, 0x4E2E, {0xB9, 0xBC, 0x20, 0xB4, 0xF0, 0xE2, 0x01, 0xCE}};
*****************************************************************************
*/
+#define IMP_IIrpTarget \
+ STDMETHODIMP_(NTSTATUS) NewIrpTarget(THIS_ \
+ OUT struct IIrpTarget **OutTarget, \
+ IN WCHAR * Name, \
+ IN PUNKNOWN Unknown, \
+ IN POOL_TYPE PoolType, \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp, \
+ IN KSOBJECT_CREATE *CreateObject); \
+ \
+ STDMETHODIMP_(NTSTATUS) DeviceIoControl(THIS_ \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp); \
+ \
+ STDMETHODIMP_(NTSTATUS) Read(THIS_ \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp); \
+ \
+ STDMETHODIMP_(NTSTATUS) Write(THIS_ \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp); \
+ \
+ STDMETHODIMP_(NTSTATUS) Flush(THIS_ \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp); \
+ \
+ STDMETHODIMP_(NTSTATUS) Close(THIS_ \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp); \
+ \
+ STDMETHODIMP_(NTSTATUS) QuerySecurity(THIS_ \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp); \
+ \
+ STDMETHODIMP_(NTSTATUS) SetSecurity(THIS_ \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp); \
+ \
+ STDMETHODIMP_(BOOLEAN) FastDeviceIoControl(THIS_ \
+ IN PFILE_OBJECT FileObject, \
+ IN BOOLEAN Wait, \
+ IN PVOID InputBuffer, \
+ IN ULONG InputBufferLength, \
+ OUT PVOID OutputBuffer, \
+ IN ULONG OutputBufferLength, \
+ IN ULONG IoControlCode, \
+ OUT PIO_STATUS_BLOCK StatusBlock, \
+ IN PDEVICE_OBJECT DeviceObject); \
+ \
+ STDMETHODIMP_(BOOLEAN) FastRead(THIS_ \
+ IN PFILE_OBJECT FileObject, \
+ IN PLARGE_INTEGER FileOffset, \
+ IN ULONG Length, \
+ IN BOOLEAN Wait, \
+ IN ULONG LockKey, \
+ IN PVOID Buffer, \
+ OUT PIO_STATUS_BLOCK StatusBlock, \
+ IN PDEVICE_OBJECT DeviceObject); \
+ \
+ STDMETHODIMP_(BOOLEAN) FastWrite(THIS_ \
+ IN PFILE_OBJECT FileObject, \
+ IN PLARGE_INTEGER FileOffset, \
+ IN ULONG Length, \
+ IN BOOLEAN Wait, \
+ IN ULONG LockKey, \
+ IN PVOID Buffer, \
+ OUT PIO_STATUS_BLOCK StatusBlock, \
+ IN PDEVICE_OBJECT DeviceObject)
+
#define DEFINE_ABSTRACT_IRPTARGET() \
STDMETHOD_(NTSTATUS, NewIrpTarget)(THIS_ \
OUT struct IIrpTarget **OutTarget, \
OUT PIO_STATUS_BLOCK StatusBlock, \
IN PDEVICE_OBJECT DeviceObject)PURE;
+
+
#undef INTERFACE
#define INTERFACE IIrpTarget
#undef INTERFACE
#define INTERFACE ISubdevice
-DECLARE_INTERFACE_(ISubdevice, IUnknown)
-{
- STDMETHOD_(NTSTATUS, QueryInterface)(THIS_
- REFIID InterfaceId,
- PVOID* Interface
- ) PURE;
- STDMETHOD_(ULONG,AddRef)(THIS) PURE;
- STDMETHOD_(ULONG,Release)(THIS) PURE;
-
- STDMETHOD_(NTSTATUS, NewIrpTarget)(THIS_
- OUT IIrpTarget **OutTarget,
- IN WCHAR * Name,
- IN PUNKNOWN Unknown,
- IN POOL_TYPE PoolType,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN KSOBJECT_CREATE *CreateObject) PURE;
-
- STDMETHOD_(NTSTATUS, ReleaseChildren)(THIS) PURE;
-
- STDMETHOD_(NTSTATUS, GetDescriptor)(THIS_
- IN SUBDEVICE_DESCRIPTOR **) PURE;
-
- STDMETHOD_(NTSTATUS, DataRangeIntersection)(THIS_
- IN ULONG PinId,
- IN PKSDATARANGE DataRange,
- IN PKSDATARANGE MatchingDataRange,
- IN ULONG OutputBufferLength,
- OUT PVOID ResultantFormat OPTIONAL,
- OUT PULONG ResultantFormatLength) PURE;
-
- STDMETHOD_(NTSTATUS, PowerChangeNotify)(THIS_
- IN POWER_STATE PowerState) PURE;
-
- STDMETHOD_(NTSTATUS, PinCount)(THIS_
- IN ULONG PinId,
- IN OUT PULONG FilterNecessary,
- IN OUT PULONG FilterCurrent,
- IN OUT PULONG FilterPossible,
- IN OUT PULONG GlobalCurrent,
+#define DEFINE_ABSTRACT_ISUBDEVICE() \
+ STDMETHOD_(NTSTATUS, NewIrpTarget)(THIS_ \
+ OUT IIrpTarget **OutTarget, \
+ IN WCHAR * Name, \
+ IN PUNKNOWN Unknown, \
+ IN POOL_TYPE PoolType, \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp, \
+ IN KSOBJECT_CREATE *CreateObject) PURE; \
+ \
+ STDMETHOD_(NTSTATUS, ReleaseChildren)(THIS) PURE; \
+ \
+ STDMETHOD_(NTSTATUS, GetDescriptor)(THIS_ \
+ IN SUBDEVICE_DESCRIPTOR **) PURE; \
+ \
+ STDMETHOD_(NTSTATUS, DataRangeIntersection)(THIS_ \
+ IN ULONG PinId, \
+ IN PKSDATARANGE DataRange, \
+ IN PKSDATARANGE MatchingDataRange, \
+ IN ULONG OutputBufferLength, \
+ OUT PVOID ResultantFormat OPTIONAL, \
+ OUT PULONG ResultantFormatLength) PURE; \
+ \
+ STDMETHOD_(NTSTATUS, PowerChangeNotify)(THIS_ \
+ IN POWER_STATE PowerState) PURE; \
+ \
+ STDMETHOD_(NTSTATUS, PinCount)(THIS_ \
+ IN ULONG PinId, \
+ IN OUT PULONG FilterNecessary, \
+ IN OUT PULONG FilterCurrent, \
+ IN OUT PULONG FilterPossible, \
+ IN OUT PULONG GlobalCurrent, \
IN OUT PULONG GlobalPossible)PURE;
+
+
+#define IMP_ISubdevice \
+ STDMETHODIMP_(NTSTATUS) NewIrpTarget( \
+ OUT IIrpTarget **OutTarget, \
+ IN WCHAR * Name, \
+ IN PUNKNOWN Unknown, \
+ IN POOL_TYPE PoolType, \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN PIRP Irp, \
+ IN KSOBJECT_CREATE *CreateObject); \
+ \
+ STDMETHODIMP_(NTSTATUS) ReleaseChildren(THIS); \
+ \
+ STDMETHODIMP_(NTSTATUS) GetDescriptor(THIS_ \
+ IN SUBDEVICE_DESCRIPTOR **); \
+ \
+ STDMETHODIMP_(NTSTATUS) DataRangeIntersection( \
+ IN ULONG PinId, \
+ IN PKSDATARANGE DataRange, \
+ IN PKSDATARANGE MatchingDataRange, \
+ IN ULONG OutputBufferLength, \
+ OUT PVOID ResultantFormat OPTIONAL, \
+ OUT PULONG ResultantFormatLength); \
+ \
+ STDMETHODIMP_(NTSTATUS) PowerChangeNotify( \
+ IN POWER_STATE PowerState); \
+ \
+ STDMETHODIMP_(NTSTATUS) PinCount( \
+ IN ULONG PinId, \
+ IN OUT PULONG FilterNecessary, \
+ IN OUT PULONG FilterCurrent, \
+ IN OUT PULONG FilterPossible, \
+ IN OUT PULONG GlobalCurrent, \
+ IN OUT PULONG GlobalPossible)
+
+
+DECLARE_INTERFACE_(ISubdevice, IUnknown)
+{
+ DEFINE_ABSTRACT_UNKNOWN()
+ DEFINE_ABSTRACT_ISUBDEVICE()
};
+typedef ISubdevice *PSUBDEVICE;
+
/*****************************************************************************
* IIrpQueue
*****************************************************************************
};
+#define IMP_IIrpQueue \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN KSPIN_CONNECT *ConnectDetails, \
+ IN PKSDATAFORMAT DataFormat, \
+ IN PDEVICE_OBJECT DeviceObject, \
+ IN ULONG FrameSize, \
+ IN ULONG Alignment, \
+ IN PVOID SilenceBuffer); \
+ \
+ STDMETHODIMP_(NTSTATUS) AddMapping(THIS_ \
+ IN PUCHAR Buffer, \
+ IN ULONG BufferSize, \
+ IN PIRP Irp); \
+ \
+ STDMETHODIMP_(NTSTATUS) GetMapping(THIS_ \
+ OUT PUCHAR * Buffer, \
+ OUT PULONG BufferSize); \
+ \
+ STDMETHODIMP_(VOID) UpdateMapping(THIS_ \
+ IN ULONG BytesWritten); \
+ \
+ STDMETHODIMP_(ULONG) NumMappings(THIS); \
+ \
+ STDMETHODIMP_(ULONG) NumData(THIS); \
+ \
+ STDMETHODIMP_(BOOL) MinimumDataAvailable(THIS); \
+ \
+ STDMETHODIMP_(BOOL) CancelBuffers(THIS); \
+ \
+ STDMETHODIMP_(VOID) UpdateFormat(THIS_ \
+ IN PKSDATAFORMAT DataFormat); \
+ \
+ STDMETHODIMP_(NTSTATUS) GetMappingWithTag(THIS_ \
+ IN PVOID Tag, \
+ OUT PPHYSICAL_ADDRESS PhysicalAddress, \
+ OUT PVOID *VirtualAddress, \
+ OUT PULONG ByteCount, \
+ OUT PULONG Flags); \
+ \
+ STDMETHODIMP_(NTSTATUS) ReleaseMappingWithTag( \
+ IN PVOID Tag); \
+ \
+ STDMETHODIMP_(BOOL) HasLastMappingFailed(THIS); \
+ STDMETHODIMP_(VOID) PrintQueueStatus(THIS); \
+ STDMETHODIMP_(VOID) SetMinimumDataThreshold( \
+ IN ULONG MinimumDataThreshold); \
+ STDMETHODIMP_(ULONG) GetMinimumDataThreshold(VOID)
+
/*****************************************************************************
* IKsWorkSink
*****************************************************************************
typedef IPortFilterWavePci *PPORTFILTERWAVEPCI;
+#define IMP_IPortFilterPci \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTWAVEPCI Port)
/*****************************************************************************
* IPortPinWavePci
STDMETHOD_(PMINIPORT, GetMiniport)(THIS);
};
+#define IMP_IPortPinWavePci \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTWAVEPCI Port, \
+ IN PPORTFILTERWAVEPCI Filter, \
+ IN KSPIN_CONNECT * ConnectDetails, \
+ IN KSPIN_DESCRIPTOR * PinDescriptor, \
+ IN PDEVICE_OBJECT DeviceObject); \
+ \
+ STDMETHODIMP_(PVOID) GetIrpStream(THIS); \
+ STDMETHODIMP_(PMINIPORT) GetMiniport(THIS)
+
+
+
typedef IPortPinWavePci *PPORTPINWAVEPCI;
+
#if (NTDDI_VERSION >= NTDDI_VISTA)
/*****************************************************************************
typedef IPortFilterWaveRT *PPORTFILTERWAVERT;
+#define IMP_IPortFilterWaveRT \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTWAVERT Port)
+
+
/*****************************************************************************
* IPortPinWaveRT
*****************************************************************************
typedef IPortPinWaveRT *PPORTPINWAVERT;
+#define IMP_IPortPinWaveRT \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTWAVERT Port, \
+ IN PPORTFILTERWAVERT Filter, \
+ IN KSPIN_CONNECT * ConnectDetails, \
+ IN KSPIN_DESCRIPTOR * PinDescriptor, \
+ IN PDEVICE_OBJECT DeviceObject)
+
+
#endif
/*****************************************************************************
typedef IPortFilterWaveCyclic *PPORTFILTERWAVECYCLIC;
+#define IMP_IPortFilterWaveCyclic \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTWAVECYCLIC Port); \
+ STDMETHODIMP_(NTSTATUS) FreePin(THIS_ \
+ IN struct IPortPinWaveCyclic* Pin)
+
+
/*****************************************************************************
* IPortPinWaveCyclic
*****************************************************************************
STDMETHOD_(PMINIPORT, GetMiniport)(THIS);
};
+#define IMP_IPortPinWaveCyclic \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTWAVECYCLIC Port, \
+ IN PPORTFILTERWAVECYCLIC Filter, \
+ IN KSPIN_CONNECT * ConnectDetails, \
+ IN KSPIN_DESCRIPTOR * PinDescriptor); \
+ STDMETHODIMP_(ULONG) GetCompletedPosition(THIS); \
+ STDMETHODIMP_(ULONG) GetCycleCount(THIS); \
+ STDMETHODIMP_(ULONG) GetDeviceBufferSize(THIS); \
+ STDMETHODIMP_(PVOID) GetIrpStream(THIS); \
+ STDMETHODIMP_(PMINIPORT) GetMiniport(THIS)
+
+
/*****************************************************************************
* IPortFilterDMus
*****************************************************************************
struct IPortPinDMus;
-DECLARE_INTERFACE_(IPortFilterDMus, IIrpTarget)
+DECLARE_INTERFACE_(IPortFilterDMus, IUnknown)
{
DEFINE_ABSTRACT_UNKNOWN()
typedef IPortFilterDMus *PPORTFILTERDMUS;
+#define IMP_IPortFilterDMus \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTDMUS Port); \
+ STDMETHODIMP_(NTSTATUS) FreePin(THIS_ \
+ IN struct IPortPinDMus* Pin); \
+ STDMETHODIMP_(VOID) NotifyPins(THIS)
+
/*****************************************************************************
* IPortPinDMus
*****************************************************************************
STDMETHOD_(VOID, Notify)(THIS);
};
+#define IMP_IPortPinDMus \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTDMUS Port, \
+ IN PPORTFILTERDMUS Filter, \
+ IN KSPIN_CONNECT * ConnectDetails, \
+ IN KSPIN_DESCRIPTOR * PinDescriptor, \
+ IN PDEVICE_OBJECT DeviceObject); \
+ STDMETHODIMP_(VOID) Notify(THIS)
+
typedef IPortPinDMus *PPORTPINDMUS;
/*****************************************************************************
DECLARE_INTERFACE_(IDmaChannelInit, IUnknown)
{
DEFINE_ABSTRACT_UNKNOWN()
-
- STDMETHOD_(NTSTATUS,AllocateBuffer)(THIS_
- IN ULONG BufferSize,
- IN PPHYSICAL_ADDRESS PhysicalAddressConstraint OPTIONAL);
-
- STDMETHOD_(VOID, FreeBuffer)(THIS);
- STDMETHOD_(ULONG, TransferCount)(THIS);
- STDMETHOD_(ULONG, MaximumBufferSize)(THIS);
- STDMETHOD_(ULONG, AllocatedBufferSize)(THIS);
- STDMETHOD_(ULONG, BufferSize)(THIS);
-
- STDMETHOD_(VOID, SetBufferSize)(THIS_
- IN ULONG BufferSize);
-
- STDMETHOD_(PVOID, SystemAddress)(THIS);
- STDMETHOD_(PHYSICAL_ADDRESS, PhysicalAddress)(THIS_
- IN PPHYSICAL_ADDRESS Address);
-
- STDMETHOD_(PADAPTER_OBJECT, GetAdapterObject)(THIS);
-
- STDMETHOD_(VOID, CopyTo)(THIS_
- IN PVOID Destination,
- IN PVOID Source,
- IN ULONG ByteCount);
-
- STDMETHOD_(VOID, CopyFrom)(THIS_
- IN PVOID Destination,
- IN PVOID Source,
- IN ULONG ByteCount);
-
- STDMETHOD_(NTSTATUS, Start)( THIS_
- IN ULONG MapSize,
- IN BOOLEAN WriteToDevice) PURE;
-
- STDMETHOD_(NTSTATUS, Stop)( THIS ) PURE;
- STDMETHOD_(ULONG, ReadCounter)( THIS ) PURE;
-
- STDMETHOD_(NTSTATUS, WaitForTC)( THIS_
- ULONG Timeout) PURE;
+ DEFINE_ABSTRACT_DMACHANNEL()
+ DEFINE_ABSTRACT_DMACHANNELSLAVE()
STDMETHOD_(NTSTATUS, Init)( THIS_
IN PDEVICE_DESCRIPTION DeviceDescription,
IN PDEVICE_OBJECT DeviceObject) PURE;
};
+
+
+#define IMP_IDmaChannelInit\
+ IMP_IDmaChannelSlave;\
+ STDMETHODIMP_(NTSTATUS) Init( \
+ IN PDEVICE_DESCRIPTION DeviceDescription, \
+ IN PDEVICE_OBJECT DeviceObject)
+
+
#undef INTERFACE
/*****************************************************************************
typedef IPortFilterTopology *PPORTFILTERTOPOLOGY;
+#define IMP_IPortFilterTopology \
+ IMP_IIrpTarget; \
+ STDMETHODIMP_(NTSTATUS) Init(THIS_ \
+ IN PPORTTOPOLOGY Port)
+
#undef INTERFACE
/*****************************************************************************
#undef INTERFACE
+#define IMP_IPortWaveRTStreamInit \
+ STDMETHODIMP_(PMDL) AllocatePagesForMdl \
+ ( THIS_ \
+ IN PHYSICAL_ADDRESS HighAddress, \
+ IN SIZE_T TotalBytes \
+ ); \
+ \
+ STDMETHODIMP_(PMDL) AllocateContiguousPagesForMdl \
+ ( THIS_ \
+ IN PHYSICAL_ADDRESS LowAddress, \
+ IN PHYSICAL_ADDRESS HighAddress, \
+ IN SIZE_T TotalBytes \
+ ); \
+ \
+ STDMETHODIMP_(PVOID) MapAllocatedPages \
+ ( THIS_ \
+ IN PMDL MemoryDescriptorList, \
+ IN MEMORY_CACHING_TYPE CacheType \
+ ); \
+ \
+ STDMETHODIMP_(VOID) UnmapAllocatedPages \
+ ( THIS_ \
+ IN PVOID BaseAddress, \
+ IN PMDL MemoryDescriptorList \
+ ); \
+ \
+ STDMETHODIMP_(VOID) FreePagesFromMdl \
+ ( THIS_ \
+ IN PMDL MemoryDescriptorList \
+ ); \
+ \
+ STDMETHODIMP_(ULONG) GetPhysicalPagesCount \
+ ( THIS_ \
+ IN PMDL MemoryDescriptorList \
+ ); \
+ \
+ STDMETHODIMP_(PHYSICAL_ADDRESS) GetPhysicalPageAddress \
+ ( THIS_ \
+ IN PPHYSICAL_ADDRESS Address, \
+ IN PMDL MemoryDescriptorList, \
+ IN ULONG Index \
+ )
+
+
+
+
#endif
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/interrupt.c
- * PURPOSE: portcls interrupt object
- * PROGRAMMER: Johannes Anderwald
- */
-
-
-#include "private.h"
-
-typedef struct
-{
- LIST_ENTRY ListEntry;
- PINTERRUPTSYNCROUTINE SyncRoutine;
- PVOID DynamicContext;
-}SYNC_ENTRY, *PSYNC_ENTRY;
-
-typedef struct
-{
- IInterruptSyncVtbl *lpVtbl;
-
- LONG ref;
- KSPIN_LOCK Lock;
- LIST_ENTRY ServiceRoutines;
- PKINTERRUPT Interrupt;
- INTERRUPTSYNCMODE Mode;
- PRESOURCELIST ResourceList;
- ULONG ResourceIndex;
-
- PINTERRUPTSYNCROUTINE SyncRoutine;
- PVOID DynamicContext;
-}IInterruptSyncImpl;
-
-
-//---------------------------------------------------------------
-// IUnknown methods
-//
-
-
-
-NTSTATUS
-NTAPI
-IInterruptSync_fnQueryInterface(
- IInterruptSync * iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)iface;
-
- DPRINT("IInterruptSync_fnQueryInterface: This %p\n", This);
-
- if (IsEqualGUIDAligned(refiid, &IID_IInterruptSync) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- DPRINT1("IInterruptSync_fnQueryInterface: This %p UNKNOWN interface requested\n", This);
- return STATUS_UNSUCCESSFUL;
-}
-
-ULONG
-NTAPI
-IInterruptSync_fnAddRef(
- IInterruptSync * iface)
-{
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)iface;
-
- DPRINT("IInterruptSync_AddRef: This %p\n", This);
-
- return InterlockedIncrement(&This->ref);
-}
-
-ULONG
-NTAPI
-IInterruptSync_fnRelease(
- IInterruptSync* iface)
-{
- PLIST_ENTRY CurEntry;
- PSYNC_ENTRY Entry;
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- DPRINT("IInterruptSync_Release: This %p new ref %u\n", This, This->ref);
-
- if (This->ref == 0)
- {
- while(!IsListEmpty(&This->ServiceRoutines))
- {
- CurEntry = RemoveHeadList(&This->ServiceRoutines);
- Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
- FreeItem(Entry, TAG_PORTCLASS);
- }
-
- This->ResourceList->lpVtbl->Release(This->ResourceList);
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- /* Return new reference count */
- return This->ref;
-}
-
-//---------------------------------------------------------------
-// IInterruptSync methods
-//
-
-
-BOOLEAN
-NTAPI
-IInterruptSynchronizedRoutine(
- IN PVOID ServiceContext)
-{
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)ServiceContext;
- DPRINT("IInterruptSynchronizedRoutine This %p SyncRoutine %p Context %p\n", This, This->SyncRoutine, This->DynamicContext);
- return This->SyncRoutine((IInterruptSync*)&This->lpVtbl, This->DynamicContext);
-}
-
-NTSTATUS
-NTAPI
-IInterruptSync_fnCallSynchronizedRoutine(
- IN IInterruptSync * iface,
- IN PINTERRUPTSYNCROUTINE Routine,
- IN PVOID DynamicContext)
-{
- KIRQL OldIrql;
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)iface;
-
- DPRINT("IInterruptSync_fnCallSynchronizedRoutine This %p Routine %p DynamicContext %p Irql %x Interrupt %p\n", This, Routine, DynamicContext, KeGetCurrentIrql(), This->Interrupt);
-
- if (!This->Interrupt)
- {
- DPRINT("IInterruptSync_CallSynchronizedRoutine %p no interrupt connected\n", This);
- if (KeGetCurrentIrql() > DISPATCH_LEVEL)
- return STATUS_UNSUCCESSFUL;
-
- KeAcquireSpinLock(&This->Lock, &OldIrql);
- This->SyncRoutine = Routine;
- This->DynamicContext = DynamicContext;
- IInterruptSynchronizedRoutine((PVOID)This);
- KeReleaseSpinLock(&This->Lock, OldIrql);
-
- return STATUS_SUCCESS;
- }
-
- This->SyncRoutine = Routine;
- This->DynamicContext = DynamicContext;
-
- if (KeSynchronizeExecution(This->Interrupt, IInterruptSynchronizedRoutine, (PVOID)This))
- return STATUS_SUCCESS;
- else
- return STATUS_UNSUCCESSFUL;
-}
-
-PKINTERRUPT
-NTAPI
-IInterruptSync_fnGetKInterrupt(
- IN IInterruptSync * iface)
-{
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)iface;
- DPRINT("IInterruptSynchronizedRoutine\n");
-
- return This->Interrupt;
-}
-
-BOOLEAN
-NTAPI
-IInterruptServiceRoutine(
- IN PKINTERRUPT Interrupt,
- IN PVOID ServiceContext)
-{
- PLIST_ENTRY CurEntry;
- PSYNC_ENTRY Entry;
- NTSTATUS Status;
- BOOL Success;
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)ServiceContext;
-
- //DPRINT("IInterruptServiceRoutine Mode %u\n", This->Mode);
-
- if (This->Mode == InterruptSyncModeNormal)
- {
- CurEntry = This->ServiceRoutines.Flink;
- while (CurEntry != &This->ServiceRoutines)
- {
- Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
- Status = Entry->SyncRoutine((IInterruptSync*)This, Entry->DynamicContext);
- if (NT_SUCCESS(Status))
- {
- return TRUE;
- }
- CurEntry = CurEntry->Flink;
- }
- return FALSE;
- }
- else if (This->Mode == InterruptSyncModeAll)
- {
- CurEntry = This->ServiceRoutines.Flink;
- while (CurEntry != &This->ServiceRoutines)
- {
- Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
- Status = Entry->SyncRoutine((IInterruptSync*)This, Entry->DynamicContext);
- CurEntry = CurEntry->Flink;
- }
- DPRINT("Returning TRUE with mode InterruptSyncModeAll\n");
- return TRUE; //FIXME
- }
- else if (This->Mode == InterruptSyncModeRepeat)
- {
- do
- {
- Success = FALSE;
- CurEntry = This->ServiceRoutines.Flink;
- while (CurEntry != &This->ServiceRoutines)
- {
- Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
- Status = Entry->SyncRoutine((IInterruptSync*)This, Entry->DynamicContext);
- if (NT_SUCCESS(Status))
- Success = TRUE;
- CurEntry = CurEntry->Flink;
- }
- }while(Success);
- DPRINT("Returning TRUE with mode InterruptSyncModeRepeat\n");
- return TRUE; //FIXME
- }
- else
- {
- DPRINT("Unknown mode %u\n", This->Mode);
- return FALSE; //FIXME
- }
-}
-
-
-NTSTATUS
-NTAPI
-IInterruptSync_fnConnect(
- IN IInterruptSync * iface)
-{
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)iface;
- NTSTATUS Status;
- PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
-
- DPRINT("IInterruptSync_fnConnect\n");
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
-
- Descriptor = This->ResourceList->lpVtbl->FindTranslatedEntry(This->ResourceList, CmResourceTypeInterrupt, This->ResourceIndex);
- if (!Descriptor)
- return STATUS_UNSUCCESSFUL;
-
- if (IsListEmpty(&This->ServiceRoutines))
- return STATUS_UNSUCCESSFUL;
-
- Status = IoConnectInterrupt(&This->Interrupt,
- IInterruptServiceRoutine,
- (PVOID)This,
- &This->Lock,
- Descriptor->u.Interrupt.Vector,
- Descriptor->u.Interrupt.Level,
- Descriptor->u.Interrupt.Level,
- (Descriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED),
- (Descriptor->Flags != CM_RESOURCE_INTERRUPT_LATCHED),
- Descriptor->u.Interrupt.Affinity,
- FALSE);
-
- DPRINT("IInterruptSync_fnConnect result %x\n", Status);
- return Status;
-}
-
-
-VOID
-NTAPI
-IInterruptSync_fnDisconnect(
- IN IInterruptSync * iface)
-{
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)iface;
-
- DPRINT("IInterruptSync_fnDisconnect\n");
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
-
- if (!This->Interrupt)
- {
- DPRINT("IInterruptSync_Disconnect %p no interrupt connected\n", This);
- return;
- }
-
- IoDisconnectInterrupt(This->Interrupt);
- This->Interrupt = NULL;
-}
-
-NTSTATUS
-NTAPI
-IInterruptSync_fnRegisterServiceRoutine(
- IN IInterruptSync * iface,
- IN PINTERRUPTSYNCROUTINE Routine,
- IN PVOID DynamicContext,
- IN BOOLEAN First)
-{
- PSYNC_ENTRY NewEntry;
- IInterruptSyncImpl * This = (IInterruptSyncImpl*)iface;
-
- DPRINT("IInterruptSync_fnRegisterServiceRoutine\n");
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
-
- NewEntry = AllocateItem(NonPagedPool, sizeof(SYNC_ENTRY), TAG_PORTCLASS);
- if (!NewEntry)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- NewEntry->SyncRoutine = Routine;
- NewEntry->DynamicContext = DynamicContext;
-
- if (First)
- InsertHeadList(&This->ServiceRoutines, &NewEntry->ListEntry);
- else
- InsertTailList(&This->ServiceRoutines, &NewEntry->ListEntry);
-
- return STATUS_SUCCESS;
-}
-
-static IInterruptSyncVtbl vt_IInterruptSyncVtbl =
-{
- /* IUnknown methods */
- IInterruptSync_fnQueryInterface,
- IInterruptSync_fnAddRef,
- IInterruptSync_fnRelease,
- /* IInterruptSync methods */
- IInterruptSync_fnCallSynchronizedRoutine,
- IInterruptSync_fnGetKInterrupt,
- IInterruptSync_fnConnect,
- IInterruptSync_fnDisconnect,
- IInterruptSync_fnRegisterServiceRoutine
-};
-
-/*
- * @implemented
- */
-NTSTATUS NTAPI
-PcNewInterruptSync(
- OUT PINTERRUPTSYNC* OutInterruptSync,
- IN PUNKNOWN OuterUnknown OPTIONAL,
- IN PRESOURCELIST ResourceList,
- IN ULONG ResourceIndex,
- IN INTERRUPTSYNCMODE Mode)
-{
- IInterruptSyncImpl * This;
-
- DPRINT("PcNewInterruptSync entered OutInterruptSync %p OuterUnknown %p ResourceList %p ResourceIndex %u Mode %d\n",
- OutInterruptSync, OuterUnknown, ResourceList, ResourceIndex, Mode);
-
- if (!OutInterruptSync || !ResourceList || Mode < InterruptSyncModeNormal || Mode > InterruptSyncModeRepeat)
- return STATUS_INVALID_PARAMETER;
-
- if (ResourceIndex > ResourceList->lpVtbl->NumberOfEntriesOfType(ResourceList, CmResourceTypeInterrupt))
- return STATUS_INVALID_PARAMETER;
-
-
- ResourceList->lpVtbl->AddRef(ResourceList);
-
- This = AllocateItem(NonPagedPool, sizeof(IInterruptSyncImpl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- /* initialize object */
- This->lpVtbl = &vt_IInterruptSyncVtbl;
- This->ref = 1;
- This->Mode = Mode;
- This->ResourceIndex = ResourceIndex;
- This->ResourceList = ResourceList;
- InitializeListHead(&This->ServiceRoutines);
- KeInitializeSpinLock(&This->Lock);
-
- *OutInterruptSync = (PINTERRUPTSYNC)&This->lpVtbl;
- DPRINT("PcNewInterruptSync success %p\n", *OutInterruptSync);
- return STATUS_SUCCESS;
-}
-
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/interrupt.cpp
+ * PURPOSE: portcls interrupt object
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+
+#include "private.hpp"
+
+typedef struct
+{
+ LIST_ENTRY ListEntry;
+ PINTERRUPTSYNCROUTINE SyncRoutine;
+ PVOID DynamicContext;
+}SYNC_ENTRY, *PSYNC_ENTRY;
+
+class CInterruptSync : public IInterruptSync
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IInterruptSync;
+ CInterruptSync(IUnknown *OuterUnknown){}
+ virtual ~CInterruptSync(){}
+
+public:
+
+ KSPIN_LOCK m_Lock;
+ LIST_ENTRY m_ServiceRoutines;
+ PKINTERRUPT m_Interrupt;
+ INTERRUPTSYNCMODE m_Mode;
+ PRESOURCELIST m_ResourceList;
+ ULONG m_ResourceIndex;
+
+ PINTERRUPTSYNCROUTINE m_SyncRoutine;
+ PVOID m_DynamicContext;
+
+ LONG m_Ref;
+
+ friend BOOLEAN NTAPI CInterruptSynchronizedRoutine(IN PVOID ServiceContext);
+ friend BOOLEAN NTAPI IInterruptServiceRoutine(IN PKINTERRUPT Interrupt, IN PVOID ServiceContext);
+};
+
+
+//---------------------------------------------------------------
+// IUnknown methods
+//
+
+
+
+NTSTATUS
+NTAPI
+CInterruptSync::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+ DPRINT("CInterruptSync::QueryInterface: this %p\n", this);
+
+ if (IsEqualGUIDAligned(refiid, IID_IInterruptSync) ||
+ IsEqualGUIDAligned(refiid, IID_IUnknown))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+
+ DPRINT1("CInterruptSync::QueryInterface: this %p UNKNOWN interface requested\n", this);
+ return STATUS_UNSUCCESSFUL;
+}
+
+//---------------------------------------------------------------
+// CInterruptSync methods
+//
+
+
+BOOLEAN
+NTAPI
+CInterruptSynchronizedRoutine(
+ IN PVOID ServiceContext)
+{
+ CInterruptSync * This = (CInterruptSync*)ServiceContext;
+ DPRINT("CInterruptSynchronizedRoutine this %p SyncRoutine %p Context %p\n", This, This->m_SyncRoutine, This->m_DynamicContext);
+ return This->m_SyncRoutine(This, This->m_DynamicContext);
+}
+
+NTSTATUS
+NTAPI
+CInterruptSync::CallSynchronizedRoutine(
+ IN PINTERRUPTSYNCROUTINE Routine,
+ IN PVOID DynamicContext)
+{
+ KIRQL OldIrql;
+
+ DPRINT("CInterruptSync::CallSynchronizedRoutine this %p Routine %p DynamicContext %p Irql %x Interrupt %p\n", this, Routine, DynamicContext, KeGetCurrentIrql(), m_Interrupt);
+
+ if (!m_Interrupt)
+ {
+ DPRINT("CInterruptSync_CallSynchronizedRoutine %p no interrupt connected\n", this);
+ if (KeGetCurrentIrql() > DISPATCH_LEVEL)
+ return STATUS_UNSUCCESSFUL;
+
+ KeAcquireSpinLock(&m_Lock, &OldIrql);
+ m_SyncRoutine = Routine;
+ m_DynamicContext = DynamicContext;
+ CInterruptSynchronizedRoutine((PVOID)this);
+ KeReleaseSpinLock(&m_Lock, OldIrql);
+
+ return STATUS_SUCCESS;
+ }
+
+ m_SyncRoutine = Routine;
+ m_DynamicContext = DynamicContext;
+
+ if (KeSynchronizeExecution(m_Interrupt, CInterruptSynchronizedRoutine, (PVOID)this))
+ return STATUS_SUCCESS;
+ else
+ return STATUS_UNSUCCESSFUL;
+}
+
+PKINTERRUPT
+NTAPI
+CInterruptSync::GetKInterrupt()
+{
+ DPRINT("CInterruptSynchronizedRoutine\n");
+
+ return m_Interrupt;
+}
+
+BOOLEAN
+NTAPI
+IInterruptServiceRoutine(
+ IN PKINTERRUPT Interrupt,
+ IN PVOID ServiceContext)
+{
+ PLIST_ENTRY CurEntry;
+ PSYNC_ENTRY Entry;
+ NTSTATUS Status;
+ BOOL Success;
+
+ //DPRINT("IInterruptServiceRoutine Mode %u\n", m_Mode);
+
+ CInterruptSync * This = (CInterruptSync*)ServiceContext;
+
+ if (This->m_Mode == InterruptSyncModeNormal)
+ {
+ CurEntry = This->m_ServiceRoutines.Flink;
+ while (CurEntry != &This->m_ServiceRoutines)
+ {
+ Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
+ Status = Entry->SyncRoutine((CInterruptSync*)This, Entry->DynamicContext);
+ if (NT_SUCCESS(Status))
+ {
+ return TRUE;
+ }
+ CurEntry = CurEntry->Flink;
+ }
+ return FALSE;
+ }
+ else if (This->m_Mode == InterruptSyncModeAll)
+ {
+ CurEntry = This->m_ServiceRoutines.Flink;
+ while (CurEntry != &This->m_ServiceRoutines)
+ {
+ Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
+ Status = Entry->SyncRoutine((CInterruptSync*)This, Entry->DynamicContext);
+ CurEntry = CurEntry->Flink;
+ }
+ DPRINT("Returning TRUE with mode InterruptSyncModeAll\n");
+ return TRUE; //FIXME
+ }
+ else if (This->m_Mode == InterruptSyncModeRepeat)
+ {
+ do
+ {
+ Success = FALSE;
+ CurEntry = This->m_ServiceRoutines.Flink;
+ while (CurEntry != &This->m_ServiceRoutines)
+ {
+ Entry = CONTAINING_RECORD(CurEntry, SYNC_ENTRY, ListEntry);
+ Status = Entry->SyncRoutine((CInterruptSync*)This, Entry->DynamicContext);
+ if (NT_SUCCESS(Status))
+ Success = TRUE;
+ CurEntry = CurEntry->Flink;
+ }
+ }while(Success);
+ DPRINT("Returning TRUE with mode InterruptSyncModeRepeat\n");
+ return TRUE; //FIXME
+ }
+ else
+ {
+ DPRINT("Unknown mode %u\n", This->m_Mode);
+ return FALSE; //FIXME
+ }
+}
+
+
+NTSTATUS
+NTAPI
+CInterruptSync::Connect()
+{
+ NTSTATUS Status;
+ PCM_PARTIAL_RESOURCE_DESCRIPTOR Descriptor;
+
+ DPRINT("CInterruptSync::Connect\n");
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+
+ Descriptor = m_ResourceList->FindTranslatedEntry(CmResourceTypeInterrupt, m_ResourceIndex);
+ if (!Descriptor)
+ return STATUS_UNSUCCESSFUL;
+
+ if (IsListEmpty(&m_ServiceRoutines))
+ return STATUS_UNSUCCESSFUL;
+
+ Status = IoConnectInterrupt(&m_Interrupt,
+ IInterruptServiceRoutine,
+ (PVOID)this,
+ &m_Lock,
+ Descriptor->u.Interrupt.Vector,
+ Descriptor->u.Interrupt.Level,
+ Descriptor->u.Interrupt.Level,
+ (KINTERRUPT_MODE)(Descriptor->Flags & CM_RESOURCE_INTERRUPT_LATCHED),
+ (Descriptor->Flags != CM_RESOURCE_INTERRUPT_LATCHED),
+ Descriptor->u.Interrupt.Affinity,
+ FALSE);
+
+ DPRINT("CInterruptSync::Connect result %x\n", Status);
+ return Status;
+}
+
+
+VOID
+NTAPI
+CInterruptSync::Disconnect()
+{
+ DPRINT("CInterruptSync::Disconnect\n");
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+
+ if (!m_Interrupt)
+ {
+ DPRINT("CInterruptSync_Disconnect %p no interrupt connected\n", this);
+ return;
+ }
+
+ IoDisconnectInterrupt(m_Interrupt);
+ m_Interrupt = NULL;
+}
+
+NTSTATUS
+NTAPI
+CInterruptSync::RegisterServiceRoutine(
+ IN PINTERRUPTSYNCROUTINE Routine,
+ IN PVOID DynamicContext,
+ IN BOOLEAN First)
+{
+ PSYNC_ENTRY NewEntry;
+
+ DPRINT("CInterruptSync::RegisterServiceRoutine\n");
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+
+ NewEntry = (PSYNC_ENTRY)AllocateItem(NonPagedPool, sizeof(SYNC_ENTRY), TAG_PORTCLASS);
+ if (!NewEntry)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ NewEntry->SyncRoutine = Routine;
+ NewEntry->DynamicContext = DynamicContext;
+
+ if (First)
+ InsertHeadList(&m_ServiceRoutines, &NewEntry->ListEntry);
+ else
+ InsertTailList(&m_ServiceRoutines, &NewEntry->ListEntry);
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NTAPI
+PcNewInterruptSync(
+ OUT PINTERRUPTSYNC* OutInterruptSync,
+ IN PUNKNOWN OuterUnknown OPTIONAL,
+ IN PRESOURCELIST ResourceList,
+ IN ULONG ResourceIndex,
+ IN INTERRUPTSYNCMODE Mode)
+{
+ CInterruptSync * This;
+ NTSTATUS Status;
+
+ DPRINT("PcNewInterruptSync entered OutInterruptSync %p OuterUnknown %p ResourceList %p ResourceIndex %u Mode %d\n",
+ OutInterruptSync, OuterUnknown, ResourceList, ResourceIndex, Mode);
+
+ if (!OutInterruptSync || !ResourceList || Mode < InterruptSyncModeNormal || Mode > InterruptSyncModeRepeat)
+ return STATUS_INVALID_PARAMETER;
+
+ if (ResourceIndex > ResourceList->NumberOfEntriesOfType(CmResourceTypeInterrupt))
+ return STATUS_INVALID_PARAMETER;
+
+ This = new(NonPagedPool, TAG_PORTCLASS)CInterruptSync(OuterUnknown);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ Status = This->QueryInterface(IID_IInterruptSync, (PVOID*)OutInterruptSync);
+
+ if (!NT_SUCCESS(Status))
+ {
+ delete This;
+ return Status;
+ }
+
+ ResourceList->AddRef();
+
+ //
+ // initialize object
+ //
+ This->m_Mode = Mode;
+ This->m_ResourceIndex = ResourceIndex;
+ This->m_ResourceList = ResourceList;
+ InitializeListHead(&This->m_ServiceRoutines);
+ KeInitializeSpinLock(&This->m_Lock);
+
+ return Status;
+}
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS
- * FILE: drivers/wdm/audio/backpln/portcls/irp.c
+ * FILE: drivers/wdm/audio/backpln/portcls/irp.cpp
* PURPOSE: Port Class driver / IRP Handling
* PROGRAMMER: Andrew Greenwood
* Johannes Anderwald
*/
-#include "private.h"
-#include <portcls.h>
+#include "private.hpp"
-/*
- Handles IRP_MJ_CREATE, which occurs when someone wants to make use of
- a device.
-*/
NTSTATUS
NTAPI
PortClsCreate(
}
-/*
- IRP_MJ_PNP handler
- Used for things like IRP_MN_START_DEVICE
-*/
NTSTATUS
NTAPI
PortClsPnp(
PIO_STACK_LOCATION IoStack;
IResourceList* resource_list = NULL;
- DPRINT("PortClsPnp called\n");
-
DeviceExt = (PPCLASS_DEVICE_EXTENSION) DeviceObject->DeviceExtension;
IoStack = IoGetCurrentIrpStackLocation(Irp);
- ASSERT(DeviceExt);
- /*
- if IRP_MN_START_DEVICE, call the driver's customer start device routine.
- Before we do so, we must create a ResourceList to pass to the Start
- routine.
- */
+ DPRINT("PortClsPnp called %u\n", IoStack->MinorFunction);
+
+ //PC_ASSERT(DeviceExt);
+
switch (IoStack->MinorFunction)
{
case IRP_MN_START_DEVICE:
DPRINT("IRP_MN_START_DEVICE\n");
- /* Create the resource list */
+ // Create the resource list
Status = PcNewResourceList(
&resource_list,
NULL,
return Status;
}
- /* forward irp to lower device object */
+ // forward irp to lower device object
Status = PcForwardIrpSynchronous(DeviceObject, Irp);
if (!NT_SUCCESS(Status))
{
- /* lower device object failed to start */
- resource_list->lpVtbl->Release(resource_list);
- /* complete the request */
+ // lower device object failed to start
+ resource_list->Release();
+ // complete the request
IoCompleteRequest(Irp, IO_NO_INCREMENT);
- /* return result */
+ // return result
return Status;
}
- /* sanity check */
- ASSERT(DeviceExt->StartDevice);
- /* Call the StartDevice routine */
+ // sanity check
+ //PC_ASSERT(DeviceExt->StartDevice);
+ // Call the StartDevice routine
DPRINT("Calling StartDevice at 0x%8p\n", DeviceExt->StartDevice);
Status = DeviceExt->StartDevice(DeviceObject, Irp, resource_list);
if (!NT_SUCCESS(Status))
return Status;
}
- /* Assign the resource list to our extension */
+ // Assign the resource list to our extension
DeviceExt->resources = resource_list;
Irp->IoStatus.Status = STATUS_SUCCESS;
return Status;
case IRP_MN_REMOVE_DEVICE:
- /* Clean up */
+ // Clean up
DPRINT("IRP_MN_REMOVE_DEVICE\n");
- DeviceExt->resources->lpVtbl->Release(DeviceExt->resources);
+ DeviceExt->resources->Release();
IoDeleteDevice(DeviceObject);
- /* Do not complete? */
+ // Do not complete?
Irp->IoStatus.Status = STATUS_SUCCESS;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
return STATUS_UNSUCCESSFUL;
}
-/*
- Power management. Handles IRP_MJ_POWER
- (not implemented)
-*/
NTSTATUS
NTAPI
PortClsPower(
{
DPRINT("PortClsPower called\n");
- /* TODO */
+ // TODO
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
return STATUS_SUCCESS;
}
-/*
- System control. Handles IRP_MJ_SYSTEM_CONTROL
- (not implemented)
-*/
NTSTATUS
NTAPI
PortClsSysControl(
{
DPRINT("PortClsSysControl called\n");
- /* TODO */
+ // TODO
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
PPHYSICAL_CONNECTION Connection;
DPRINT("PortClsShutdown called\n");
- /* get device extension */
+ // get device extension
DeviceExtension = (PPCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
while(!IsListEmpty(&DeviceExtension->PhysicalConnectionList))
{
- /* get connection entry */
+ // get connection entry
Entry = RemoveHeadList(&DeviceExtension->PhysicalConnectionList);
Connection = (PPHYSICAL_CONNECTION)CONTAINING_RECORD(Entry, PHYSICAL_CONNECTION, Entry);
if (Connection->FromSubDevice)
{
- /* release subdevice */
- Connection->FromSubDevice->lpVtbl->Release(Connection->FromSubDevice);
+ // release subdevice
+ Connection->FromSubDevice->Release();
}
if (Connection->ToSubDevice)
{
- /* release subdevice */
- Connection->ToSubDevice->lpVtbl->Release(Connection->ToSubDevice);
+ // release subdevice
+ Connection->ToSubDevice->Release();
}
FreeItem(Connection, TAG_PORTCLASS);
}
if (DeviceExtension->AdapterPowerManagement)
{
- /* release adapter power management */
- DPRINT1("Power %u\n", DeviceExtension->AdapterPowerManagement->lpVtbl->Release(DeviceExtension->AdapterPowerManagement));
+ // release adapter power management
+ DPRINT1("Power %u\n", DeviceExtension->AdapterPowerManagement->Release());
}
Irp->IoStatus.Status = STATUS_SUCCESS;
return STATUS_SUCCESS;
}
-
-
-/*
- ==========================================================================
- API EXPORTS
- ==========================================================================
-*/
-
-/*
- Drivers may implement their own IRP handlers. If a driver decides to let
- PortCls handle the IRP, it can do so by calling this.
-*/
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
PcDispatchIrp(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
switch ( IoStack->MajorFunction )
{
- /* PortCls */
+ // PortCls
case IRP_MJ_CREATE :
return PortClsCreate(DeviceObject, Irp);
break;
};
- /* If we reach here, we just complete the IRP */
+ // If we reach here, we just complete the IRP
Irp->IoStatus.Status = STATUS_SUCCESS;
Irp->IoStatus.Information = 0;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_SUCCESS;
}
-/*
- * @implemented
- */
+
NTSTATUS
NTAPI
PcCompleteIrp(
IN PIRP Irp,
IN NTSTATUS Status)
{
- ASSERT(DeviceObject);
- ASSERT(Irp);
- ASSERT(Status != STATUS_PENDING);
+#if 0
+ PC_ASSERT(DeviceObject);
+ PC_ASSERT(Irp);
+ PC_ASSERT(Status != STATUS_PENDING);
+#endif
Irp->IoStatus.Status = Status;
IoCompleteRequest(Irp, IO_NO_INCREMENT);
return STATUS_MORE_PROCESSING_REQUIRED;
}
+#undef IoSetCompletionRoutine
+#define IoSetCompletionRoutine(_Irp, \
+ _CompletionRoutine, \
+ _Context, \
+ _InvokeOnSuccess, \
+ _InvokeOnError, \
+ _InvokeOnCancel) \
+{ \
+ PIO_STACK_LOCATION _IrpSp; \
+ _IrpSp = IoGetNextIrpStackLocation(_Irp); \
+ _IrpSp->CompletionRoutine = (PIO_COMPLETION_ROUTINE)(_CompletionRoutine); \
+ _IrpSp->Context = (_Context); \
+ _IrpSp->Control = 0; \
+ if (_InvokeOnSuccess) _IrpSp->Control = SL_INVOKE_ON_SUCCESS; \
+ if (_InvokeOnError) _IrpSp->Control |= SL_INVOKE_ON_ERROR; \
+ if (_InvokeOnCancel) _IrpSp->Control |= SL_INVOKE_ON_CANCEL; \
+}
+
-/*
- * @implemented
- */
-NTSTATUS NTAPI
+
+NTSTATUS
+NTAPI
PcForwardIrpSynchronous(
IN PDEVICE_OBJECT DeviceObject,
IN PIRP Irp)
PPCLASS_DEVICE_EXTENSION DeviceExt;
NTSTATUS Status;
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
DeviceExt = (PPCLASS_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
- /* initialize the notification event */
+ // initialize the notification event
KeInitializeEvent(&Event, NotificationEvent, FALSE);
IoCopyCurrentIrpStackLocationToNext(Irp);
IoSetCompletionRoutine(Irp, CompletionRoutine, (PVOID)&Event, TRUE, TRUE, TRUE);
- /* now call the driver */
+ // now call the driver
Status = IoCallDriver(DeviceExt->PrevDeviceObject, Irp);
- /* did the request complete yet */
+ // did the request complete yet
if (Status == STATUS_PENDING)
{
- /* not yet, lets wait a bit */
+ // not yet, lets wait a bit
KeWaitForSingleObject(&Event, Executive, KernelMode, FALSE, NULL);
Status = Irp->IoStatus.Status;
}
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/irpstream.c
- * PURPOSE: IRP Stream handling
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-
-typedef struct
-{
- IIrpQueueVtbl *lpVtbl;
-
- LONG ref;
-
- ULONG CurrentOffset;
- LONG NumMappings;
- ULONG NumDataAvailable;
- BOOL StartStream;
- KSPIN_CONNECT *ConnectDetails;
- PKSDATAFORMAT_WAVEFORMATEX DataFormat;
-
- KSPIN_LOCK IrpListLock;
- LIST_ENTRY IrpList;
- LIST_ENTRY FreeIrpList;
- PIRP Irp;
- PVOID SilenceBuffer;
-
- ULONG OutOfMapping;
- ULONG MaxFrameSize;
- ULONG Alignment;
- ULONG MinimumDataThreshold;
-
-}IIrpQueueImpl;
-
-NTSTATUS
-NTAPI
-IIrpQueue_fnQueryInterface(
- IIrpQueue* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtbl;
- _InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- return STATUS_UNSUCCESSFUL;
-}
-
-ULONG
-NTAPI
-IIrpQueue_fnAddRef(
- IIrpQueue* iface)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- return _InterlockedIncrement(&This->ref);
-}
-
-ULONG
-NTAPI
-IIrpQueue_fnRelease(
- IIrpQueue* iface)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- _InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- /* Return new reference count */
- return This->ref;
-}
-
-
-NTSTATUS
-NTAPI
-IIrpQueue_fnInit(
- IN IIrpQueue *iface,
- IN KSPIN_CONNECT *ConnectDetails,
- IN PKSDATAFORMAT DataFormat,
- IN PDEVICE_OBJECT DeviceObject,
- IN ULONG FrameSize,
- IN ULONG Alignment,
- IN PVOID SilenceBuffer)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- This->ConnectDetails = ConnectDetails;
- This->DataFormat = (PKSDATAFORMAT_WAVEFORMATEX)DataFormat;
- This->MaxFrameSize = FrameSize;
- This->SilenceBuffer = SilenceBuffer;
- This->Alignment = Alignment;
- This->MinimumDataThreshold = ((PKSDATAFORMAT_WAVEFORMATEX)DataFormat)->WaveFormatEx.nAvgBytesPerSec / 3;
-
- InitializeListHead(&This->IrpList);
- InitializeListHead(&This->FreeIrpList);
- KeInitializeSpinLock(&This->IrpListLock);
-
- return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-IIrpQueue_fnAddMapping(
- IN IIrpQueue *iface,
- IN PUCHAR Buffer,
- IN ULONG BufferSize,
- IN PIRP Irp)
-{
- PKSSTREAM_HEADER Header;
- NTSTATUS Status = STATUS_SUCCESS;
- PIO_STACK_LOCATION IoStack;
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- /* get current irp stack location */
- IoStack = IoGetCurrentIrpStackLocation(Irp);
-
- if (!Buffer)
- {
- /* probe the stream irp */
- Status = KsProbeStreamIrp(Irp, KSSTREAM_WRITE | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK | KSPROBE_ALLOWFORMATCHANGE | KSPROBE_SYSTEMADDRESS, 0);
-
- /* check for success */
- if (!NT_SUCCESS(Status))
- {
- DPRINT1("KsProbeStreamIrp failed with %x\n", Status);
- return Status;
- }
-
- /* get the stream header */
- Header = (PKSSTREAM_HEADER)Irp->AssociatedIrp.SystemBuffer;
- ASSERT(Header);
- ASSERT(Irp->MdlAddress);
-
- if (Irp->RequestorMode != KernelMode)
- {
- /* use allocated mdl */
- Header->Data = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
- }
- }
- else
- {
- /* HACK */
- Header = (PKSSTREAM_HEADER)Buffer;
- }
-
- /* HACK */
- Irp->Tail.Overlay.DriverContext[2] = (PVOID)Header;
-
- /* sanity check */
- ASSERT(Header);
-
- /* dont exceed max frame size */
- //ASSERT(This->MaxFrameSize >= Header->DataUsed);
-
- /* increment num mappings */
- InterlockedIncrement(&This->NumMappings);
-
- /* increment num data available */
- This->NumDataAvailable += Header->DataUsed;
-
- /* mark irp as pending */
- IoMarkIrpPending(Irp);
-
- /* add irp to cancelable queue */
- KsAddIrpToCancelableQueue(&This->IrpList, &This->IrpListLock, Irp, KsListEntryTail, NULL);
-
- /* done */
- return Status;
-}
-
-NTSTATUS
-NTAPI
-IIrpQueue_fnGetMapping(
- IN IIrpQueue *iface,
- OUT PUCHAR * Buffer,
- OUT PULONG BufferSize)
-{
- PIRP Irp;
- ULONG Offset;
- //PIO_STACK_LOCATION IoStack;
- PKSSTREAM_HEADER StreamHeader;
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- /* check if there is an irp in the partially processed */
- if (This->Irp)
- {
- /* use last irp */
- if (This->Irp->Cancel == FALSE)
- {
- Irp = This->Irp;
- Offset = This->CurrentOffset;
- }
- else
- {
- /* irp has been cancelled */
- This->Irp->IoStatus.Status = STATUS_CANCELLED;
- IoCompleteRequest(This->Irp, IO_NO_INCREMENT);
- This->Irp = Irp = NULL;
- }
- }
- else
- {
- /* get a fresh new irp from the queue */
- This->Irp = Irp = KsRemoveIrpFromCancelableQueue(&This->IrpList, &This->IrpListLock, KsListEntryHead, KsAcquireAndRemoveOnlySingleItem);
- This->CurrentOffset = Offset = 0;
- }
-
- if (!Irp)
- {
- /* no irp available, use silence buffer */
- *Buffer = This->SilenceBuffer;
- *BufferSize = This->MaxFrameSize;
- /* flag for port wave pci driver */
- This->OutOfMapping = TRUE;
- /* indicate flag to restart fast buffering */
- This->StartStream = FALSE;
- return STATUS_SUCCESS;
- }
-
-#if 0
- /* get current irp stack location */
- IoStack = IoGetCurrentIrpStackLocation(Irp);
-
- /* get stream header */
- StreamHeader = (PKSSTREAM_HEADER)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
-#else
- /* HACK get stream header */
- StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
-#endif
-
- /* sanity check */
- ASSERT(StreamHeader);
-
- /* store buffersize */
- *BufferSize = StreamHeader->DataUsed - Offset;
-
- /* store buffer */
- *Buffer = &((PUCHAR)StreamHeader->Data)[Offset];
-
- /* unset flag that no irps are available */
- This->OutOfMapping = FALSE;
-
- return STATUS_SUCCESS;
-}
-
-VOID
-NTAPI
-IIrpQueue_fnUpdateMapping(
- IN IIrpQueue *iface,
- IN ULONG BytesWritten)
-{
- //PIO_STACK_LOCATION IoStack;
- PKSSTREAM_HEADER StreamHeader;
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- if (!This->Irp)
- {
- /* silence buffer was used */
- return;
- }
-
-#if 0
- /* get current irp stack location */
- IoStack = IoGetCurrentIrpStackLocation(This->Irp);
-
- /* get stream header */
- StreamHeader = (PKSSTREAM_HEADER)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
-#else
- /* HACK get stream header */
- StreamHeader = (PKSSTREAM_HEADER)This->Irp->Tail.Overlay.DriverContext[2];
-#endif
-
- /* sanity check */
- ASSERT(StreamHeader);
-
- /* add to current offset */
- This->CurrentOffset += BytesWritten;
-
- /* decrement available data counter */
- This->NumDataAvailable -= BytesWritten;
-
- if (This->CurrentOffset >= StreamHeader->DataUsed)
- {
- /* irp has been processed completly */
- This->Irp->IoStatus.Status = STATUS_SUCCESS;
-
- /* frame extend contains the original request size, DataUsed contains the real buffer size
- * is different when kmixer performs channel conversion, upsampling etc
- */
- This->Irp->IoStatus.Information = StreamHeader->FrameExtent;
-
- if (This->Irp->RequestorMode != KernelMode)
- {
- /* HACK - WDMAUD should pass PKSSTREAM_HEADERs */
- ExFreePool(StreamHeader->Data);
- ExFreePool(StreamHeader);
- }
-
- /* complete the request */
- IoCompleteRequest(This->Irp, IO_SOUND_INCREMENT);
- /* remove irp as it is complete */
- This->Irp = NULL;
- This->CurrentOffset = 0;
- }
-}
-
-ULONG
-NTAPI
-IIrpQueue_fnNumMappings(
- IN IIrpQueue *iface)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- /* returns the amount of mappings available */
- return This->NumMappings;
-}
-
-ULONG
-NTAPI
-IIrpQueue_fnNumData(
- IN IIrpQueue *iface)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
- /* returns the amount of audio stream data available */
- return This->NumDataAvailable;
-}
-
-
-BOOL
-NTAPI
-IIrpQueue_fnMinimumDataAvailable(
- IN IIrpQueue *iface)
-{
- BOOL Result;
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- if (This->StartStream)
- return TRUE;
-
- if (This->MinimumDataThreshold < This->NumDataAvailable)
- {
- This->StartStream = TRUE;
- Result = TRUE;
- }
- else
- {
- Result = FALSE;
- }
- return Result;
-}
-
-BOOL
-NTAPI
-IIrpQueue_fnCancelBuffers(
- IN IIrpQueue *iface)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- This->StartStream = FALSE;
- return TRUE;
-}
-
-VOID
-NTAPI
-IIrpQueue_fnUpdateFormat(
- IN IIrpQueue *iface,
- PKSDATAFORMAT DataFormat)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
- This->DataFormat = (PKSDATAFORMAT_WAVEFORMATEX)DataFormat;
- This->MinimumDataThreshold = This->DataFormat->WaveFormatEx.nAvgBytesPerSec / 3;
- This->StartStream = FALSE;
- This->NumDataAvailable = 0;
-}
-
-NTSTATUS
-NTAPI
-IIrpQueue_fnGetMappingWithTag(
- IN IIrpQueue *iface,
- IN PVOID Tag,
- OUT PPHYSICAL_ADDRESS PhysicalAddress,
- OUT PVOID *VirtualAddress,
- OUT PULONG ByteCount,
- OUT PULONG Flags)
-{
- PKSSTREAM_HEADER StreamHeader;
- PIRP Irp;
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- *Flags = 0;
- ASSERT(Tag != NULL);
-
- /* get an irp from the queue */
- Irp = KsRemoveIrpFromCancelableQueue(&This->IrpList, &This->IrpListLock, KsListEntryHead, KsAcquireAndRemoveOnlySingleItem);
-
- /* check if there is an irp */
- if (!Irp)
- {
- /* no irp available */
- This->OutOfMapping = TRUE;
- This->StartStream = FALSE;
- return STATUS_UNSUCCESSFUL;
- }
-
- /* HACK get stream header */
- StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
-
- /* store mapping in the free list */
- ExInterlockedInsertTailList(&This->FreeIrpList, &Irp->Tail.Overlay.ListEntry, &This->IrpListLock);
-
- /* return mapping */
- *PhysicalAddress = MmGetPhysicalAddress(StreamHeader->Data);
- *VirtualAddress = StreamHeader->Data;
- *ByteCount = StreamHeader->DataUsed;
-
- /* decrement mapping count */
- InterlockedDecrement(&This->NumMappings);
- /* decrement num data available */
- This->NumDataAvailable -= StreamHeader->DataUsed;
-
- /* store tag in irp */
- Irp->Tail.Overlay.DriverContext[3] = Tag;
-
- /* done */
- return STATUS_SUCCESS;
-}
-
-NTSTATUS
-NTAPI
-IIrpQueue_fnReleaseMappingWithTag(
- IN IIrpQueue *iface,
- IN PVOID Tag)
-{
- PIRP Irp;
- PLIST_ENTRY CurEntry;
- PKSSTREAM_HEADER StreamHeader;
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- DPRINT("IIrpQueue_fnReleaseMappingWithTag Tag %p\n", Tag);
-
- /* remove irp from used list */
- CurEntry = ExInterlockedRemoveHeadList(&This->FreeIrpList, &This->IrpListLock);
- /* sanity check */
- ASSERT(CurEntry);
-
- /* get irp from list entry */
- Irp = (PIRP)CONTAINING_RECORD(CurEntry, IRP, Tail.Overlay.ListEntry);
-
- /* HACK get stream header */
- StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
-
- /* driver must release items in the same order */
- ASSERT(Irp->Tail.Overlay.DriverContext[3] == Tag);
-
- /* irp has been processed completly */
- Irp->IoStatus.Status = STATUS_SUCCESS;
-
- /* frame extend contains the original request size, DataUsed contains the real buffer size
- * is different when kmixer performs channel conversion, upsampling etc
- */
- Irp->IoStatus.Information = StreamHeader->FrameExtent;
-
- /* free stream data, no tag as wdmaud.drv does it atm */
- ExFreePool(StreamHeader->Data);
-
- /* free stream header, no tag as wdmaud.drv allocates it atm */
- ExFreePool(StreamHeader);
-
- /* complete the request */
- IoCompleteRequest(Irp, IO_SOUND_INCREMENT);
-
- return STATUS_SUCCESS;
-}
-
-BOOL
-NTAPI
-IIrpQueue_fnHasLastMappingFailed(
- IN IIrpQueue *iface)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
- return This->OutOfMapping;
-}
-
-VOID
-NTAPI
-IIrpQueue_fnPrintQueueStatus(
- IN IIrpQueue *iface)
-{
-
-}
-
-VOID
-NTAPI
-IIrpQueue_fnSetMinimumDataThreshold(
- IN IIrpQueue *iface,
- ULONG MinimumDataThreshold)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- This->MinimumDataThreshold = MinimumDataThreshold;
-}
-
-ULONG
-NTAPI
-IIrpQueue_fnGetMinimumDataThreshold(
- IN IIrpQueue *iface)
-{
- IIrpQueueImpl * This = (IIrpQueueImpl*)iface;
-
- return This->MinimumDataThreshold;
-}
-
-
-static IIrpQueueVtbl vt_IIrpQueue =
-{
- IIrpQueue_fnQueryInterface,
- IIrpQueue_fnAddRef,
- IIrpQueue_fnRelease,
- IIrpQueue_fnInit,
- IIrpQueue_fnAddMapping,
- IIrpQueue_fnGetMapping,
- IIrpQueue_fnUpdateMapping,
- IIrpQueue_fnNumMappings,
- IIrpQueue_fnNumData,
- IIrpQueue_fnMinimumDataAvailable,
- IIrpQueue_fnCancelBuffers,
- IIrpQueue_fnUpdateFormat,
- IIrpQueue_fnGetMappingWithTag,
- IIrpQueue_fnReleaseMappingWithTag,
- IIrpQueue_fnHasLastMappingFailed,
- IIrpQueue_fnPrintQueueStatus,
- IIrpQueue_fnSetMinimumDataThreshold,
- IIrpQueue_fnGetMinimumDataThreshold
-};
-
-NTSTATUS
-NTAPI
-NewIrpQueue(
- IN IIrpQueue **Queue)
-{
- IIrpQueueImpl *This = AllocateItem(NonPagedPool, sizeof(IIrpQueueImpl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- This->ref = 1;
- This->lpVtbl = &vt_IIrpQueue;
-
- *Queue = (IIrpQueue*)This;
- return STATUS_SUCCESS;
-
-}
-
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/irpstream.cpp
+ * PURPOSE: IRP Stream handling
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+
+class CIrpQueue : public IIrpQueue
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IIrpQueue;
+ CIrpQueue(IUnknown *OuterUnknown){}
+ virtual ~CIrpQueue(){}
+
+protected:
+ ULONG m_CurrentOffset;
+ LONG m_NumMappings;
+ ULONG m_NumDataAvailable;
+ BOOL m_StartStream;
+ KSPIN_CONNECT * m_ConnectDetails;
+ PKSDATAFORMAT_WAVEFORMATEX m_DataFormat;
+
+ KSPIN_LOCK m_IrpListLock;
+ LIST_ENTRY m_IrpList;
+ LIST_ENTRY m_FreeIrpList;
+ PIRP m_Irp;
+ PVOID m_SilenceBuffer;
+
+ ULONG m_OutOfMapping;
+ ULONG m_MaxFrameSize;
+ ULONG m_Alignment;
+ ULONG m_MinimumDataThreshold;
+
+ LONG m_Ref;
+
+};
+
+NTSTATUS
+NTAPI
+CIrpQueue::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+ if (IsEqualGUIDAligned(refiid, IID_IUnknown))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CIrpQueue::Init(
+ IN KSPIN_CONNECT *ConnectDetails,
+ IN PKSDATAFORMAT DataFormat,
+ IN PDEVICE_OBJECT DeviceObject,
+ IN ULONG FrameSize,
+ IN ULONG Alignment,
+ IN PVOID SilenceBuffer)
+{
+ m_ConnectDetails = ConnectDetails;
+ m_DataFormat = (PKSDATAFORMAT_WAVEFORMATEX)DataFormat;
+ m_MaxFrameSize = FrameSize;
+ m_SilenceBuffer = SilenceBuffer;
+ m_Alignment = Alignment;
+ m_MinimumDataThreshold = ((PKSDATAFORMAT_WAVEFORMATEX)DataFormat)->WaveFormatEx.nAvgBytesPerSec / 3;
+
+ InitializeListHead(&m_IrpList);
+ InitializeListHead(&m_FreeIrpList);
+ KeInitializeSpinLock(&m_IrpListLock);
+
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NTAPI
+CIrpQueue::AddMapping(
+ IN PUCHAR Buffer,
+ IN ULONG BufferSize,
+ IN PIRP Irp)
+{
+ PKSSTREAM_HEADER Header;
+ NTSTATUS Status = STATUS_SUCCESS;
+ PIO_STACK_LOCATION IoStack;
+
+ // get current irp stack location
+ IoStack = IoGetCurrentIrpStackLocation(Irp);
+
+ if (!Buffer)
+ {
+ // probe the stream irp
+ Status = KsProbeStreamIrp(Irp, KSSTREAM_WRITE | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK | KSPROBE_ALLOWFORMATCHANGE | KSPROBE_SYSTEMADDRESS, 0);
+
+ // check for success
+ if (!NT_SUCCESS(Status))
+ {
+ DPRINT1("KsProbeStreamIrp failed with %x\n", Status);
+ return Status;
+ }
+
+ // get the stream header
+ Header = (PKSSTREAM_HEADER)Irp->AssociatedIrp.SystemBuffer;
+ PC_ASSERT(Header);
+ PC_ASSERT(Irp->MdlAddress);
+
+ if (Irp->RequestorMode != KernelMode)
+ {
+ // use allocated mdl
+ Header->Data = MmGetSystemAddressForMdlSafe(Irp->MdlAddress, NormalPagePriority);
+ }
+ }
+ else
+ {
+ // HACK
+ Header = (PKSSTREAM_HEADER)Buffer;
+ }
+
+ // HACK
+ Irp->Tail.Overlay.DriverContext[2] = (PVOID)Header;
+
+ // sanity check
+ PC_ASSERT(Header);
+
+ // dont exceed max frame size
+ PC_ASSERT(m_MaxFrameSize >= Header->DataUsed);
+
+ // increment num mappings
+ InterlockedIncrement(&m_NumMappings);
+
+ // increment num data available
+ m_NumDataAvailable += Header->DataUsed;
+
+ // mark irp as pending
+ IoMarkIrpPending(Irp);
+
+ // add irp to cancelable queue
+ KsAddIrpToCancelableQueue(&m_IrpList, &m_IrpListLock, Irp, KsListEntryTail, NULL);
+
+ // done
+ return Status;
+}
+
+NTSTATUS
+NTAPI
+CIrpQueue::GetMapping(
+ OUT PUCHAR * Buffer,
+ OUT PULONG BufferSize)
+{
+ PIRP Irp;
+ ULONG Offset;
+ //PIO_STACK_LOCATION IoStack;
+ PKSSTREAM_HEADER StreamHeader;
+
+ // check if there is an irp in the partially processed
+ if (m_Irp)
+ {
+ // use last irp
+ if (m_Irp->Cancel == FALSE)
+ {
+ Irp = m_Irp;
+ Offset = m_CurrentOffset;
+ }
+ else
+ {
+ // irp has been cancelled
+ m_Irp->IoStatus.Status = STATUS_CANCELLED;
+ IoCompleteRequest(m_Irp, IO_NO_INCREMENT);
+ m_Irp = Irp = NULL;
+ }
+ }
+ else
+ {
+ // get a fresh new irp from the queue
+ m_Irp = Irp = KsRemoveIrpFromCancelableQueue(&m_IrpList, &m_IrpListLock, KsListEntryHead, KsAcquireAndRemoveOnlySingleItem);
+ m_CurrentOffset = Offset = 0;
+ }
+
+ if (!Irp)
+ {
+ // no irp available, use silence buffer
+ *Buffer = (PUCHAR)m_SilenceBuffer;
+ *BufferSize = m_MaxFrameSize;
+ // flag for port wave pci driver
+ m_OutOfMapping = TRUE;
+ // indicate flag to restart fast buffering
+ m_StartStream = FALSE;
+ return STATUS_SUCCESS;
+ }
+
+#if 0
+ // get current irp stack location
+ IoStack = IoGetCurrentIrpStackLocation(Irp);
+
+ // get stream header
+ StreamHeader = (PKSSTREAM_HEADER)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
+#else
+ // HACK get stream header
+ StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
+#endif
+
+ // sanity check
+ PC_ASSERT(StreamHeader);
+
+ // store buffersize
+ *BufferSize = StreamHeader->DataUsed - Offset;
+
+ // store buffer
+ *Buffer = &((PUCHAR)StreamHeader->Data)[Offset];
+
+ // unset flag that no irps are available
+ m_OutOfMapping = FALSE;
+
+ return STATUS_SUCCESS;
+}
+
+VOID
+NTAPI
+CIrpQueue::UpdateMapping(
+ IN ULONG BytesWritten)
+{
+ //PIO_STACK_LOCATION IoStack;
+ PKSSTREAM_HEADER StreamHeader;
+
+ if (!m_Irp)
+ {
+ // silence buffer was used
+ return;
+ }
+
+#if 0
+ // get current irp stack location
+ IoStack = IoGetCurrentIrpStackLocation(m_Irp);
+
+ // get stream header
+ StreamHeader = (PKSSTREAM_HEADER)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
+#else
+ // HACK get stream header
+ StreamHeader = (PKSSTREAM_HEADER)m_Irp->Tail.Overlay.DriverContext[2];
+#endif
+
+ // sanity check
+ // ASSERT(StreamHeader);
+
+ // add to current offset
+ m_CurrentOffset += BytesWritten;
+
+ // decrement available data counter
+ m_NumDataAvailable -= BytesWritten;
+
+ if (m_CurrentOffset >= StreamHeader->DataUsed)
+ {
+ // irp has been processed completly
+ m_Irp->IoStatus.Status = STATUS_SUCCESS;
+
+ // frame extend contains the original request size, DataUsed contains the real buffer size
+ //is different when kmixer performs channel conversion, upsampling etc
+
+ m_Irp->IoStatus.Information = StreamHeader->FrameExtent;
+
+ if (m_Irp->RequestorMode != KernelMode)
+ {
+ // HACK - WDMAUD should pass PKSSTREAM_HEADERs
+ ExFreePool(StreamHeader->Data);
+ ExFreePool(StreamHeader);
+ }
+
+ // complete the request
+ IoCompleteRequest(m_Irp, IO_SOUND_INCREMENT);
+ // remove irp as it is complete
+ m_Irp = NULL;
+ m_CurrentOffset = 0;
+ }
+}
+
+ULONG
+NTAPI
+CIrpQueue::NumMappings()
+{
+
+ // returns the amount of mappings available
+ return m_NumMappings;
+}
+
+ULONG
+NTAPI
+CIrpQueue::NumData()
+{
+ // returns the amount of audio stream data available
+ return m_NumDataAvailable;
+}
+
+
+BOOL
+NTAPI
+CIrpQueue::MinimumDataAvailable()
+{
+ BOOL Result;
+
+ if (m_StartStream)
+ return TRUE;
+
+ if (m_MinimumDataThreshold < m_NumDataAvailable)
+ {
+ m_StartStream = TRUE;
+ Result = TRUE;
+ }
+ else
+ {
+ Result = FALSE;
+ }
+ return Result;
+}
+
+BOOL
+NTAPI
+CIrpQueue::CancelBuffers()
+{
+
+ m_StartStream = FALSE;
+ return TRUE;
+}
+
+VOID
+NTAPI
+CIrpQueue::UpdateFormat(
+ PKSDATAFORMAT DataFormat)
+{
+ m_DataFormat = (PKSDATAFORMAT_WAVEFORMATEX)DataFormat;
+ m_MinimumDataThreshold = m_DataFormat->WaveFormatEx.nAvgBytesPerSec / 3;
+ m_StartStream = FALSE;
+ m_NumDataAvailable = 0;
+}
+
+NTSTATUS
+NTAPI
+CIrpQueue::GetMappingWithTag(
+ IN PVOID Tag,
+ OUT PPHYSICAL_ADDRESS PhysicalAddress,
+ OUT PVOID *VirtualAddress,
+ OUT PULONG ByteCount,
+ OUT PULONG Flags)
+{
+ PKSSTREAM_HEADER StreamHeader;
+ PIRP Irp;
+
+ *Flags = 0;
+ PC_ASSERT(Tag != NULL);
+
+ // get an irp from the queue
+ Irp = KsRemoveIrpFromCancelableQueue(&m_IrpList, &m_IrpListLock, KsListEntryHead, KsAcquireAndRemoveOnlySingleItem);
+
+ // check if there is an irp
+ if (!Irp)
+ {
+ // no irp available
+ m_OutOfMapping = TRUE;
+ m_StartStream = FALSE;
+ return STATUS_UNSUCCESSFUL;
+ }
+
+ // HACK get stream header
+ StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
+
+ // store mapping in the free list
+ ExInterlockedInsertTailList(&m_FreeIrpList, &Irp->Tail.Overlay.ListEntry, &m_IrpListLock);
+
+ // return mapping
+ *PhysicalAddress = MmGetPhysicalAddress(StreamHeader->Data);
+ *VirtualAddress = StreamHeader->Data;
+ *ByteCount = StreamHeader->DataUsed;
+
+ // decrement mapping count
+ InterlockedDecrement(&m_NumMappings);
+ // decrement num data available
+ m_NumDataAvailable -= StreamHeader->DataUsed;
+
+ // store tag in irp
+ Irp->Tail.Overlay.DriverContext[3] = Tag;
+
+ // done
+ return STATUS_SUCCESS;
+}
+
+NTSTATUS
+NTAPI
+CIrpQueue::ReleaseMappingWithTag(
+ IN PVOID Tag)
+{
+ PIRP Irp;
+ PLIST_ENTRY CurEntry;
+ PKSSTREAM_HEADER StreamHeader;
+
+ DPRINT("CIrpQueue::ReleaseMappingWithTag Tag %p\n", Tag);
+
+ // remove irp from used list
+ CurEntry = ExInterlockedRemoveHeadList(&m_FreeIrpList, &m_IrpListLock);
+ // sanity check
+ PC_ASSERT(CurEntry);
+
+ // get irp from list entry
+ Irp = (PIRP)CONTAINING_RECORD(CurEntry, IRP, Tail.Overlay.ListEntry);
+
+ // HACK get stream header
+ StreamHeader = (PKSSTREAM_HEADER)Irp->Tail.Overlay.DriverContext[2];
+
+ // driver must release items in the same order
+ PC_ASSERT(Irp->Tail.Overlay.DriverContext[3] == Tag);
+
+ // irp has been processed completly
+ Irp->IoStatus.Status = STATUS_SUCCESS;
+
+ // frame extend contains the original request size, DataUsed contains the real buffer size
+ // is different when kmixer performs channel conversion, upsampling etc
+
+ Irp->IoStatus.Information = StreamHeader->FrameExtent;
+
+ // free stream data, no tag as wdmaud.drv does it atm
+ ExFreePool(StreamHeader->Data);
+
+ // free stream header, no tag as wdmaud.drv allocates it atm
+ ExFreePool(StreamHeader);
+
+ // complete the request
+ IoCompleteRequest(Irp, IO_SOUND_INCREMENT);
+
+ return STATUS_SUCCESS;
+}
+
+BOOL
+NTAPI
+CIrpQueue::HasLastMappingFailed()
+{
+ return m_OutOfMapping;
+}
+
+VOID
+NTAPI
+CIrpQueue::PrintQueueStatus()
+{
+
+}
+
+VOID
+NTAPI
+CIrpQueue::SetMinimumDataThreshold(
+ ULONG MinimumDataThreshold)
+{
+
+ m_MinimumDataThreshold = MinimumDataThreshold;
+}
+
+ULONG
+NTAPI
+CIrpQueue::GetMinimumDataThreshold()
+{
+ return m_MinimumDataThreshold;
+}
+
+
+NTSTATUS
+NTAPI
+NewIrpQueue(
+ IN IIrpQueue **Queue)
+{
+ CIrpQueue *This = new(NonPagedPool, TAG_PORTCLASS)CIrpQueue(NULL);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ This->AddRef();
+
+ *Queue = (IIrpQueue*)This;
+ return STATUS_SUCCESS;
+}
+
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/miniport.c
+ * FILE: drivers/wdm/audio/backpln/portcls/miniport.cpp
* PURPOSE: Miniport construction api
* PROGRAMMER: Andrew Greenwood
*/
-#include "private.h"
+#include "private.hpp"
-/*
- * @implemented
- */
-NTSTATUS NTAPI
+NTSTATUS
+NTAPI
PcNewMiniport(
OUT PMINIPORT* OutMiniport,
IN REFCLSID ClassId)
NTSTATUS Status = STATUS_INVALID_PARAMETER;
DPRINT("PcNewMiniport entered\n");
- ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
+ PC_ASSERT_IRQL_EQUAL(PASSIVE_LEVEL);
if (!OutMiniport)
{
return STATUS_INVALID_PARAMETER;
}
- if (IsEqualGUIDAligned(ClassId, &CLSID_MiniportDriverDMusUART) ||
- IsEqualGUIDAligned(ClassId, &CLSID_MiniportDriverUart) ||
- IsEqualGUIDAligned(ClassId, &CLSID_MiniportDriverDMusUARTCapture))
+ if (IsEqualGUIDAligned(ClassId, CLSID_MiniportDriverDMusUART) ||
+ IsEqualGUIDAligned(ClassId, CLSID_MiniportDriverUart) ||
+ IsEqualGUIDAligned(ClassId, CLSID_MiniportDriverDMusUARTCapture))
{
Status = NewMiniportDMusUART(OutMiniport, ClassId);
}
- else if (IsEqualGUIDAligned(ClassId, &CLSID_MiniportDriverFmSynth) ||
- IsEqualGUIDAligned(ClassId, &CLSID_MiniportDriverFmSynthWithVol))
+ else if (IsEqualGUIDAligned(ClassId, CLSID_MiniportDriverFmSynth) ||
+ IsEqualGUIDAligned(ClassId, CLSID_MiniportDriverFmSynthWithVol))
{
Status = NewMiniportFmSynth(OutMiniport, ClassId);
}
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/miniport_dmus.c
- * PURPOSE: DirectMusic miniport
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-typedef struct
-{
- IMiniportDMusVtbl *lpVtbl;
- LONG ref;
- CLSID ClassId;
-
-}IMiniportDMusImpl;
-
-
-
-/* IUnknown methods */
-
-NTSTATUS
-NTAPI
-IMiniportDMus_fnQueryInterface(
- IMiniportDMus* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IMiniportDMusImpl * This = (IMiniportDMusImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IMiniportDMus))
- {
- *Output = &This->lpVtbl;
- _InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- return STATUS_UNSUCCESSFUL;
-}
-
-ULONG
-NTAPI
-IMiniportDMus_fnAddRef(
- IMiniportDMus* iface)
-{
- IMiniportDMusImpl * This = (IMiniportDMusImpl*)iface;
-
- return _InterlockedIncrement(&This->ref);
-}
-
-ULONG
-NTAPI
-IMiniportDMust_fnRelease(
- IMiniportDMus* iface)
-{
- IMiniportDMusImpl * This = (IMiniportDMusImpl*)iface;
-
- _InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- /* Return new reference count */
- return This->ref;
-}
-
-/* IMiniport methods */
-
-NTSTATUS
-NTAPI
-IMiniportDMus_fnDataRangeIntersection(
- IN IMiniportDMus * iface,
- IN ULONG PinId,
- IN PKSDATARANGE DataRange,
- IN PKSDATARANGE MatchingDataRange,
- IN ULONG OutputBufferLength,
- OUT PVOID ResultantFormat OPTIONAL,
- OUT PULONG ResultantFormatLength)
-{
- return STATUS_UNSUCCESSFUL;
-}
-
-NTSTATUS
-NTAPI
-IMiniportDMus_fnGetDescription(
- IN IMiniportDMus * iface,
- OUT PPCFILTER_DESCRIPTOR *Description
- )
-{
- return STATUS_UNSUCCESSFUL;
-}
-
-/* IMinIMiniportDMus methods */
-
-HRESULT
-NTAPI
-IMiniportDMus_fnInit(
- IN IMiniportDMus * iface,
- IN PUNKNOWN pUnknownAdapter,
- IN PRESOURCELIST pResourceList,
- IN PPORTDMUS pPort,
- OUT PSERVICEGROUP *ppServiceGroup
- )
-{
- return STATUS_UNSUCCESSFUL;
-}
-
-HRESULT
-NTAPI
-IMiniportDMus_fnNewStream(
- IN IMiniportDMus * iface,
- OUT PMXF *ppMXF,
- IN PUNKNOWN pOuterUnknown OPTIONAL,
- IN POOL_TYPE PoolType,
- IN ULONG uPinId,
- IN DMUS_STREAM_TYPE StreamType,
- IN PKSDATAFORMAT pDataFormat,
- OUT PSERVICEGROUP *ppServiceGroup,
- IN PAllocatorMXF pAllocatorMXF,
- IN PMASTERCLOCK pMasterClock,
- OUT PULONGLONG puuSchedulePreFetch
- )
-{
- return STATUS_UNSUCCESSFUL;
-}
-
-VOID
-NTAPI
-IMiniportDMus_fnService(
- IN IMiniportDMus * iface)
-{
-
-}
-
-static IMiniportDMusVtbl vt_PortDMusVtbl =
-{
- /* IUnknown */
- IMiniportDMus_fnQueryInterface,
- IMiniportDMus_fnAddRef,
- IMiniportDMust_fnRelease,
- /* IMiniport */
- IMiniportDMus_fnGetDescription,
- IMiniportDMus_fnDataRangeIntersection,
- /* IMiniportDMus */
- IMiniportDMus_fnInit,
- IMiniportDMus_fnService,
- IMiniportDMus_fnNewStream
-};
-
-NTSTATUS
-NewMiniportDMusUART(
- OUT PMINIPORT* OutMiniport,
- IN REFCLSID ClassId)
-{
- IMiniportDMusImpl * This;
-
- This = AllocateItem(NonPagedPool, sizeof(IMiniportDMusImpl), TAG_PORTCLASS);
- if (!This)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- /* Initialize IMiniportDMus */
- RtlCopyMemory(&This->ClassId, ClassId, sizeof(CLSID));
- This->ref = 1;
- This->lpVtbl = &vt_PortDMusVtbl;
- *OutMiniport = (PMINIPORT)&This->lpVtbl;
-
- return STATUS_SUCCESS;
-}
-
-
--- /dev/null
+/*
+ * COPYRIGHT: See COPYING in the top level directory
+ * PROJECT: ReactOS Kernel Streaming
+ * FILE: drivers/wdm/audio/backpln/portcls/miniport_dmus.cpp
+ * PURPOSE: DirectMusic miniport
+ * PROGRAMMER: Johannes Anderwald
+ */
+
+#include "private.hpp"
+
+class CMiniportDMus : public IMiniportDMus
+{
+public:
+ STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
+
+ STDMETHODIMP_(ULONG) AddRef()
+ {
+ InterlockedIncrement(&m_Ref);
+ return m_Ref;
+ }
+ STDMETHODIMP_(ULONG) Release()
+ {
+ InterlockedDecrement(&m_Ref);
+
+ if (!m_Ref)
+ {
+ delete this;
+ return 0;
+ }
+ return m_Ref;
+ }
+ IMP_IMiniportDMus;
+ CMiniportDMus(IUnknown *OuterUnknown){}
+ virtual ~CMiniportDMus(){}
+
+protected:
+ LONG m_Ref;
+
+};
+
+// IUnknown methods
+
+NTSTATUS
+NTAPI
+CMiniportDMus::QueryInterface(
+ IN REFIID refiid,
+ OUT PVOID* Output)
+{
+ if (IsEqualGUIDAligned(refiid, IID_IMiniportDMus))
+ {
+ *Output = PVOID(PUNKNOWN(this));
+ PUNKNOWN(*Output)->AddRef();
+ return STATUS_SUCCESS;
+ }
+ return STATUS_UNSUCCESSFUL;
+}
+
+// IMiniport methods
+
+NTSTATUS
+NTAPI
+CMiniportDMus::DataRangeIntersection(
+ IN ULONG PinId,
+ IN PKSDATARANGE DataRange,
+ IN PKSDATARANGE MatchingDataRange,
+ IN ULONG OutputBufferLength,
+ OUT PVOID ResultantFormat OPTIONAL,
+ OUT PULONG ResultantFormatLength)
+{
+ return STATUS_UNSUCCESSFUL;
+}
+
+NTSTATUS
+NTAPI
+CMiniportDMus::GetDescription(
+ OUT PPCFILTER_DESCRIPTOR *Description)
+{
+ return STATUS_UNSUCCESSFUL;
+}
+
+HRESULT
+NTAPI
+CMiniportDMus::Init(
+ IN PUNKNOWN pUnknownAdapter,
+ IN PRESOURCELIST pResourceList,
+ IN PPORTDMUS pPort,
+ OUT PSERVICEGROUP *ppServiceGroup
+ )
+{
+ return STATUS_UNSUCCESSFUL;
+}
+
+HRESULT
+NTAPI
+CMiniportDMus::NewStream(
+ OUT PMXF *ppMXF,
+ IN PUNKNOWN pOuterUnknown OPTIONAL,
+ IN POOL_TYPE PoolType,
+ IN ULONG uPinId,
+ IN DMUS_STREAM_TYPE StreamType,
+ IN PKSDATAFORMAT pDataFormat,
+ OUT PSERVICEGROUP *ppServiceGroup,
+ IN PAllocatorMXF pAllocatorMXF,
+ IN PMASTERCLOCK pMasterClock,
+ OUT PULONGLONG puuSchedulePreFetch
+ )
+{
+ return STATUS_UNSUCCESSFUL;
+}
+
+VOID
+NTAPI
+CMiniportDMus::Service()
+{
+
+}
+
+NTSTATUS
+NewMiniportDMusUART(
+ OUT PMINIPORT* OutMiniport,
+ IN REFCLSID ClassId)
+{
+ CMiniportDMus * This;
+
+ This = new(NonPagedPool, TAG_PORTCLASS)CMiniportDMus(NULL);
+ if (!This)
+ return STATUS_INSUFFICIENT_RESOURCES;
+
+ *OutMiniport = (PMINIPORT)This;
+ This->AddRef();
+
+ return STATUS_SUCCESS;
+}
+
+
/*
* COPYRIGHT: See COPYING in the top level directory
* PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/miniport_fmsynth.c
+ * FILE: drivers/wdm/audio/backpln/portcls/miniport_fmsynth.cpp
* PURPOSE: Miniport FM Synth
* PROGRAMMER: Johannes Anderwald
*/
-#include "private.h"
+#include "private.hpp"
NTSTATUS NewMiniportFmSynth(
+++ /dev/null
-/*
- * COPYRIGHT: See COPYING in the top level directory
- * PROJECT: ReactOS Kernel Streaming
- * FILE: drivers/wdm/audio/backpln/portcls/pin_dmus.c
- * PURPOSE: DMus IRP Audio Pin
- * PROGRAMMER: Johannes Anderwald
- */
-
-#include "private.h"
-
-typedef struct
-{
- IPortPinDMusVtbl *lpVtbl;
- IServiceSinkVtbl *lpVtblServiceSink;
- IMasterClockVtbl *lpVtblMasterClock;
- IAllocatorMXFVtbl *lpVtblAllocatorMXF;
- IMXFVtbl *lpVtblMXF;
-
- LONG ref;
- IPortDMus * Port;
- IPortFilterDMus * Filter;
- KSPIN_DESCRIPTOR * KsPinDescriptor;
- PMINIPORTDMUS Miniport;
-
- PSERVICEGROUP ServiceGroup;
-
- PMXF Mxf;
- ULONGLONG SchedulePreFetch;
- NPAGED_LOOKASIDE_LIST LookAsideEvent;
- NPAGED_LOOKASIDE_LIST LookAsideBuffer;
-
- PMINIPORTMIDI MidiMiniport;
- PMINIPORTMIDISTREAM MidiStream;
-
-
- KSSTATE State;
- PKSDATAFORMAT Format;
- KSPIN_CONNECT * ConnectDetails;
-
- BOOL Capture;
- PDEVICE_OBJECT DeviceObject;
- IIrpQueue * IrpQueue;
-
- ULONG TotalPackets;
- ULONG PreCompleted;
- ULONG PostCompleted;
-
- ULONG LastTag;
-
-}IPortPinDMusImpl;
-
-typedef struct
-{
- DMUS_KERNEL_EVENT Event;
- PVOID Tag;
-}DMUS_KERNEL_EVENT_WITH_TAG, *PDMUS_KERNEL_EVENT_WITH_TAG;
-
-typedef struct
-{
- IPortPinDMusImpl *Pin;
- PIO_WORKITEM WorkItem;
- KSSTATE State;
-}SETSTREAM_CONTEXT, *PSETSTREAM_CONTEXT;
-
-//==================================================================================================================================
-
-
-static
-NTSTATUS
-NTAPI
-IMasterClock_fnQueryInterface(
- IMasterClock* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblMasterClock);
-
- DPRINT("IServiceSink_fnQueryInterface entered\n");
-
- if (IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtblServiceSink;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- return STATUS_UNSUCCESSFUL;
-}
-
-static
-ULONG
-NTAPI
-IMasterClock_fnAddRef(
- IMasterClock* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblMasterClock);
- DPRINT("IServiceSink_fnAddRef entered\n");
-
- return InterlockedIncrement(&This->ref);
-}
-
-static
-ULONG
-NTAPI
-IMasterClock_fnRelease(
- IMasterClock* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblMasterClock);
-
- InterlockedDecrement(&This->ref);
-
- DPRINT("IServiceSink_fnRelease entered %u\n", This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- /* Return new reference count */
- return This->ref;
-}
-
-static
-NTSTATUS
-NTAPI
-IMasterClock_fnGetTime(
- IMasterClock* iface,
- OUT REFERENCE_TIME *prtTime)
-{
- UNIMPLEMENTED
- return STATUS_SUCCESS;
-}
-
-static IMasterClockVtbl vt_IMasterClock =
-{
- IMasterClock_fnQueryInterface,
- IMasterClock_fnAddRef,
- IMasterClock_fnRelease,
- IMasterClock_fnGetTime
-};
-
-//==================================================================================================================================
-
-
-static
-NTSTATUS
-NTAPI
-IAllocatorMXF_fnQueryInterface(
- IAllocatorMXF* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblAllocatorMXF);
-
- DPRINT("IServiceSink_fnQueryInterface entered\n");
-
- if (IsEqualGUIDAligned(refiid, &IID_IAllocatorMXF) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtblServiceSink;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- return STATUS_UNSUCCESSFUL;
-}
-
-static
-ULONG
-NTAPI
-IAllocatorMXF_fnAddRef(
- IAllocatorMXF* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblAllocatorMXF);
- DPRINT("IServiceSink_fnAddRef entered\n");
-
- return InterlockedIncrement(&This->ref);
-}
-
-static
-ULONG
-NTAPI
-IAllocatorMXF_fnRelease(
- IAllocatorMXF* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblAllocatorMXF);
-
- InterlockedDecrement(&This->ref);
-
- DPRINT("IServiceSink_fnRelease entered %u\n", This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- /* Return new reference count */
- return This->ref;
-}
-
-static
-NTSTATUS
-NTAPI
-IAllocatorMXF_fnGetMessage(
- IAllocatorMXF* iface,
- OUT PDMUS_KERNEL_EVENT * ppDMKEvt)
-{
- PVOID Buffer;
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblAllocatorMXF);
-
- Buffer = ExAllocateFromNPagedLookasideList(&This->LookAsideEvent);
- if (!Buffer)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- *ppDMKEvt = Buffer;
- RtlZeroMemory(Buffer, sizeof(DMUS_KERNEL_EVENT));
- return STATUS_SUCCESS;
-}
-
-static
-USHORT
-NTAPI
-IAllocatorMXF_fnGetBufferSize(
- IAllocatorMXF* iface)
-{
- return PAGE_SIZE;
-}
-
-static
-NTSTATUS
-NTAPI
-IAllocatorMXF_fnGetBuffer(
- IAllocatorMXF* iface,
- OUT PBYTE * ppBuffer)
-{
- PVOID Buffer;
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblAllocatorMXF);
-
- Buffer = ExAllocateFromNPagedLookasideList(&This->LookAsideBuffer);
- if (!Buffer)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- *ppBuffer = Buffer;
- RtlZeroMemory(Buffer, PAGE_SIZE);
- return STATUS_SUCCESS;
-}
-
-static
-NTSTATUS
-NTAPI
-IAllocatorMXF_fnPutBuffer(
- IAllocatorMXF* iface,
- IN PBYTE pBuffer)
-{
- PDMUS_KERNEL_EVENT_WITH_TAG Event = (PDMUS_KERNEL_EVENT_WITH_TAG)pBuffer;
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblAllocatorMXF);
-
- This->IrpQueue->lpVtbl->ReleaseMappingWithTag(This->IrpQueue, Event->Tag);
-
- ExFreeToNPagedLookasideList(&This->LookAsideBuffer, pBuffer);
- return STATUS_SUCCESS;
-}
-
-static
-NTSTATUS
-NTAPI
-IAllocatorMXF_fnSetState(
- IAllocatorMXF* iface,
- IN KSSTATE State)
-{
- UNIMPLEMENTED
- return STATUS_NOT_IMPLEMENTED;
-}
-
-static
-NTSTATUS
-NTAPI
-IAllocatorMXF_fnPutMessage(
- IAllocatorMXF* iface,
- IN PDMUS_KERNEL_EVENT pDMKEvt)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblAllocatorMXF);
-
- ExFreeToNPagedLookasideList(&This->LookAsideEvent, pDMKEvt);
- return STATUS_SUCCESS;
-}
-
-static
-NTSTATUS
-NTAPI
-IAllocatorMXF_fnConnectOutput(
- IAllocatorMXF* iface,
- IN PMXF sinkMXF)
-{
- UNIMPLEMENTED
- return STATUS_NOT_IMPLEMENTED;
-}
-
-static
-NTSTATUS
-NTAPI
-IAllocatorMXF_fnDisconnectOutput(
- IAllocatorMXF* iface,
- IN PMXF sinkMXF)
-{
- UNIMPLEMENTED
- return STATUS_NOT_IMPLEMENTED;
-}
-
-static IAllocatorMXFVtbl vt_IAllocatorMXF =
-{
- IAllocatorMXF_fnQueryInterface,
- IAllocatorMXF_fnAddRef,
- IAllocatorMXF_fnRelease,
- IAllocatorMXF_fnSetState,
- IAllocatorMXF_fnPutMessage,
- IAllocatorMXF_fnConnectOutput,
- IAllocatorMXF_fnDisconnectOutput,
- IAllocatorMXF_fnGetMessage,
- IAllocatorMXF_fnGetBufferSize,
- IAllocatorMXF_fnGetBuffer,
- IAllocatorMXF_fnPutBuffer
-};
-
-//==================================================================================================================================
-
-static
-NTSTATUS
-NTAPI
-IServiceSink_fnQueryInterface(
- IServiceSink* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblServiceSink);
-
- DPRINT("IServiceSink_fnQueryInterface entered\n");
-
- if (IsEqualGUIDAligned(refiid, &IID_IServiceSink) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtblServiceSink;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
- return STATUS_UNSUCCESSFUL;
-}
-
-static
-ULONG
-NTAPI
-IServiceSink_fnAddRef(
- IServiceSink* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblServiceSink);
- DPRINT("IServiceSink_fnAddRef entered\n");
-
- return InterlockedIncrement(&This->ref);
-}
-
-static
-ULONG
-NTAPI
-IServiceSink_fnRelease(
- IServiceSink* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblServiceSink);
-
- InterlockedDecrement(&This->ref);
-
- DPRINT("IServiceSink_fnRelease entered %u\n", This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- /* Return new reference count */
- return This->ref;
-}
-
-
-static
-VOID
-NTAPI
-SetStreamWorkerRoutine(
- IN PDEVICE_OBJECT DeviceObject,
- IN PVOID Context)
-{
- IPortPinDMusImpl * This;
- KSSTATE State;
- NTSTATUS Status;
- PSETSTREAM_CONTEXT Ctx = (PSETSTREAM_CONTEXT)Context;
-
- This = Ctx->Pin;
- State = Ctx->State;
-
- IoFreeWorkItem(Ctx->WorkItem);
- FreeItem(Ctx, TAG_PORTCLASS);
-
- /* Has the audio stream resumed? */
- if (This->IrpQueue->lpVtbl->NumMappings(This->IrpQueue) && State == KSSTATE_STOP)
- return;
-
- /* Set the state */
- if (This->MidiStream)
- {
- Status = This->MidiStream->lpVtbl->SetState(This->MidiStream, State);
- }
- else
- {
- Status = This->Mxf->lpVtbl->SetState(This->Mxf, State);
- }
-
- if (NT_SUCCESS(Status))
- {
- /* Set internal state to requested state */
- This->State = State;
-
- if (This->State == KSSTATE_STOP)
- {
- /* reset start stream */
- This->IrpQueue->lpVtbl->CancelBuffers(This->IrpQueue); //FIX function name
- DPRINT1("Stopping PreCompleted %u PostCompleted %u\n", This->PreCompleted, This->PostCompleted);
- }
- }
-}
-static
-VOID
-NTAPI
-SetStreamState(
- IN IPortPinDMusImpl * This,
- IN KSSTATE State)
-{
- PIO_WORKITEM WorkItem;
- PSETSTREAM_CONTEXT Context;
-
- ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
-
- /* Has the audio stream resumed? */
- if (This->IrpQueue->lpVtbl->NumMappings(This->IrpQueue) && State == KSSTATE_STOP)
- return;
-
- /* Has the audio state already been set? */
- if (This->State == State)
- return;
-
- /* allocate set state context */
- Context = AllocateItem(NonPagedPool, sizeof(SETSTREAM_CONTEXT), TAG_PORTCLASS);
-
- if (!Context)
- return;
-
- /* allocate work item */
- WorkItem = IoAllocateWorkItem(This->DeviceObject);
-
- if (!WorkItem)
- {
- ExFreePool(Context);
- return;
- }
-
- Context->Pin = (PVOID)This;
- Context->WorkItem = WorkItem;
- Context->State = State;
-
- /* queue the work item */
- IoQueueWorkItem(WorkItem, SetStreamWorkerRoutine, DelayedWorkQueue, (PVOID)Context);
-}
-
-VOID
-TransferMidiData(
- IPortPinDMusImpl * This)
-{
- NTSTATUS Status;
- PUCHAR Buffer;
- ULONG BufferSize;
- ULONG BytesWritten;
-
- do
- {
- Status = This->IrpQueue->lpVtbl->GetMapping(This->IrpQueue, &Buffer, &BufferSize);
- if (!NT_SUCCESS(Status))
- {
- SetStreamState(This, KSSTATE_STOP);
- return;
- }
-
- if (This->Capture)
- {
- Status = This->MidiStream->lpVtbl->Read(This->MidiStream, Buffer, BufferSize, &BytesWritten);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("Read failed with %x\n", Status);
- return;
- }
- }
- else
- {
- Status = This->MidiStream->lpVtbl->Write(This->MidiStream, Buffer, BufferSize, &BytesWritten);
- if (!NT_SUCCESS(Status))
- {
- DPRINT("Write failed with %x\n", Status);
- return;
- }
- }
-
- if (!BytesWritten)
- {
- DPRINT("Device is busy retry later\n");
- return;
- }
-
- This->IrpQueue->lpVtbl->UpdateMapping(This->IrpQueue, BytesWritten);
-
- }while(TRUE);
-
-}
-
-VOID
-TransferMidiDataToDMus(
- IPortPinDMusImpl * This)
-{
- NTSTATUS Status;
- PHYSICAL_ADDRESS PhysicalAddress;
- ULONG BufferSize, Flags;
- PVOID Buffer;
- PDMUS_KERNEL_EVENT_WITH_TAG Event, LastEvent = NULL, Root = NULL;
-
- do
- {
- This->LastTag++;
- Status = This->IrpQueue->lpVtbl->GetMappingWithTag(This->IrpQueue, UlongToPtr(This->LastTag), &PhysicalAddress, &Buffer, &BufferSize, &Flags);
- if (!NT_SUCCESS(Status))
- {
- break;
- }
-
- Status = IAllocatorMXF_fnGetMessage((IAllocatorMXF*)&This->lpVtblAllocatorMXF, (PDMUS_KERNEL_EVENT*)&Event);
- if (!NT_SUCCESS(Status))
- break;
-
- //FIXME
- //set up struct
- //Event->Event.usFlags = DMUS_KEF_EVENT_COMPLETE;
- Event->Event.cbStruct = sizeof(DMUS_KERNEL_EVENT);
- Event->Event.cbEvent = BufferSize;
- Event->Event.uData.pbData = Buffer;
-
-
- if (!Root)
- Root = Event;
- else
- LastEvent->Event.pNextEvt = (struct _DMUS_KERNEL_EVENT *)Event;
-
- LastEvent = Event;
- LastEvent->Event.pNextEvt = NULL;
- LastEvent->Tag = UlongToPtr(This->LastTag);
-
- }while(TRUE);
-
- if (!Root)
- {
- SetStreamState(This, KSSTATE_STOP);
- return;
- }
-
- Status = This->Mxf->lpVtbl->PutMessage(This->Mxf, (PDMUS_KERNEL_EVENT)Root);
- DPRINT("Status %x\n", Status);
-}
-
-
-static
-VOID
-NTAPI
-IServiceSink_fnRequestService(
- IServiceSink* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)CONTAINING_RECORD(iface, IPortPinDMusImpl, lpVtblServiceSink);
-
- ASSERT_IRQL(DISPATCH_LEVEL);
-
- if (This->MidiStream)
- {
- TransferMidiData(This);
- }
- else if (This->Mxf)
- {
- TransferMidiDataToDMus(This);
- }
-}
-
-static IServiceSinkVtbl vt_IServiceSink =
-{
- IServiceSink_fnQueryInterface,
- IServiceSink_fnAddRef,
- IServiceSink_fnRelease,
- IServiceSink_fnRequestService
-};
-
-//==================================================================================================================================
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnQueryInterface(
- IPortPinDMus* iface,
- IN REFIID refiid,
- OUT PVOID* Output)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)iface;
-
- if (IsEqualGUIDAligned(refiid, &IID_IIrpTarget) ||
- IsEqualGUIDAligned(refiid, &IID_IUnknown))
- {
- *Output = &This->lpVtbl;
- InterlockedIncrement(&This->ref);
- return STATUS_SUCCESS;
- }
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortPinDMus_fnAddRef(
- IPortPinDMus* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)iface;
-
- return InterlockedIncrement(&This->ref);
-}
-
-/*
- * @implemented
- */
-ULONG
-NTAPI
-IPortPinDMus_fnRelease(
- IPortPinDMus* iface)
-{
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)iface;
-
- InterlockedDecrement(&This->ref);
-
- if (This->ref == 0)
- {
- FreeItem(This, TAG_PORTCLASS);
- return 0;
- }
- return This->ref;
-}
-
-/*
- * @unimplemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnNewIrpTarget(
- IN IPortPinDMus* iface,
- OUT struct IIrpTarget **OutTarget,
- IN WCHAR * Name,
- IN PUNKNOWN Unknown,
- IN POOL_TYPE PoolType,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp,
- IN KSOBJECT_CREATE *CreateObject)
-{
- UNIMPLEMENTED
-
- Irp->IoStatus.Information = 0;
- Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @unimplemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnDeviceIoControl(
- IN IPortPinDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- UNIMPLEMENTED
-
- Irp->IoStatus.Information = 0;
- Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
- return STATUS_UNSUCCESSFUL;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnRead(
- IN IPortPinDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnWrite(
- IN IPortPinDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnFlush(
- IN IPortPinDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-static
-VOID
-NTAPI
-CloseStreamRoutine(
- IN PDEVICE_OBJECT DeviceObject,
- IN PVOID Context)
-{
- PMINIPORTMIDISTREAM Stream = NULL;
- NTSTATUS Status;
- ISubdevice *ISubDevice;
- PSUBDEVICE_DESCRIPTOR Descriptor;
- IPortPinDMusImpl * This;
- PCLOSESTREAM_CONTEXT Ctx = (PCLOSESTREAM_CONTEXT)Context;
-
- This = (IPortPinDMusImpl*)Ctx->Pin;
-
- if (This->MidiStream)
- {
- if (This->State != KSSTATE_STOP)
- {
- This->MidiStream->lpVtbl->SetState(This->MidiStream, KSSTATE_STOP);
- KeStallExecutionProcessor(10);
- }
- Stream = This->MidiStream;
- This->MidiStream = NULL;
- }
-
- if (This->ServiceGroup)
- {
- This->ServiceGroup->lpVtbl->RemoveMember(This->ServiceGroup, (PSERVICESINK)&This->lpVtblServiceSink);
- This->ServiceGroup->lpVtbl->Release(This->ServiceGroup);
- }
-
- Status = This->Port->lpVtbl->QueryInterface(This->Port, &IID_ISubdevice, (PVOID*)&ISubDevice);
- if (NT_SUCCESS(Status))
- {
- Status = ISubDevice->lpVtbl->GetDescriptor(ISubDevice, &Descriptor);
- if (NT_SUCCESS(Status))
- {
- ISubDevice->lpVtbl->Release(ISubDevice);
- Descriptor->Factory.Instances[This->ConnectDetails->PinId].CurrentPinInstanceCount--;
- }
- }
-
- if (This->Format)
- {
- ExFreePool(This->Format);
- This->Format = NULL;
- }
-
- /* complete the irp */
- Ctx->Irp->IoStatus.Information = 0;
- Ctx->Irp->IoStatus.Status = STATUS_SUCCESS;
- IoCompleteRequest(Ctx->Irp, IO_NO_INCREMENT);
-
- /* free the work item */
- IoFreeWorkItem(Ctx->WorkItem);
-
- /* free work item ctx */
- FreeItem(Ctx, TAG_PORTCLASS);
-
- /* destroy DMus pin */
- This->Filter->lpVtbl->FreePin(This->Filter, (PPORTPINDMUS)This);
-
- if (Stream)
- {
- DPRINT1("Closing stream at Irql %u\n", KeGetCurrentIrql());
- Stream->lpVtbl->Release(Stream);
- }
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnClose(
- IN IPortPinDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- PCLOSESTREAM_CONTEXT Ctx;
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)iface;
-
- if (This->MidiStream || This->Mxf)
- {
- Ctx = AllocateItem(NonPagedPool, sizeof(CLOSESTREAM_CONTEXT), TAG_PORTCLASS);
- if (!Ctx)
- {
- DPRINT1("Failed to allocate stream context\n");
- goto cleanup;
- }
-
- Ctx->WorkItem = IoAllocateWorkItem(DeviceObject);
- if (!Ctx->WorkItem)
- {
- DPRINT1("Failed to allocate work item\n");
- goto cleanup;
- }
-
- Ctx->Irp = Irp;
- Ctx->Pin = (PVOID)This;
-
- IoMarkIrpPending(Irp);
- Irp->IoStatus.Information = 0;
- Irp->IoStatus.Status = STATUS_PENDING;
-
- /* defer work item */
- IoQueueWorkItem(Ctx->WorkItem, CloseStreamRoutine, DelayedWorkQueue, (PVOID)Ctx);
- /* Return result */
- return STATUS_PENDING;
- }
-
- Irp->IoStatus.Information = 0;
- Irp->IoStatus.Status = STATUS_SUCCESS;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
-
- return STATUS_SUCCESS;
-
-cleanup:
-
- if (Ctx)
- FreeItem(Ctx, TAG_PORTCLASS);
-
- Irp->IoStatus.Information = 0;
- Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
- IoCompleteRequest(Irp, IO_NO_INCREMENT);
- return STATUS_UNSUCCESSFUL;
-
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnQuerySecurity(
- IN IPortPinDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnSetSecurity(
- IN IPortPinDMus* iface,
- IN PDEVICE_OBJECT DeviceObject,
- IN PIRP Irp)
-{
- return KsDispatchInvalidDeviceRequest(DeviceObject, Irp);
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortPinDMus_fnFastDeviceIoControl(
- IN IPortPinDMus* iface,
- IN PFILE_OBJECT FileObject,
- IN BOOLEAN Wait,
- IN PVOID InputBuffer,
- IN ULONG InputBufferLength,
- OUT PVOID OutputBuffer,
- IN ULONG OutputBufferLength,
- IN ULONG IoControlCode,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- UNIMPLEMENTED
- return FALSE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortPinDMus_fnFastRead(
- IN IPortPinDMus* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- NTSTATUS Status;
- PCONTEXT_WRITE Packet;
- PIRP Irp;
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)iface;
-
- DPRINT("IPortPinDMus_fnFastRead entered\n");
-
- Packet = (PCONTEXT_WRITE)Buffer;
-
- Irp = Packet->Irp;
- StatusBlock->Status = STATUS_PENDING;
-
- Status = This->IrpQueue->lpVtbl->AddMapping(This->IrpQueue, Buffer, Length, Irp);
-
- if (!NT_SUCCESS(Status))
- return FALSE;
-
- StatusBlock->Status = STATUS_PENDING;
- return TRUE;
-}
-
-/*
- * @implemented
- */
-BOOLEAN
-NTAPI
-IPortPinDMus_fnFastWrite(
- IN IPortPinDMus* iface,
- IN PFILE_OBJECT FileObject,
- IN PLARGE_INTEGER FileOffset,
- IN ULONG Length,
- IN BOOLEAN Wait,
- IN ULONG LockKey,
- IN PVOID Buffer,
- OUT PIO_STATUS_BLOCK StatusBlock,
- IN PDEVICE_OBJECT DeviceObject)
-{
- NTSTATUS Status;
- PCONTEXT_WRITE Packet;
- PIRP Irp;
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)iface;
-
- InterlockedIncrement((PLONG)&This->TotalPackets);
-
- DPRINT("IPortPinDMus_fnFastWrite entered Total %u Pre %u Post %u\n", This->TotalPackets, This->PreCompleted, This->PostCompleted);
-
- Packet = (PCONTEXT_WRITE)Buffer;
-
-
- if (This->IrpQueue->lpVtbl->MinimumDataAvailable(This->IrpQueue))
- {
- Irp = Packet->Irp;
- StatusBlock->Status = STATUS_PENDING;
- InterlockedIncrement((PLONG)&This->PostCompleted);
- }
- else
- {
- Irp = NULL;
- Packet->Irp->IoStatus.Status = STATUS_SUCCESS;
- Packet->Irp->IoStatus.Information = Packet->Header.FrameExtent;
- IoCompleteRequest(Packet->Irp, IO_SOUND_INCREMENT);
- StatusBlock->Status = STATUS_SUCCESS;
- InterlockedIncrement((PLONG)&This->PreCompleted);
- }
-
- Status = This->IrpQueue->lpVtbl->AddMapping(This->IrpQueue, Buffer, Length, Irp);
-
- if (!NT_SUCCESS(Status))
- return FALSE;
-
- StatusBlock->Status = STATUS_PENDING;
- return TRUE;
-}
-
-/*
- * @implemented
- */
-NTSTATUS
-NTAPI
-IPortPinDMus_fnInit(
- IN IPortPinDMus* iface,
- IN PPORTDMUS Port,
- IN PPORTFILTERDMUS Filter,
- IN KSPIN_CONNECT * ConnectDetails,
- IN KSPIN_DESCRIPTOR * KsPinDescriptor,
- IN PDEVICE_OBJECT DeviceObject)
-{
- NTSTATUS Status;
- PKSDATAFORMAT DataFormat;
- BOOL Capture;
-
- IPortPinDMusImpl * This = (IPortPinDMusImpl*)iface;
-
- Port->lpVtbl->AddRef(Port);
- Filter->lpVtbl->AddRef(Filter);
-
- This->Port = Port;
- This->Filter = Filter;
- This->KsPinDescriptor = KsPinDescriptor;
- This->ConnectDetails = ConnectDetails;
- This->DeviceObject = DeviceObject;
- GetDMusMiniport(Port, &This->Miniport, &This->MidiMiniport);
-
- DataFormat = (PKSDATAFORMAT)(ConnectDetails + 1);
-
- DPRINT("IPortPinDMus_fnInit entered\n");
-
- This->Format = ExAllocatePoolWithTag(NonPagedPool, DataFormat->FormatSize, TAG_PORTCLASS);
- if (!This->Format)
- return STATUS_INSUFFICIENT_RESOURCES;
-
- RtlMoveMemory(This->Format, DataFormat, DataFormat->FormatSize);
-
- if (KsPinDescriptor->Communication ==
projects / reactos.git / commitdiff