drivers/ksfilter/ks/device.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel Streaming
   4  * FILE:            drivers/ksfilter/ks/device.c
   5  * PURPOSE:         KS IKsDevice interface functions
   6  * PROGRAMMER:      Johannes Anderwald
   7  */
   8
   9
  10 #include "priv.h"
  11
  12 NTSTATUS
  13 NTAPI
  14 IKsDevice_fnQueryInterface(
  15     IN IKsDevice * iface,
  16     REFIID refiid,
  17     PVOID* Output)
  18 {
  19     NTSTATUS Status;
  20     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
  21
  22     if (IsEqualGUIDAligned(refiid, &IID_IUnknown))
  23     {
  24         *Output = &This->BasicHeader.OuterUnknown;
  25         _InterlockedIncrement(&This->ref);
  26         return STATUS_SUCCESS;
  27     }
  28
  29     if (This->BasicHeader.ClientAggregate)
  30     {
  31          /* using client aggregate */
  32          Status = This->BasicHeader.ClientAggregate->lpVtbl->QueryInterface(This->BasicHeader.ClientAggregate, refiid, Output);
  33
  34          if (NT_SUCCESS(Status))
  35          {
  36              /* client aggregate supports interface */
  37              return Status;
  38          }
  39     }
  40
  41     DPRINT("IKsDevice_fnQueryInterface no interface\n");
  42     return STATUS_NOT_SUPPORTED;
  43 }
  44
  45 ULONG
  46 NTAPI
  47 IKsDevice_fnAddRef(
  48     IN IKsDevice * iface)
  49 {
  50     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
  51
  52     return InterlockedIncrement(&This->ref);
  53 }
  54
  55 ULONG
  56 NTAPI
  57 IKsDevice_fnRelease(
  58     IN IKsDevice * iface)
  59 {
  60     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
  61
  62     InterlockedDecrement(&This->ref);
  63
  64     return This->ref;
  65 }
  66
  67
  68
  69 PKSDEVICE
  70 NTAPI
  71 IKsDevice_fnGetStruct(
  72     IN IKsDevice * iface)
  73 {
  74     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
  75
  76     return &This->KsDevice;
  77 }
  78
  79 NTSTATUS
  80 NTAPI
  81 IKsDevice_fnInitializeObjectBag(
  82     IN IKsDevice * iface,
  83     IN PKSIOBJECT_BAG Bag,
  84     IN PRKMUTEX Mutex)
  85 {
  86     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
  87
  88     if (!Mutex)
  89     {
  90         /* use device mutex */
  91         Mutex = &This->BagMutex;
  92     }
  93
  94     /* initialize object bag */
  95     Bag->BagMutex = Mutex;
  96     Bag->DeviceHeader = (PKSIDEVICE_HEADER)This;
  97     InitializeListHead(&Bag->ObjectList);
  98
  99     /* insert bag into device list */
 100     InsertTailList(&This->ObjectBags, &Bag->Entry);
 101
 102     return STATUS_SUCCESS;
 103 }
 104
 105 NTSTATUS
 106 NTAPI
 107 IKsDevice_fnAcquireDevice(
 108     IN IKsDevice * iface)
 109 {
 110     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
 111
 112     return KeWaitForSingleObject(&This->DeviceMutex, Executive, KernelMode, FALSE, NULL);
 113 }
 114
 115 NTSTATUS
 116 NTAPI
 117 IKsDevice_fnReleaseDevice(
 118     IN IKsDevice * iface)
 119 {
 120     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
 121
 122     return KeReleaseMutex(&This->DeviceMutex, FALSE);
 123 }
 124
 125 NTSTATUS
 126 NTAPI
 127 IKsDevice_fnGetAdapterObject(
 128     IN IKsDevice * iface,
 129     IN PADAPTER_OBJECT * Object,
 130     IN PULONG MaxMappingsByteCount,
 131     IN PULONG MappingTableStride)
 132 {
 133     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
 134
 135     *Object = This->AdapterObject;
 136     *MaxMappingsByteCount = This->MaxMappingsByteCount;
 137     *MappingTableStride = This->MappingTableStride;
 138
 139     return STATUS_SUCCESS;
 140
 141 }
 142
 143 NTSTATUS
 144 NTAPI
 145 IKsDevice_fnAddPowerEntry(
 146     IN IKsDevice * iface,
 147     IN struct KSPOWER_ENTRY * Entry,
 148     IN IKsPowerNotify* Notify)
 149 {
 150     //PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
 151
 152     UNIMPLEMENTED
 153     return STATUS_NOT_IMPLEMENTED;
 154 }
 155
 156 NTSTATUS
 157 NTAPI
 158 IKsDevice_fnRemovePowerEntry(
 159     IN IKsDevice * iface,
 160     IN struct KSPOWER_ENTRY * Entry)
 161 {
 162     //PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
 163
 164     UNIMPLEMENTED
 165     return STATUS_NOT_IMPLEMENTED;
 166
 167 }
 168
 169 NTSTATUS
 170 NTAPI
 171 IKsDevice_fnPinStateChange(
 172     IN IKsDevice * iface,
 173     IN KSPIN Pin,
 174     IN PIRP Irp,
 175     IN KSSTATE OldState,
 176     IN KSSTATE NewState)
 177 {
 178     //PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
 179
 180     UNIMPLEMENTED
 181     return STATUS_NOT_IMPLEMENTED;
 182
 183 }
 184
 185 NTSTATUS
 186 NTAPI
 187 IKsDevice_fnArbitrateAdapterChannel(
 188     IN IKsDevice * iface,
 189     IN ULONG NumberOfMapRegisters,
 190     IN PDRIVER_CONTROL ExecutionRoutine,
 191     IN PVOID Context)
 192 {
 193     PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
 194     NTSTATUS Status;
 195
 196     DPRINT("IKsDevice_fnArbitrateAdapterChannel NumberOfMapRegisters %lu ExecutionRoutine %p Context %p Irql %lu\n", NumberOfMapRegisters, ExecutionRoutine, Context, KeGetCurrentIrql());
 197
 198     /* sanity check */
 199     ASSERT(KeGetCurrentIrql() == DISPATCH_LEVEL);
 200     ASSERT(This->AdapterObject);
 201
 202     /* allocate adapter channel */
 203     Status = IoAllocateAdapterChannel(This->AdapterObject, This->KsDevice.FunctionalDeviceObject, NumberOfMapRegisters, ExecutionRoutine, Context);
 204
 205     /* done */
 206     return Status;
 207 }
 208
 209 NTSTATUS
 210 NTAPI
 211 IKsDevice_fnCheckIoCapability(
 212     IN IKsDevice * iface,
 213     IN ULONG Unknown)
 214 {
 215     //PKSIDEVICE_HEADER This = (PKSIDEVICE_HEADER)CONTAINING_RECORD(iface, KSIDEVICE_HEADER, BasicHeader.OuterUnknown);
 216
 217     UNIMPLEMENTED
 218     return STATUS_NOT_IMPLEMENTED;
 219 }
 220
 221 static IKsDeviceVtbl vt_IKsDevice =
 222 {
 223     IKsDevice_fnQueryInterface,
 224     IKsDevice_fnAddRef,
 225     IKsDevice_fnRelease,
 226     IKsDevice_fnGetStruct,
 227     IKsDevice_fnInitializeObjectBag,
 228     IKsDevice_fnAcquireDevice,
 229     IKsDevice_fnReleaseDevice,
 230     IKsDevice_fnGetAdapterObject,
 231     IKsDevice_fnAddPowerEntry,
 232     IKsDevice_fnRemovePowerEntry,
 233     IKsDevice_fnPinStateChange,
 234     IKsDevice_fnArbitrateAdapterChannel,
 235     IKsDevice_fnCheckIoCapability
 236 };
 237
 238
 239 VOID
 240 NTAPI
 241 IKsDevice_PnpPostStart(
 242     IN PDEVICE_OBJECT  DeviceObject,
 243     IN PVOID  Context)
 244 {
 245     NTSTATUS Status;
 246     PPNP_POSTSTART_CONTEXT Ctx = (PPNP_POSTSTART_CONTEXT)Context;
 247
 248     /* call driver pnp post routine */
 249     Status = Ctx->DeviceHeader->KsDevice.Descriptor->Dispatch->PostStart(&Ctx->DeviceHeader->KsDevice);
 250
 251     if (!NT_SUCCESS(Status))
 252     {
 253         /* set state to disabled */
 254         Ctx->DeviceHeader->TargetState  = KSTARGET_STATE_DISABLED;
 255     }
 256     else
 257     {
 258         /* set state to enabled */
 259         Ctx->DeviceHeader->TargetState = KSTARGET_STATE_ENABLED;
 260         Status = KspSetFilterFactoriesState(Ctx->DeviceHeader, TRUE);
 261     }
 262
 263     /* free work item */
 264     IoFreeWorkItem(Ctx->WorkItem);
 265
 266     /* free work context */
 267     FreeItem(Ctx);
 268
 269     DPRINT("IKsDevice_PnpPostStart: PostStart Routine returned %x\n", Status);
 270 }
 271
 272 NTSTATUS
 273 NTAPI
 274 IKsDevice_PnpStartDevice(
 275     IN PDEVICE_OBJECT  DeviceObject,
 276     IN PIRP Irp)
 277 {
 278     PIO_STACK_LOCATION IoStack;
 279     PDEVICE_EXTENSION DeviceExtension;
 280     PKSIDEVICE_HEADER DeviceHeader;
 281     PPNP_POSTSTART_CONTEXT Ctx = NULL;
 282     NTSTATUS Status;
 283     PCM_RESOURCE_LIST TranslatedResourceList;
 284     PCM_RESOURCE_LIST UntranslatedResourceList;
 285     PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor, UnPartialDescriptor;
 286     ULONG Index;
 287
 288     /* get current stack location */
 289     IoStack = IoGetCurrentIrpStackLocation(Irp);
 290     /* get device extension */
 291     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 292     /* get device header */
 293     DeviceHeader = DeviceExtension->DeviceHeader;
 294
 295     DPRINT("IKsDevice_PnpStartDevice DeviceHeader %p\n", DeviceHeader);
 296
 297     /* first forward irp to lower device object */
 298     Status = KspForwardIrpSynchronous(DeviceObject, Irp);
 299
 300     /* check for success */
 301     if (!NT_SUCCESS(Status))
 302     {
 303         DPRINT1("NextDevice object failed to start with %x\n", Status);
 304         Irp->IoStatus.Status = Status;
 305         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 306         return Status;
 307     }
 308
 309     TranslatedResourceList = IoStack->Parameters.StartDevice.AllocatedResourcesTranslated;
 310     UntranslatedResourceList = IoStack->Parameters.StartDevice.AllocatedResources;
 311
 312     DPRINT("ResourceDescriptorCount %lu\n", TranslatedResourceList->List[0].PartialResourceList.Count);
 313     for (Index = 0; Index < TranslatedResourceList->List[0].PartialResourceList.Count; Index ++ )
 314     {
 315         PartialDescriptor = &TranslatedResourceList->List[0].PartialResourceList.PartialDescriptors[Index];
 316         UnPartialDescriptor = &UntranslatedResourceList->List[0].PartialResourceList.PartialDescriptors[Index];
 317         DPRINT("Descriptor Type %u\n", PartialDescriptor->Type);
 318
 319         if (PartialDescriptor->Type == CmResourceTypeInterrupt)
 320         {
 321             DPRINT("CmResourceTypeInterrupt Index %u TRANS   Interrupt Number Affinity %x Level %u Vector %u Flags %x Share %x\n", Index, PartialDescriptor->u.Interrupt.Affinity, PartialDescriptor->u.Interrupt.Level, PartialDescriptor->u.Interrupt.Vector, PartialDescriptor->Flags, PartialDescriptor->ShareDisposition);
 322             DPRINT("CmResourceTypeInterrupt Index %u UNTRANS Interrupt Number Affinity %x Level %u Vector %u Flags %x Share %x\\n", Index, UnPartialDescriptor->u.Interrupt.Affinity, UnPartialDescriptor->u.Interrupt.Level, UnPartialDescriptor->u.Interrupt.Vector, UnPartialDescriptor->Flags, UnPartialDescriptor->ShareDisposition);
 323
 324         }
 325         else if (PartialDescriptor->Type == CmResourceTypePort)
 326         {
 327             DPRINT("CmResourceTypePort Index %u TRANS    Port Length %u Start %u %u Flags %x Share %x\n", Index, PartialDescriptor->u.Port.Length, PartialDescriptor->u.Port.Start.HighPart, PartialDescriptor->u.Port.Start.LowPart, PartialDescriptor->Flags, PartialDescriptor->ShareDisposition);
 328             DPRINT("CmResourceTypePort Index %u UNTRANS  Port Length %u Start %u %u Flags %x Share %x\n", Index, UnPartialDescriptor->u.Port.Length, UnPartialDescriptor->u.Port.Start.HighPart, UnPartialDescriptor->u.Port.Start.LowPart, UnPartialDescriptor->Flags, UnPartialDescriptor->ShareDisposition);
 329         }
 330         else if (PartialDescriptor->Type == CmResourceTypeMemory)
 331         {
 332             DPRINT("CmResourceTypeMemory Index %u TRANS  Start %x Length %u Flags %x Share %x\n", Index, PartialDescriptor->u.Memory.Start.LowPart, PartialDescriptor->u.Memory.Length, PartialDescriptor->Flags, PartialDescriptor->ShareDisposition);
 333             DPRINT("CmResourceTypeMemory Index %u TRANS  Start %x Length %u Flags %x Share %x\n", Index, UnPartialDescriptor->u.Memory.Start.LowPart, UnPartialDescriptor->u.Memory.Length, UnPartialDescriptor->Flags, UnPartialDescriptor->ShareDisposition);
 334         }
 335     }
 336
 337     ASSERT(DeviceHeader->KsDevice.Descriptor);
 338     ASSERT(DeviceHeader->KsDevice.Descriptor->Dispatch);
 339     ASSERT(DeviceHeader->KsDevice.Descriptor->Dispatch->Start);
 340
 341
 342     /* do we have a device descriptor */
 343     if (DeviceHeader->KsDevice.Descriptor)
 344     {
 345         /* does the device want pnp notifications */
 346         if (DeviceHeader->KsDevice.Descriptor->Dispatch)
 347         {
 348             /* does the driver care about IRP_MN_START_DEVICE */
 349             if (DeviceHeader->KsDevice.Descriptor->Dispatch->Start)
 350             {
 351                 /* call driver start device routine */
 352                 Status = DeviceHeader->KsDevice.Descriptor->Dispatch->Start(&DeviceHeader->KsDevice, Irp,
 353                                                                    TranslatedResourceList,
 354                                                                    UntranslatedResourceList);
 355
 356
 357                 DPRINT("IKsDevice_PnpStartDevice Start %p, Context %p\n", DeviceHeader->KsDevice.Descriptor->Dispatch->Start, DeviceHeader->KsDevice.Context);
 358                 ASSERT(Status != STATUS_PENDING);
 359
 360                 if (!NT_SUCCESS(Status))
 361                 {
 362                     DPRINT1("Driver: failed to start %x\n", Status);
 363                     Irp->IoStatus.Status = Status;
 364                     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 365                     return Status;
 366                 }
 367
 368                 /* set state to run */
 369                 DeviceHeader->KsDevice.Started = TRUE;
 370
 371             }
 372
 373             /* does the driver need post start routine */
 374             if (DeviceHeader->KsDevice.Descriptor->Dispatch->PostStart)
 375             {
 376                 /* allocate pnp post workitem context */
 377                 Ctx = (PPNP_POSTSTART_CONTEXT)AllocateItem(NonPagedPool, sizeof(PNP_POSTSTART_CONTEXT));
 378                 if (!Ctx)
 379                 {
 380                     /* no memory */
 381                     Status = STATUS_INSUFFICIENT_RESOURCES;
 382                 }
 383                 else
 384                 {
 385                     /* allocate a work item */
 386                     Ctx->WorkItem = IoAllocateWorkItem(DeviceObject);
 387
 388                     if (!Ctx->WorkItem)
 389                     {
 390                          /* no memory */
 391                         FreeItem(Ctx);
 392                         Ctx = NULL;
 393                         Status = STATUS_INSUFFICIENT_RESOURCES;
 394                     }
 395                     else
 396                     {
 397                         /* store device header for post-start pnp processing */
 398                         Ctx->DeviceHeader = DeviceHeader;
 399                     }
 400                 }
 401             }
 402             else
 403             {
 404                 /* set state to enabled, IRP_MJ_CREATE request may now succeed */
 405                 DeviceHeader->TargetState = KSTARGET_STATE_ENABLED;
 406                 Status = KspSetFilterFactoriesState(DeviceHeader, TRUE);
 407             }
 408         }
 409     }
 410
 411     /* store result */
 412     Irp->IoStatus.Status = Status;
 413     /* complete request */
 414     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 415
 416     if (Ctx)
 417     {
 418         /* queue a work item for driver post start routine */
 419         IoQueueWorkItem(Ctx->WorkItem, IKsDevice_PnpPostStart, DelayedWorkQueue, (PVOID)Ctx);
 420     }
 421
 422     /* return result */
 423     DPRINT1("IKsDevice_PnpStartDevice Status %x PostStartRoutine %p\n", Status, Ctx);
 424     return Status;
 425 }
 426
 427 NTSTATUS
 428 NTAPI
 429 IKsDevice_Pnp(
 430     IN PDEVICE_OBJECT  DeviceObject,
 431     IN PIRP Irp)
 432 {
 433     PIO_STACK_LOCATION IoStack;
 434     PDEVICE_EXTENSION DeviceExtension;
 435     PKSIDEVICE_HEADER DeviceHeader;
 436     PKSDEVICE_DISPATCH Dispatch = NULL;
 437     NTSTATUS Status;
 438
 439     /* get current stack location */
 440     IoStack = IoGetCurrentIrpStackLocation(Irp);
 441
 442     /* get device extension */
 443     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 444     /* get device header */
 445     DeviceHeader = DeviceExtension->DeviceHeader;
 446
 447     /* do we have a device descriptor */
 448     if (DeviceHeader->KsDevice.Descriptor && DeviceHeader->KsDevice.Descriptor->Dispatch)
 449     {
 450         /* does the device want pnp notifications */
 451         Dispatch = (PKSDEVICE_DISPATCH)DeviceHeader->KsDevice.Descriptor->Dispatch;
 452     }
 453
 454     switch (IoStack->MinorFunction)
 455     {
 456         case IRP_MN_START_DEVICE:
 457         {
 458             return IKsDevice_PnpStartDevice(DeviceObject, Irp);
 459         }
 460
 461         case IRP_MN_QUERY_STOP_DEVICE:
 462         {
 463             Status = STATUS_SUCCESS;
 464             /* check for pnp notification support */
 465             if (Dispatch)
 466             {
 467                 /* check for query stop support */
 468                 if (Dispatch->QueryStop)
 469                 {
 470                     /* call driver's query stop */
 471                     Status = Dispatch->QueryStop(&DeviceHeader->KsDevice, Irp);
 472                     ASSERT(Status != STATUS_PENDING);
 473                 }
 474             }
 475
 476             if (!NT_SUCCESS(Status))
 477             {
 478                 DPRINT1("Driver: query stop failed %x\n", Status);
 479                 Irp->IoStatus.Status = Status;
 480                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
 481                 return Status;
 482             }
 483
 484             /* pass the irp down the driver stack */
 485             Status = KspForwardIrpSynchronous(DeviceObject, Irp);
 486
 487             DPRINT("Next Device: Status %x\n", Status);
 488
 489             Irp->IoStatus.Status = Status;
 490             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 491             return Status;
 492         }
 493
 494         case IRP_MN_REMOVE_DEVICE:
 495         {
 496             /* Clean up */
 497             if (Dispatch)
 498             {
 499                 /* check for remove support */
 500                 if (Dispatch->Remove)
 501                 {
 502                     /* call driver's stop routine */
 503                     Dispatch->Remove(&DeviceHeader->KsDevice, Irp);
 504                 }
 505             }
 506
 507             /* pass the irp down the driver stack */
 508             Status = KspForwardIrpSynchronous(DeviceObject, Irp);
 509
 510             DPRINT("Next Device: Status %x\n", Status);
 511
 512             /* FIXME delete device resources */
 513
 514
 515             Irp->IoStatus.Status = Status;
 516             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 517             return Status;
 518         }
 519         case IRP_MN_QUERY_INTERFACE:
 520         {
 521             Status = STATUS_UNSUCCESSFUL;
 522             /* check for pnp notification support */
 523             if (Dispatch)
 524             {
 525                 /* check for query interface support */
 526                 if (Dispatch->QueryInterface)
 527                 {
 528                     /* call driver's query interface */
 529                     Status = Dispatch->QueryInterface(&DeviceHeader->KsDevice, Irp);
 530                     ASSERT(Status != STATUS_PENDING);
 531                 }
 532             }
 533
 534             if (NT_SUCCESS(Status))
 535             {
 536                 /* driver supports a private interface */
 537                 DPRINT1("IRP_MN_QUERY_INTERFACE Device supports interface\n");
 538                 Irp->IoStatus.Status = Status;
 539                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
 540                 return Status;
 541             }
 542
 543             /* pass the irp down the driver stack */
 544             Status = KspForwardIrpSynchronous(DeviceObject, Irp);
 545
 546             DPRINT1("IRP_MN_QUERY_INTERFACE Next Device: Status %x\n", Status);
 547             Irp->IoStatus.Status = Status;
 548             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 549             return Status;
 550         }
 551         case IRP_MN_QUERY_DEVICE_RELATIONS:
 552         {
 553             /* pass the irp down the driver stack */
 554             Status = KspForwardIrpSynchronous(DeviceObject, Irp);
 555
 556             DPRINT("IRP_MN_QUERY_DEVICE_RELATIONS Next Device: Status %x\n", Status);
 557
 558             //Irp->IoStatus.Status = Status;
 559             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 560             return Status;
 561         }
 562         case IRP_MN_FILTER_RESOURCE_REQUIREMENTS:
 563         {
 564             /* pass the irp down the driver stack */
 565             //Status = KspForwardIrpSynchronous(DeviceObject, Irp);
 566             Status = Irp->IoStatus.Status;
 567             DPRINT("IRP_MN_FILTER_RESOURCE_REQUIREMENTS Next Device: Status %x\n", Status);
 568
 569             //Irp->IoStatus.Status = Status;
 570             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 571             return Status;
 572         }
 573        case IRP_MN_QUERY_RESOURCE_REQUIREMENTS:
 574        {
 575             /* pass the irp down the driver stack */
 576             Status = KspForwardIrpSynchronous(DeviceObject, Irp);
 577
 578             DPRINT("IRP_MN_QUERY_RESOURCE_REQUIREMENTS Next Device: Status %x\n", Status);
 579
 580             Irp->IoStatus.Status = Status;
 581             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 582             return Status;
 583        }
 584        default:
 585           DPRINT1("unhandled function %u\n", IoStack->MinorFunction);
 586           /* pass the irp down the driver stack */
 587           Status = KspForwardIrpSynchronous(DeviceObject, Irp);
 588
 589           Irp->IoStatus.Status = Status;
 590           IoCompleteRequest(Irp, IO_NO_INCREMENT);
 591           return Status;
 592     }
 593 }
 594
 595 NTSTATUS
 596 NTAPI
 597 IKsDevice_Power(
 598     IN PDEVICE_OBJECT  DeviceObject,
 599     IN PIRP Irp)
 600 {
 601     UNIMPLEMENTED
 602
 603     /* TODO */
 604
 605     Irp->IoStatus.Status = STATUS_SUCCESS;
 606     Irp->IoStatus.Information = 0;
 607     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 608
 609     return STATUS_SUCCESS;
 610 }
 611
 612 NTSTATUS
 613 NTAPI
 614 IKsDevice_Create(
 615     IN PDEVICE_OBJECT  DeviceObject,
 616     IN PIRP Irp)
 617 {
 618     PCREATE_ITEM_ENTRY CreateItemEntry;
 619     PIO_STACK_LOCATION IoStack;
 620     PDEVICE_EXTENSION DeviceExtension;
 621     PKSIDEVICE_HEADER DeviceHeader;
 622     PKSIOBJECT_HEADER ObjectHeader;
 623     NTSTATUS Status;
 624
 625     DPRINT("IKsDevice_Create\n");
 626     /* get current stack location */
 627     IoStack = IoGetCurrentIrpStackLocation(Irp);
 628     /* get device extension */
 629     DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
 630     /* get device header */
 631     DeviceHeader = DeviceExtension->DeviceHeader;
 632
 633     /* acquire list lock */
 634     IKsDevice_fnAcquireDevice((IKsDevice*)&DeviceHeader->BasicHeader.OuterUnknown);
 635
 636     /* sanity check */
 637     ASSERT(IoStack->FileObject);
 638
 639     /* check if the request is relative */
 640     if (IoStack->FileObject->RelatedFileObject != NULL)
 641     {
 642         /* request is to instantiate a pin / node / clock / allocator */
 643         ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->RelatedFileObject->FsContext2;
 644
 645         /* sanity check */
 646         ASSERT(ObjectHeader);
 647
 648         /* find a matching a create item */
 649         Status = FindMatchingCreateItem(&ObjectHeader->ItemList, IoStack->FileObject->FileName.Length, IoStack->FileObject->FileName.Buffer, &CreateItemEntry);
 650     }
 651     else
 652     {
 653         /* request to create a filter */
 654         Status = FindMatchingCreateItem(&DeviceHeader->ItemList, IoStack->FileObject->FileName.Length, IoStack->FileObject->FileName.Buffer, &CreateItemEntry);
 655     }
 656
 657     if (NT_SUCCESS(Status))
 658     {
 659         /* set object create item */
 660         KSCREATE_ITEM_IRP_STORAGE(Irp) = CreateItemEntry->CreateItem;
 661
 662         /* call create function */
 663         Status = CreateItemEntry->CreateItem->Create(DeviceObject, Irp);
 664
 665         if (NT_SUCCESS(Status))
 666         {
 667             /* increment create item reference count */
 668             InterlockedIncrement(&CreateItemEntry->ReferenceCount);
 669         }
 670     }
 671
 672     /* acquire list lock */
 673     IKsDevice_fnReleaseDevice((IKsDevice*)&DeviceHeader->BasicHeader.OuterUnknown);
 674
 675     if (Status != STATUS_PENDING)
 676     {
 677         Irp->IoStatus.Information = 0;
 678         /* set return status */
 679         Irp->IoStatus.Status = Status;
 680         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 681     }
 682
 683     return Status;
 684
 685
 686 }
 687
 688 /*
 689     @implemented
 690 */
 691 KSDDKAPI
 692 NTSTATUS
 693 NTAPI
 694 KsInitializeDevice(
 695     IN PDEVICE_OBJECT FunctionalDeviceObject,
 696     IN PDEVICE_OBJECT PhysicalDeviceObject,
 697     IN PDEVICE_OBJECT NextDeviceObject,
 698     IN const KSDEVICE_DESCRIPTOR* Descriptor OPTIONAL)
 699 {
 700     PDEVICE_EXTENSION DeviceExtension;
 701     PKSIDEVICE_HEADER Header;
 702     ULONG Index;
 703     PKSIOBJECT_BAG Bag;
 704     NTSTATUS Status = STATUS_SUCCESS;
 705
 706     DPRINT("KsInitializeDevice Descriptor %p\n", Descriptor);
 707
 708     /* get device extension */
 709     DeviceExtension = (PDEVICE_EXTENSION)FunctionalDeviceObject->DeviceExtension;
 710
 711     /* first allocate device header */
 712     Status = KsAllocateDeviceHeader((KSDEVICE_HEADER*)&DeviceExtension->DeviceHeader, 0, NULL);
 713
 714     /* point to allocated header */
 715     Header = DeviceExtension->DeviceHeader;
 716
 717     DPRINT("DeviceHeader %p\n", DeviceExtension->DeviceHeader);
 718
 719     if (Descriptor && Descriptor->Dispatch)
 720     {
 721         DPRINT("Descriptor Add %p\n", Descriptor->Dispatch->Add);
 722         DPRINT("Descriptor Start %p\n", Descriptor->Dispatch->Start);
 723         DPRINT("Descriptor PostStart %p\n", Descriptor->Dispatch->PostStart);
 724         DPRINT("Descriptor QueryStop %p\n", Descriptor->Dispatch->QueryStop);
 725         DPRINT("Descriptor CancelStop %p\n", Descriptor->Dispatch->CancelStop);
 726         DPRINT("Descriptor Stop %p\n", Descriptor->Dispatch->Stop);
 727         DPRINT("Descriptor QueryRemove %p\n", Descriptor->Dispatch->QueryRemove);
 728         DPRINT("Descriptor CancelRemove %p\n", Descriptor->Dispatch->CancelRemove);
 729         DPRINT("Descriptor Remove %p\n", Descriptor->Dispatch->Remove);
 730         DPRINT("Descriptor QueryCapabilities %p\n", Descriptor->Dispatch->QueryCapabilities);
 731         DPRINT("Descriptor SurpriseRemoval %p\n", Descriptor->Dispatch->SurpriseRemoval);
 732         DPRINT("Descriptor QueryPower %p\n", Descriptor->Dispatch->QueryPower);
 733         DPRINT("Descriptor SetPower %p\n", Descriptor->Dispatch->SetPower);
 734         DPRINT("Descriptor QueryInterface %p\n", Descriptor->Dispatch->QueryInterface);
 735     }
 736
 737     /* check for success */
 738     if (!NT_SUCCESS(Status))
 739     {
 740         DPRINT1("KsInitializeDevice Failed to allocate device header with %x\n", Status);
 741         return Status;
 742     }
 743
 744     /* initialize IKsDevice interface */
 745     Header->BasicHeader.OuterUnknown = (PUNKNOWN)&vt_IKsDevice;
 746     Header->ref = 1;
 747
 748     /* allocate object bag */
 749     Header->KsDevice.Bag = AllocateItem(NonPagedPool, sizeof(KSIOBJECT_BAG));
 750     if (!Header->KsDevice.Bag)
 751     {
 752         /* no memory */
 753         KsFreeDeviceHeader((KSDEVICE_HEADER*)&DeviceExtension->DeviceHeader);
 754         return STATUS_INSUFFICIENT_RESOURCES;
 755     }
 756
 757     /* initialize object bag */
 758     KeInitializeMutex(&Header->BagMutex, 0);
 759     KeInitializeMutex(&Header->DeviceMutex, 0);
 760
 761     Bag = (PKSIOBJECT_BAG)Header->KsDevice.Bag;
 762     Bag->BagMutex = &Header->BagMutex;
 763     InitializeListHead(&Header->ObjectBags);
 764     InitializeListHead(&Bag->ObjectList);
 765     Bag->DeviceHeader = (PVOID)Header;
 766
 767     /* insert bag into device list */
 768     InsertTailList(&Header->ObjectBags, &Bag->Entry);
 769
 770     /* initialize device header */
 771     Header->KsDevice.FunctionalDeviceObject = FunctionalDeviceObject;
 772     Header->KsDevice.PhysicalDeviceObject = PhysicalDeviceObject;
 773     Header->KsDevice.NextDeviceObject = NextDeviceObject;
 774     Header->KsDevice.Descriptor = Descriptor;
 775     Header->KsDevice.SystemPowerState = PowerSystemWorking;
 776     Header->KsDevice.DevicePowerState = PowerDeviceD0;
 777     Header->KsDevice.Started = FALSE;
 778     Header->KsDevice.Context = NULL;
 779     KsSetDevicePnpAndBaseObject(Header, PhysicalDeviceObject, NextDeviceObject);
 780
 781
 782
 783     if (Descriptor)
 784     {
 785         /* create a filter factory for each filter descriptor */
 786         DPRINT("KsInitializeDevice FilterDescriptorCount %lu\n", Descriptor->FilterDescriptorsCount);
 787         for(Index = 0; Index < Descriptor->FilterDescriptorsCount; Index++)
 788         {
 789             Status = KspCreateFilterFactory(FunctionalDeviceObject, Descriptor->FilterDescriptors[Index], NULL, NULL, 0, NULL, NULL, NULL);
 790
 791             DPRINT("KsInitializeDevice Index %lu KspCreateFilterFactory Status %lx\n", Index, Status);
 792             /* check for success */
 793             if (!NT_SUCCESS(Status))
 794             {
 795                 DPRINT1("KspCreateFilterFactory failed with %x\n", Status);
 796                 /* FIXME memory leak */
 797                 return Status;
 798             }
 799         }
 800
 801         /* does the driver pnp notification */
 802         if (Descriptor->Dispatch)
 803         {
 804             /* does the driver care about the add device */
 805             Status = Descriptor->Dispatch->Add(&Header->KsDevice);
 806
 807             DPRINT("Driver: AddHandler Status %x\n", Status);
 808             Header->KsDevice.Descriptor = Descriptor;
 809         }
 810     }
 811
 812
 813    return Status;
 814 }
 815
 816 /*
 817     @implemented
 818 */
 819 KSDDKAPI
 820 NTSTATUS
 821 NTAPI
 822 KsReferenceSoftwareBusObject(
 823     IN KSDEVICE_HEADER  Header)
 824 {
 825      IKsDevice * Device;
 826      PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)Header;
 827
 828      /* get device interface */
 829      Device = (IKsDevice*)DeviceHeader->BasicHeader.OuterUnknown;
 830
 831      if (Device)
 832      {
 833          /* reference device interface */
 834          Device->lpVtbl->AddRef(Device);
 835      }
 836
 837     return STATUS_SUCCESS;
 838 }
 839
 840 /*
 841     @implemented
 842 */
 843 KSDDKAPI
 844 NTSTATUS
 845 NTAPI
 846 KsReferenceBusObject(
 847     IN  KSDEVICE_HEADER Header)
 848 {
 849      IKsDevice * Device;
 850      PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)Header;
 851
 852      /* get device interface */
 853      Device = (IKsDevice*)DeviceHeader->BasicHeader.OuterUnknown;
 854
 855      if (Device)
 856      {
 857          /* reference device interface */
 858          Device->lpVtbl->AddRef(Device);
 859      }
 860
 861     return STATUS_SUCCESS;
 862
 863 }
 864
 865 /*
 866     @implemented
 867 */
 868 KSDDKAPI
 869 VOID
 870 NTAPI
 871 KsDereferenceBusObject(
 872     IN  KSDEVICE_HEADER Header)
 873 {
 874      IKsDevice * Device;
 875      PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)Header;
 876
 877      /* get device interface */
 878      Device = (IKsDevice*)DeviceHeader->BasicHeader.OuterUnknown;
 879
 880      if (Device)
 881      {
 882          /* release device interface */
 883          Device->lpVtbl->Release(Device);
 884      }
 885 }
 886
 887 /*
 888     @implemented
 889 */
 890 KSDDKAPI
 891 VOID
 892 NTAPI
 893 KsDereferenceSoftwareBusObject(
 894     IN KSDEVICE_HEADER  Header)
 895 {
 896      IKsDevice * Device;
 897      PKSIDEVICE_HEADER DeviceHeader = (PKSIDEVICE_HEADER)Header;
 898
 899      DPRINT1("KsDereferenceSoftwareBusObject DeviceHeader %p\n", Header);
 900
 901      /* get device interface */
 902      Device = (IKsDevice*)DeviceHeader->BasicHeader.OuterUnknown;
 903
 904      if (Device)
 905      {
 906          /* release device interface */
 907          Device->lpVtbl->Release(Device);
 908      }
 909 }