NTSTATUS
CCaptureDevice::
PnpStart (
IN PCM_RESOURCE_LIST TranslatedResourceList,
IN PCM_RESOURCE_LIST UntranslatedResourceList
)
/*++
Routine Description:
Called at Pnp start. We start up our virtual hardware simulation.
Arguments:
TranslatedResourceList -
The translated resource list from Pnp
UntranslatedResourceList -
The untranslated resource list from Pnp
Return Value:
Success / Failure
--*/
{
PAGED_CODE();
//
// Normally, we'd do things here like parsing the resource lists and
// connecting our interrupt. Since this is a simulation, there isn't
// much to parse. The parsing and connection should be the same as
// any WDM driver. The sections that will differ are illustrated below
// in setting up a simulated DMA.
//
NTSTATUS Status = STATUS_SUCCESS;
if (!m_Device -> Started) {
// Create the Filter for the device
KsAcquireDevice(m_Device);
Status = KsCreateFilterFactory( m_Device->FunctionalDeviceObject,
&CaptureFilterDescriptor,
L"GLOBAL",
NULL,
KSCREATE_ITEM_FREEONSTOP,
NULL,
NULL,
NULL );
KsReleaseDevice(m_Device);
}
//
// By PnP, it's possible to receive multiple starts without an intervening
// stop (to reevaluate resources, for example). Thus, we only perform
// creations of the simulation on the initial start and ignore any
// subsequent start. Hardware drivers with resources should evaluate
// resources and make changes on 2nd start.
//
if (NT_SUCCESS(Status) && (!m_Device -> Started)) {
m_HardwareSimulation = new (NonPagedPool) CHardwareSimulation (this);
if (!m_HardwareSimulation) {
//
// If we couldn't create the hardware simulation, fail.
//
Status = STATUS_INSUFFICIENT_RESOURCES;
} else {
Status = KsAddItemToObjectBag (
m_Device -> Bag,
reinterpret_cast <PVOID> (m_HardwareSimulation),
reinterpret_cast <PFNKSFREE> (CHardwareSimulation::Cleanup)
);
if (!NT_SUCCESS (Status)) {
delete m_HardwareSimulation;
}
}
#if defined(_X86_)
//
// DMA operations illustrated in this sample are applicable only for 32bit platform.
//
INTERFACE_TYPE InterfaceBuffer;
ULONG InterfaceLength;
DEVICE_DESCRIPTION DeviceDescription;
if (NT_SUCCESS (Status)) {
//
// Set up DMA...
//
// Ordinarilly, we'd be using InterfaceBuffer or
// InterfaceTypeUndefined if !NT_SUCCESS (IfStatus) as the
// InterfaceType below; however, for the purposes of this sample,
// we lie and say we're on the PCI Bus. Otherwise, we're using map
// registers on x86 32 bit physical to 32 bit logical and this isn't
// what I want to show in this sample.
//
//
// NTSTATUS IfStatus =
IoGetDeviceProperty (
m_Device -> PhysicalDeviceObject,
DevicePropertyLegacyBusType,
sizeof (INTERFACE_TYPE),
&InterfaceBuffer,
&InterfaceLength
);
//
// Initialize our fake device description. We claim to be a
// bus-mastering 32-bit scatter/gather capable piece of hardware.
//
DeviceDescription.Version = DEVICE_DESCRIPTION_VERSION;
DeviceDescription.DmaChannel = ((ULONG) ~0);
DeviceDescription.InterfaceType = PCIBus;
DeviceDescription.DmaWidth = Width32Bits;
DeviceDescription.DmaSpeed = Compatible;
DeviceDescription.ScatterGather = TRUE;
DeviceDescription.Master = TRUE;
DeviceDescription.Dma32BitAddresses = TRUE;
DeviceDescription.AutoInitialize = FALSE;
DeviceDescription.MaximumLength = (ULONG) -1;
//
// Get a DMA adapter object from the system.
//
m_DmaAdapterObject = IoGetDmaAdapter (
m_Device -> PhysicalDeviceObject,
&DeviceDescription,
&m_NumberOfMapRegisters
);
if (!m_DmaAdapterObject) {
Status = STATUS_UNSUCCESSFUL;
}
}
if (NT_SUCCESS (Status)) {
//
// Initialize our DMA adapter object with AVStream. This is
// **ONLY** necessary **IF** you are doing DMA directly into
// capture buffers as this sample does. For this,
// KSPIN_FLAG_GENERATE_MAPPINGS must be specified on a queue.
//
//
// The (1 << 20) below is the maximum size of a single s/g mapping
// that this hardware can handle. Note that I have pulled this
// number out of thin air for the "fake" hardware.
//
KsDeviceRegisterAdapterObject (
m_Device,
m_DmaAdapterObject,
(1 << 20),
sizeof (KSMAPPING)
);
}
#endif
}
return Status;
}
NTSTATUS
CCaptureDevice::
DispatchCreate (
IN PKSDEVICE Device
)
/*++
Routine Description:
Create the capture device. This is the creation dispatch for the
capture device.
Arguments:
Device -
The AVStream device being created.
Return Value:
Success / Failure
--*/
{
PAGED_CODE();
NTSTATUS Status;
CCaptureDevice *CapDevice = new (NonPagedPool) CCaptureDevice (Device);
if (!CapDevice) {
//
// Return failure if we couldn't create the pin.
//
Status = STATUS_INSUFFICIENT_RESOURCES;
} else {
//
// Add the item to the object bag if we were successful.
// Whenever the device goes away, the bag is cleaned up and
// we will be freed.
//
// For backwards compatibility with DirectX 8.0, we must grab
// the device mutex before doing this. For Windows XP, this is
// not required, but it is still safe.
//
KsAcquireDevice (Device);
Status = KsAddItemToObjectBag (
Device -> Bag,
reinterpret_cast <PVOID> (CapDevice),
reinterpret_cast <PFNKSFREE> (CCaptureDevice::Cleanup)
);
KsReleaseDevice (Device);
if (!NT_SUCCESS (Status)) {
delete CapDevice;
} else {
Device -> Context = reinterpret_cast <PVOID> (CapDevice);
}
}
return Status;
}
/*****************************************************************************
* CreateMidiFilterFactory()
*****************************************************************************
*//*!
* @brief
* Filter factory create function.
* @details
* Creates a device control filter factory.
* @return
* Returns STATUS_SUCCESS if successful. Otherwise, returns an appropriate
* error code.
*/
NTSTATUS
CreateMidiFilterFactory
(
IN PKSDEVICE KsDevice,
IN PWCHAR RefString,
IN PVOID Parameter1,
IN PVOID Parameter2
)
{
PAGED_CODE();
_DbgPrintF(DEBUGLVL_BLAB,("[CMidiFilterFactory::Instantiate]"));
NTSTATUS ntStatus;
CMidiFilterFactory * FilterFactory = new(NonPagedPool,'rCcP') CMidiFilterFactory(NULL);
if (FilterFactory)
{
FilterFactory->AddRef();
ntStatus = FilterFactory->Init(KsDevice, Parameter1, Parameter2);
PKSFILTER_DESCRIPTOR KsFilterDescriptor = NULL;
if (NT_SUCCESS(ntStatus))
{
ntStatus = FilterFactory->GetFilterDescription(&KsFilterDescriptor);
}
if (NT_SUCCESS(ntStatus))
{
#define PROXY_CLSID L"{17CCA71B-ECD7-11D0-B908-00A0C9223196}"
PKSADAPTER KsAdapter = PKSADAPTER(KsDevice->Context);
for (ULONG i = 0; i < KsFilterDescriptor->CategoriesCount; i++)
{
// Do what normally done by INF AddInterface directive.
KsAdapter->AddSubDeviceInterface(RefString, KsFilterDescriptor->Categories[i]);
KsAdapter->SetSubDeviceParameter(RefString, KsFilterDescriptor->Categories[i], L"CLSID", REG_SZ, PROXY_CLSID, sizeof(PROXY_CLSID));
}
CMidiFilterFactory::SetupFriendlyName(KsAdapter, KsFilterDescriptor, RefString, Parameter1, Parameter2);
KsAcquireDevice(KsDevice);
PKSFILTERFACTORY KsFilterFactory = NULL;
ntStatus = KsCreateFilterFactory
(
KsDevice->FunctionalDeviceObject,
KsFilterDescriptor,
RefString,
NULL,
0,
CMidiFilterFactory::SleepCallback,
CMidiFilterFactory::WakeCallback,
&KsFilterFactory
);
if (NT_SUCCESS(ntStatus))
{
KsFilterFactory->Context = PVOID(FilterFactory);
}
KsReleaseDevice(KsDevice);
}
if (NT_SUCCESS(ntStatus))
{
//
// Add the item to the object bag if we were successful. Whenever the device goes
// away, the bag is cleaned up and we will be freed.
//
// For backwards compatibility with DirectX 8.0, we must grab the device mutex
// before doing this. For Windows XP, this is not required, but it is still safe.
//
KsAcquireDevice(KsDevice);
ntStatus = KsAddItemToObjectBag(KsDevice->Bag, FilterFactory, (PFNKSFREE)CMidiFilterFactory::Destruct);
KsReleaseDevice(KsDevice);
}
if (NT_SUCCESS(ntStatus))
{
// Keeping this object...
FilterFactory->AddRef();
}
// Release the private reference.
FilterFactory->Release();
}
else
{
ntStatus = STATUS_INSUFFICIENT_RESOURCES;
}
return ntStatus;
}
