drivers/wdm/audio/backpln/portcls/undoc.cpp

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel Streaming
   4  * FILE:            drivers/wdm/audio/backpln/portcls/api.cpp
   5  * PURPOSE:         Port api functions
   6  * PROGRAMMER:      Johannes Anderwald
   7  */
   8
   9 #include "private.hpp"
  10
  11 NTSTATUS
  12 NTAPI
  13 KsoDispatchCreateWithGenericFactory(
  14     LONG Unknown,
  15     PIRP Irp)
  16 {
  17     UNIMPLEMENTED;
  18     return STATUS_NOT_IMPLEMENTED;
  19 }
  20
  21 IIrpTarget *
  22 NTAPI
  23 KsoGetIrpTargetFromFileObject(
  24     PFILE_OBJECT FileObject)
  25 {
  26     PC_ASSERT(FileObject);
  27
  28     // IrpTarget is stored in FsContext
  29     return (IIrpTarget*)FileObject->FsContext;
  30 }
  31
  32 IIrpTarget *
  33 NTAPI
  34 KsoGetIrpTargetFromIrp(
  35     PIRP Irp)
  36 {
  37     PIO_STACK_LOCATION IoStack;
  38
  39     // get current irp stack location
  40     IoStack = IoGetCurrentIrpStackLocation(Irp);
  41
  42     // IIrpTarget is stored in Context member
  43     return (IIrpTarget*)IoStack->FileObject->FsContext;
  44 }
  45
  46 NTSTATUS
  47 NTAPI
  48 PcHandleEnableEventWithTable(
  49     IN PIRP Irp,
  50     IN PSUBDEVICE_DESCRIPTOR Descriptor)
  51 {
  52     // store descriptor
  53     KSEVENT_ITEM_IRP_STORAGE(Irp) = (PKSEVENT_ITEM)Descriptor;
  54
  55     // FIXME seh probing
  56     return KsEnableEvent(Irp, Descriptor->EventSetCount, Descriptor->EventSet, NULL, KSEVENTS_NONE, NULL);
  57 }
  58
  59 NTSTATUS
  60 NTAPI
  61 PcHandleDisableEventWithTable(
  62     IN PIRP Irp,
  63     IN PSUBDEVICE_DESCRIPTOR Descriptor)
  64 {
  65     // store descriptor
  66     KSEVENT_ITEM_IRP_STORAGE(Irp) = (PKSEVENT_ITEM)Descriptor;
  67
  68     // FIXME seh probing
  69
  70     return KsDisableEvent(Irp, Descriptor->EventList, KSEVENTS_SPINLOCK, (PVOID)Descriptor->EventListLock);
  71 }
  72
  73 NTSTATUS
  74 NTAPI
  75 PcHandlePropertyWithTable(
  76     IN PIRP Irp,
  77     IN ULONG PropertySetCount,
  78     IN PKSPROPERTY_SET PropertySet,
  79     IN PSUBDEVICE_DESCRIPTOR SubDeviceDescriptor)
  80 {
  81     PIO_STACK_LOCATION IoStack;
  82
  83     // get current irp stack location
  84     IoStack = IoGetCurrentIrpStackLocation(Irp);
  85
  86     if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(KSPROPERTY))
  87     {
  88         // certainly an invalid request
  89         return STATUS_INVALID_PARAMETER;
  90     }
  91
  92     // store device descriptor
  93     KSPROPERTY_ITEM_IRP_STORAGE(Irp) = (PKSPROPERTY_ITEM)SubDeviceDescriptor;
  94
  95     // then try KsPropertyHandler
  96     return KsPropertyHandler(Irp, PropertySetCount, PropertySet);
  97 }
  98
  99 VOID
 100 NTAPI
 101 PcAcquireFormatResources(
 102     LONG Unknown,
 103     LONG Unknown2,
 104     LONG Unknown3,
 105     LONG Unknown4)
 106 {
 107     UNIMPLEMENTED;
 108 }
 109
 110 NTSTATUS
 111 PcAddToEventTable(
 112     PVOID Ptr,
 113     LONG Unknown2,
 114     ULONG Length,
 115     LONG Unknown3,
 116     LONG Unknown4,
 117     LONG Unknown5,
 118     LONG Unknown6,
 119     LONG Unknown7)
 120 {
 121     UNIMPLEMENTED;
 122     return STATUS_NOT_IMPLEMENTED;
 123 }
 124
 125 NTSTATUS
 126 NTAPI
 127 PropertyItemDispatch(
 128     IN PIRP Irp,
 129     IN PKSIDENTIFIER  Request,
 130     IN OUT PVOID  Data)
 131 {
 132     PPCPROPERTY_REQUEST PropertyRequest;
 133     PSUBDEVICE_DESCRIPTOR Descriptor;
 134     PKSPROPERTY Property;
 135     PPCNODE_DESCRIPTOR NodeDescriptor;
 136     PKSNODEPROPERTY NodeProperty;
 137     PKSPROPERTY_SET PropertySet;
 138     PPCPROPERTY_ITEM PropertyItem;
 139     PPCAUTOMATION_TABLE NodeAutomation;
 140     PIO_STACK_LOCATION IoStack;
 141     ULONG InstanceSize, ValueSize, Index;
 142     PVOID Instance;
 143     NTSTATUS Status;
 144
 145     // allocate a property request
 146     PropertyRequest = (PPCPROPERTY_REQUEST)AllocateItem(NonPagedPool, sizeof(PCPROPERTY_REQUEST), TAG_PORTCLASS);
 147     if (!PropertyRequest)
 148         return STATUS_INSUFFICIENT_RESOURCES;
 149
 150     // grab device descriptor
 151     Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
 152
 153     // get current irp stack
 154     IoStack = IoGetCurrentIrpStackLocation(Irp);
 155
 156     // get input property request
 157     Property = (PKSPROPERTY)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
 158
 159     // get property set
 160     PropertySet = (PKSPROPERTY_SET)KSPROPERTY_SET_IRP_STORAGE(Irp);
 161
 162     // sanity check
 163     PC_ASSERT(Descriptor);
 164     PC_ASSERT(Descriptor->UnknownMiniport);
 165
 166     // get instance / value size
 167     InstanceSize = IoStack->Parameters.DeviceIoControl.InputBufferLength;
 168     Instance = Data;
 169     ValueSize = IoStack->Parameters.DeviceIoControl.OutputBufferLength;
 170
 171      // initialize property request
 172      PropertyRequest->MajorTarget = Descriptor->UnknownMiniport;
 173      PropertyRequest->MinorTarget = Descriptor->UnknownStream;
 174      PropertyRequest->Irp = Irp;
 175      PropertyRequest->Verb = Property->Flags;
 176
 177
 178     // check if this is filter / pin property request
 179     if (!(Property->Flags & KSPROPERTY_TYPE_TOPOLOGY))
 180     {
 181         // adjust input buffer size
 182         InstanceSize -= sizeof(KSPROPERTY);
 183         Instance = (PVOID)((ULONG_PTR)Instance + sizeof(KSPROPERTY));
 184
 185         // filter / pin property request dont use node field
 186         PropertyRequest->Node = MAXULONG;
 187     }
 188     else if (InstanceSize >= sizeof(KSNODEPROPERTY))
 189     {
 190         // request is for a node
 191         InstanceSize -= sizeof(KSNODEPROPERTY);
 192         Instance = (PVOID)((ULONG_PTR)Instance + sizeof(KSNODEPROPERTY));
 193
 194         // cast node property request
 195         NodeProperty = (PKSNODEPROPERTY)Request;
 196
 197         // store node id
 198         PropertyRequest->Node = NodeProperty->NodeId;
 199     }
 200     else
 201     {
 202         // invalid buffer size
 203         return STATUS_INVALID_BUFFER_SIZE;
 204     }
 205
 206     // store instance size
 207     PropertyRequest->InstanceSize = InstanceSize;
 208     PropertyRequest->Instance = (InstanceSize != 0 ? Instance : NULL);
 209
 210     // store value size
 211     PropertyRequest->ValueSize = ValueSize;
 212     PropertyRequest->Value = (ValueSize != 0 ? Irp->UserBuffer : NULL);
 213
 214     // now scan the property set for the attached property set item stored in Relations member
 215     if (PropertySet)
 216     {
 217         // sanity check
 218         PC_ASSERT(IsEqualGUIDAligned(Property->Set, *PropertySet->Set));
 219
 220         for(Index = 0; Index < PropertySet->PropertiesCount; Index++)
 221         {
 222             // check if they got the same property id
 223             if (PropertySet->PropertyItem[Index].PropertyId == Property->Id)
 224             {
 225                 // found item
 226                 PropertyRequest->PropertyItem = (const PCPROPERTY_ITEM*)PropertySet->PropertyItem[Index].Relations;
 227
 228                 // done
 229                 break;
 230             }
 231         }
 232     }
 233
 234     // check if there has been a property set item attached
 235     if (!PropertyRequest->PropertyItem)
 236     {
 237         // is topology node id valid
 238         if (PropertyRequest->Node < Descriptor->DeviceDescriptor->NodeCount)
 239         {
 240             // get node descriptor
 241             NodeDescriptor = (PPCNODE_DESCRIPTOR) ((ULONG_PTR)Descriptor->DeviceDescriptor->Nodes + PropertyRequest->Node * Descriptor->DeviceDescriptor->NodeSize);
 242
 243             // get node automation table
 244             NodeAutomation = (PPCAUTOMATION_TABLE)NodeDescriptor->AutomationTable;
 245
 246             // has it got a automation table
 247             if (NodeAutomation)
 248             {
 249                 // now scan the properties and check if it supports this request
 250                 PropertyItem = (PPCPROPERTY_ITEM)NodeAutomation->Properties;
 251                 for(Index = 0; Index < NodeAutomation->PropertyCount; Index++)
 252                 {
 253                     // are they same property
 254                     if (IsEqualGUIDAligned(*PropertyItem->Set, Property->Set))
 255                     {
 256                         if (PropertyItem->Id == Property->Id)
 257                         {
 258                             // found match
 259                             PropertyRequest->PropertyItem = PropertyItem;
 260
 261                             // done
 262                             break;
 263                         }
 264                     }
 265
 266                     // move to next property item
 267                     PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + NodeAutomation->PropertyItemSize);
 268                 }
 269             }
 270         }
 271     }
 272
 273     if (PropertyRequest->PropertyItem && PropertyRequest->PropertyItem->Handler)
 274     {
 275         // now call the handler
 276         UNICODE_STRING GuidBuffer;
 277         RtlStringFromGUID(Property->Set, &GuidBuffer);
 278         DPRINT1("Calling Node %lu MajorTarget %p MinorTarget %p PropertySet %S PropertyId %lu PropertyFlags %lx InstanceSize %lu ValueSize %lu Handler %p PropertyRequest %p\n",
 279                 PropertyRequest->Node, PropertyRequest->MajorTarget, PropertyRequest->MinorTarget, GuidBuffer.Buffer, Property->Id, Property->Flags, PropertyRequest->InstanceSize, PropertyRequest->ValueSize,
 280                 PropertyRequest->PropertyItem->Handler, PropertyRequest);
 281         Status = PropertyRequest->PropertyItem->Handler(PropertyRequest);
 282
 283          Irp->IoStatus.Information = PropertyRequest->ValueSize;
 284
 285         if (Status != STATUS_PENDING)
 286         {
 287             // free property request
 288             FreeItem(PropertyRequest, TAG_PORTCLASS);
 289         }
 290     }
 291     else
 292     {
 293         FreeItem(PropertyRequest, TAG_PORTCLASS);
 294         Status = STATUS_NOT_FOUND;
 295     }
 296
 297     /* done */
 298     return Status;
 299 }
 300
 301 NTSTATUS
 302 PcAddToPropertyTable(
 303     IN PSUBDEVICE_DESCRIPTOR SubDeviceDescriptor,
 304     IN PPCPROPERTY_ITEM PropertyItem,
 305     IN ULONG bNode)
 306 {
 307     ULONG bFound = FALSE;
 308     ULONG Index, PropertySetIndex, PropertySetItemIndex;
 309     PKSPROPERTY_SET NewPropertySet;
 310     PKSPROPERTY_ITEM FilterPropertyItem, NewFilterPropertyItem;
 311     LPGUID Guid;
 312     //UNICODE_STRING GuidBuffer;
 313
 314 ASSERT(PropertyItem->Set);
 315         //      RtlStringFromGUID(*PropertyItem->Set, &GuidBuffer);
 316    // DPRINT1("PcAddToPropertyTable Adding Item Set %S Id %lu Flags %lx\n", GuidBuffer.Buffer, PropertyItem->Id, PropertyItem->Flags);
 317
 318
 319
 320     //DPRINT1("FilterPropertySetCount %lu\n", SubDeviceDescriptor->FilterPropertySetCount);
 321     // first step check if the property set is present already
 322     for(Index = 0; Index < SubDeviceDescriptor->FilterPropertySetCount; Index++)
 323     {
 324
 325                 //RtlStringFromGUID(*SubDeviceDescriptor->FilterPropertySet[Index].Set, &GuidBuffer);
 326         //DPRINT1("FilterProperty Set %S PropertyCount %lu\n", GuidBuffer.Buffer, SubDeviceDescriptor->FilterPropertySet[Index].PropertiesCount);
 327         if (IsEqualGUIDAligned(*SubDeviceDescriptor->FilterPropertySet[Index].Set, *PropertyItem->Set))
 328         {
 329             // property set is already present
 330             bFound = TRUE;
 331             PropertySetIndex = Index;
 332
 333             // break out
 334             break;
 335         }
 336     }
 337
 338     // is the property set present
 339     if (!bFound)
 340     {
 341         // need to allocate a property set
 342         NewPropertySet = (PKSPROPERTY_SET)AllocateItem(NonPagedPool, (SubDeviceDescriptor->FilterPropertySetCount + 1) * sizeof(KSPROPERTY_SET), TAG_PORTCLASS);
 343         if (!NewPropertySet)
 344         {
 345             // out of memory
 346             return STATUS_INSUFFICIENT_RESOURCES;
 347         }
 348
 349         // need to allocate property set guid
 350         Guid = (LPGUID)AllocateItem(NonPagedPool, sizeof(GUID), TAG_PORTCLASS);
 351         if (!Guid)
 352         {
 353             // out of memory
 354             FreeItem(NewPropertySet, TAG_PORTCLASS);
 355             return STATUS_INSUFFICIENT_RESOURCES;
 356         }
 357
 358         // are any existing property sets
 359         if (SubDeviceDescriptor->FilterPropertySetCount)
 360         {
 361             // copy property sets
 362             RtlMoveMemory(NewPropertySet, SubDeviceDescriptor->FilterPropertySet, SubDeviceDescriptor->FilterPropertySetCount * sizeof(KSPROPERTY_SET));
 363
 364             // release memory
 365             FreeItem(SubDeviceDescriptor->FilterPropertySet, TAG_PORTCLASS);
 366         }
 367
 368         // store new property set descriptors
 369         SubDeviceDescriptor->FilterPropertySet = NewPropertySet;
 370
 371         // store index
 372         PropertySetIndex = SubDeviceDescriptor->FilterPropertySetCount;
 373
 374         // increment property set count
 375         SubDeviceDescriptor->FilterPropertySetCount++;
 376
 377         // copy property guid
 378         RtlMoveMemory(Guid, PropertyItem->Set, sizeof(GUID));
 379
 380         // initialize property set
 381         SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].Set = Guid;
 382         SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount = 0;
 383     }
 384
 385     // as the property set has been indentified, now search for duplicate property set item entries
 386     FilterPropertyItem = (PKSPROPERTY_ITEM)SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem;
 387     bFound = FALSE;
 388
 389     for(Index = 0; Index < SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount; Index++)
 390     {
 391         // now search for an equal property set item
 392         if (FilterPropertyItem->PropertyId == PropertyItem->Id)
 393         {
 394             // found existing property set item
 395             bFound = TRUE;
 396             PropertySetItemIndex = Index;
 397             break;
 398         }
 399
 400         // move to next entry
 401         FilterPropertyItem++;
 402     }
 403
 404     if (!bFound)
 405     {
 406         // need to allocate memory for new property set item
 407         NewFilterPropertyItem = (PKSPROPERTY_ITEM)AllocateItem(NonPagedPool, (SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount + 1) * sizeof(KSPROPERTY_ITEM), TAG_PORTCLASS);
 408         if (!NewFilterPropertyItem)
 409         {
 410             // out of memory
 411             return STATUS_INSUFFICIENT_RESOURCES;
 412         }
 413
 414         // are any existing property set items
 415         if (SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount)
 416         {
 417             // copy property item sets
 418             RtlMoveMemory(NewFilterPropertyItem,
 419                           (PVOID)SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem,
 420                           SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount * sizeof(KSPROPERTY_ITEM));
 421
 422             // release old descriptors
 423             FreeItem((PVOID)SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem, TAG_PORTCLASS);
 424         }
 425
 426         // store new descriptor
 427         SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem = NewFilterPropertyItem;
 428
 429         // store index
 430         PropertySetItemIndex = SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount;
 431
 432         // increment property item set count
 433         SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertiesCount++;
 434
 435         // now initialize property item
 436         FilterPropertyItem = (PKSPROPERTY_ITEM)&SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem[PropertySetItemIndex];
 437         FilterPropertyItem->PropertyId = PropertyItem->Id;
 438         FilterPropertyItem->MinProperty = sizeof(KSPROPERTY);
 439         FilterPropertyItem->MinData = 0;
 440
 441         // are any set operations supported
 442         if (PropertyItem->Flags & PCPROPERTY_ITEM_FLAG_SET)
 443         {
 444             // setup handler
 445             FilterPropertyItem->SetPropertyHandler = PropertyItemDispatch;
 446         }
 447
 448         // are set operation supported
 449         if (PropertyItem->Flags & PCPROPERTY_ITEM_FLAG_GET)
 450         {
 451             // setup handler
 452             FilterPropertyItem->GetPropertyHandler = PropertyItemDispatch;
 453         }
 454
 455         // are get operations supported
 456         if (PropertyItem->Flags & PCPROPERTY_ITEM_FLAG_GET)
 457         {
 458             // setup handler
 459             FilterPropertyItem->GetPropertyHandler = PropertyItemDispatch;
 460         }
 461
 462         // are basic support operations supported
 463         if (PropertyItem->Flags & PCPROPERTY_ITEM_FLAG_BASICSUPPORT)
 464         {
 465             // setup handler
 466             FilterPropertyItem->SupportHandler = PropertyItemDispatch;
 467         }
 468
 469         if (!bNode)
 470         {
 471             // store property item in relations
 472             // only store property item of filter properties / pin properties
 473             // because filter & pin properties do not require a specific context
 474             // on the other hand node properties are specifically bound to a node
 475
 476             FilterPropertyItem->Relations = (const KSPROPERTY*)PropertyItem;
 477         }
 478     }
 479     else
 480     {
 481         // property set item handler already present
 482
 483         if (bNode)
 484         {
 485             // filter & pin properties should not be exposed on a node
 486             ASSERT(SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem[PropertySetItemIndex].Relations == NULL);
 487         }
 488         else
 489         {
 490             // node properties should not be exposed on a filter & pin
 491             ASSERT(SubDeviceDescriptor->FilterPropertySet[PropertySetIndex].PropertyItem[PropertySetItemIndex].Relations != NULL);
 492         }
 493     }
 494
 495     // done
 496     return STATUS_SUCCESS;
 497 }
 498
 499 NTSTATUS
 500 PcCaptureFormat(
 501     LONG Unknown,
 502     LONG Unknown2,
 503     LONG Unknown3,
 504     LONG Unknown4)
 505 {
 506     UNIMPLEMENTED;
 507     return STATUS_NOT_IMPLEMENTED;
 508 }
 509
 510 VOID
 511 DumpFilterDescriptor(
 512     IN PPCFILTER_DESCRIPTOR FilterDescription)
 513 {
 514     ULONG Index, SubIndex;
 515     PPCPROPERTY_ITEM PropertyItem;
 516     PPCEVENT_ITEM EventItem;
 517     PPCNODE_DESCRIPTOR NodeDescriptor;
 518     UNICODE_STRING GuidString;
 519
 520
 521
 522     DPRINT("======================\n");
 523     DPRINT("Descriptor Automation Table %p\n",FilterDescription->AutomationTable);
 524
 525     if (FilterDescription->AutomationTable)
 526     {
 527         DPRINT("FilterPropertiesCount %u FilterPropertySize %u Expected %u Events %u EventItemSize %u expected %u\n", FilterDescription->AutomationTable->PropertyCount, FilterDescription->AutomationTable->PropertyItemSize, sizeof(PCPROPERTY_ITEM),
 528                 FilterDescription->AutomationTable->EventCount, FilterDescription->AutomationTable->EventItemSize, sizeof(PCEVENT_ITEM));
 529         if (FilterDescription->AutomationTable->PropertyCount)
 530         {
 531             PropertyItem = (PPCPROPERTY_ITEM)FilterDescription->AutomationTable->Properties;
 532
 533             for(Index = 0; Index < FilterDescription->AutomationTable->PropertyCount; Index++)
 534             {
 535                 RtlStringFromGUID(*PropertyItem->Set, &GuidString);
 536                 DPRINT("Property Index %u GUID %S Id %u Flags %x\n", Index, GuidString.Buffer, PropertyItem->Id, PropertyItem->Flags);
 537
 538                 PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + FilterDescription->AutomationTable->PropertyItemSize);
 539             }
 540
 541             EventItem = (PPCEVENT_ITEM)FilterDescription->AutomationTable->Events;
 542             for(Index = 0; Index < FilterDescription->AutomationTable->EventCount; Index++)
 543             {
 544                 RtlStringFromGUID(*EventItem->Set, &GuidString);
 545                 DPRINT("EventIndex %u GUID %S Id %u Flags %x\n", Index, GuidString.Buffer, EventItem->Id, EventItem->Flags);
 546
 547                 EventItem = (PPCEVENT_ITEM)((ULONG_PTR)EventItem + FilterDescription->AutomationTable->EventItemSize);
 548             }
 549
 550         }
 551     }
 552
 553     if (FilterDescription->Nodes)
 554     {
 555         DPRINT("NodeCount %u NodeSize %u expected %u\n", FilterDescription->NodeCount, FilterDescription->NodeSize, sizeof(PCNODE_DESCRIPTOR));
 556         NodeDescriptor = (PPCNODE_DESCRIPTOR)FilterDescription->Nodes;
 557         for(Index = 0; Index < FilterDescription->NodeCount; Index++)
 558         {
 559             DPRINT("Index %u AutomationTable %p\n", Index, NodeDescriptor->AutomationTable);
 560
 561             if (NodeDescriptor->AutomationTable)
 562             {
 563                 DPRINT(" Index %u EventCount %u\n", Index, NodeDescriptor->AutomationTable->EventCount);
 564                 EventItem = (PPCEVENT_ITEM)NodeDescriptor->AutomationTable->Events;
 565                 for(SubIndex = 0; SubIndex < NodeDescriptor->AutomationTable->EventCount; SubIndex++)
 566                 {
 567                     RtlStringFromGUID(*EventItem->Set, &GuidString);
 568                     DPRINT("  EventIndex %u GUID %S Id %u Flags %x\n", SubIndex, GuidString.Buffer, EventItem->Id, EventItem->Flags);
 569
 570                     EventItem = (PPCEVENT_ITEM)((ULONG_PTR)EventItem + NodeDescriptor->AutomationTable->EventItemSize);
 571                 }
 572
 573                 DPRINT1(" Index %u PropertyCount %u\n", Index, NodeDescriptor->AutomationTable->PropertyCount);
 574                 PropertyItem = (PPCPROPERTY_ITEM)NodeDescriptor->AutomationTable->Properties;
 575                 for(SubIndex = 0; SubIndex < NodeDescriptor->AutomationTable->PropertyCount; SubIndex++)
 576                 {
 577                     RtlStringFromGUID(*PropertyItem->Set, &GuidString);
 578                     DPRINT1("  PropertyIndex %u GUID %S Id %u Flags %x\n", SubIndex, GuidString.Buffer, PropertyItem->Id, PropertyItem->Flags);
 579
 580                     PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + NodeDescriptor->AutomationTable->PropertyItemSize);
 581                 }
 582             }
 583
 584
 585             NodeDescriptor = (PPCNODE_DESCRIPTOR)((ULONG_PTR)NodeDescriptor + FilterDescription->NodeSize);
 586         }
 587
 588
 589
 590     }
 591
 592     DPRINT("ConnectionCount: %lu\n", FilterDescription->ConnectionCount);
 593
 594     if (FilterDescription->ConnectionCount)
 595     {
 596         DPRINT("------ Start of Nodes Connections ----------------\n");
 597         for(Index = 0; Index < FilterDescription->ConnectionCount; Index++)
 598         {
 599             DPRINT1("Index %ld FromPin %ld FromNode %ld -> ToPin %ld ToNode %ld\n", Index,
 600                                                                                     FilterDescription->Connections[Index].FromNodePin,
 601                                                                                     FilterDescription->Connections[Index].FromNode,
 602                                                                                     FilterDescription->Connections[Index].ToNodePin,
 603                                                                                     FilterDescription->Connections[Index].ToNode);
 604         }
 605         DPRINT("------ End of Nodes Connections----------------\n");
 606     }
 607
 608     DPRINT1("======================\n");
 609 }
 610
 611 NTSTATUS
 612 NTAPI
 613 PcCreateSubdeviceDescriptor(
 614     OUT SUBDEVICE_DESCRIPTOR ** OutSubdeviceDescriptor,
 615     IN ULONG InterfaceCount,
 616     IN GUID * InterfaceGuids,
 617     IN ULONG IdentifierCount,
 618     IN KSIDENTIFIER *Identifier,
 619     IN ULONG FilterPropertiesCount,
 620     IN KSPROPERTY_SET * FilterProperties,
 621     IN ULONG Unknown1,
 622     IN ULONG Unknown2,
 623     IN ULONG PinPropertiesCount,
 624     IN KSPROPERTY_SET * PinProperties,
 625     IN ULONG EventSetCount,
 626     IN KSEVENT_SET * EventSet,
 627     IN PPCFILTER_DESCRIPTOR FilterDescription)
 628 {
 629     SUBDEVICE_DESCRIPTOR * Descriptor;
 630     ULONG Index, SubIndex;
 631     NTSTATUS Status = STATUS_INSUFFICIENT_RESOURCES;
 632     PPCPIN_DESCRIPTOR SrcDescriptor;
 633     PPCNODE_DESCRIPTOR NodeDescriptor;
 634     PPCPROPERTY_ITEM PropertyItem;
 635
 636     // allocate subdevice descriptor
 637     Descriptor = (PSUBDEVICE_DESCRIPTOR)AllocateItem(NonPagedPool, sizeof(SUBDEVICE_DESCRIPTOR), TAG_PORTCLASS);
 638     if (!Descriptor)
 639         return STATUS_INSUFFICIENT_RESOURCES;
 640
 641     // initialize physical / symbolic link connection list
 642     InitializeListHead(&Descriptor->SymbolicLinkList);
 643     InitializeListHead(&Descriptor->PhysicalConnectionList);
 644
 645     //FIXME add driver category guids
 646     Descriptor->Interfaces = (GUID*)AllocateItem(NonPagedPool, sizeof(GUID) * InterfaceCount, TAG_PORTCLASS);
 647     if (!Descriptor->Interfaces)
 648         goto cleanup;
 649
 650     // copy interface guids
 651     RtlCopyMemory(Descriptor->Interfaces, InterfaceGuids, sizeof(GUID) * InterfaceCount);
 652     Descriptor->InterfaceCount = InterfaceCount;
 653
 654     //DumpFilterDescriptor(FilterDescription);
 655
 656     // are any property sets supported by the portcls
 657     if (FilterPropertiesCount)
 658     {
 659        // first allocate filter properties set
 660        Descriptor->FilterPropertySet = (PKSPROPERTY_SET)AllocateItem(NonPagedPool, sizeof(KSPROPERTY_SET) * FilterPropertiesCount, TAG_PORTCLASS);
 661        if (! Descriptor->FilterPropertySet)
 662            goto cleanup;
 663
 664        // now copy all filter property sets
 665        Descriptor->FilterPropertySetCount = FilterPropertiesCount;
 666        for(Index = 0; Index < FilterPropertiesCount; Index++)
 667        {
 668            // copy property set
 669            RtlMoveMemory(&Descriptor->FilterPropertySet[Index], &FilterProperties[Index], sizeof(KSPROPERTY_SET));
 670
 671            if (Descriptor->FilterPropertySet[Index].PropertiesCount)
 672            {
 673                // copy property items to make sure they are dynamically allocated
 674                Descriptor->FilterPropertySet[Index].PropertyItem = (PKSPROPERTY_ITEM)AllocateItem(NonPagedPool, FilterProperties[Index].PropertiesCount * sizeof(KSPROPERTY_ITEM), TAG_PORTCLASS);
 675                if (!Descriptor->FilterPropertySet[Index].PropertyItem)
 676                {
 677                    // no memory
 678                    goto cleanup;
 679                }
 680
 681                // copy filter property items
 682                RtlMoveMemory((PVOID)Descriptor->FilterPropertySet[Index].PropertyItem, FilterProperties[Index].PropertyItem, FilterProperties[Index].PropertiesCount * sizeof(KSPROPERTY_ITEM));
 683            }
 684        }
 685     }
 686
 687     // now check if the filter descriptor supports filter properties
 688     if (FilterDescription->AutomationTable)
 689     {
 690         // get first entry
 691         PropertyItem = (PPCPROPERTY_ITEM)FilterDescription->AutomationTable->Properties;
 692
 693         // copy driver filter property sets
 694         for(Index = 0; Index < FilterDescription->AutomationTable->PropertyCount; Index++)
 695         {
 696             // add the property item
 697             Status = PcAddToPropertyTable(Descriptor, PropertyItem, FALSE);
 698
 699             // check for success
 700             if (Status != STATUS_SUCCESS)
 701             {
 702                 // goto cleanup
 703                 goto cleanup;
 704             }
 705
 706             // move to next entry
 707             PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + FilterDescription->AutomationTable->PropertyItemSize);
 708         }
 709     }
 710
 711     // check if the filter has pins
 712     if (FilterDescription->PinCount)
 713     {
 714         // allocate pin factory descriptors
 715         Descriptor->Factory.KsPinDescriptor = (PKSPIN_DESCRIPTOR)AllocateItem(NonPagedPool, sizeof(KSPIN_DESCRIPTOR) * FilterDescription->PinCount, TAG_PORTCLASS);
 716         if (!Descriptor->Factory.KsPinDescriptor)
 717             goto cleanup;
 718
 719         // allocate pin instance info
 720         Descriptor->Factory.Instances = (PPIN_INSTANCE_INFO)AllocateItem(NonPagedPool, FilterDescription->PinCount * sizeof(PIN_INSTANCE_INFO), TAG_PORTCLASS);
 721         if (!Descriptor->Factory.Instances)
 722             goto cleanup;
 723
 724         // initialize pin factory descriptor
 725         Descriptor->Factory.PinDescriptorCount = FilterDescription->PinCount;
 726         Descriptor->Factory.PinDescriptorSize = sizeof(KSPIN_DESCRIPTOR);
 727
 728         // grab first entry
 729         SrcDescriptor = (PPCPIN_DESCRIPTOR)FilterDescription->Pins;
 730
 731         // copy pin factories
 732         for(Index = 0; Index < FilterDescription->PinCount; Index++)
 733         {
 734             // copy pin descriptor
 735             RtlMoveMemory(&Descriptor->Factory.KsPinDescriptor[Index], &SrcDescriptor->KsPinDescriptor, sizeof(KSPIN_DESCRIPTOR));
 736
 737             // initialize pin factory instance data
 738             Descriptor->Factory.Instances[Index].CurrentPinInstanceCount = 0;
 739             Descriptor->Factory.Instances[Index].MaxFilterInstanceCount = SrcDescriptor->MaxFilterInstanceCount;
 740             Descriptor->Factory.Instances[Index].MaxGlobalInstanceCount = SrcDescriptor->MaxGlobalInstanceCount;
 741             Descriptor->Factory.Instances[Index].MinFilterInstanceCount = SrcDescriptor->MinFilterInstanceCount;
 742
 743             // check if the descriptor has an automation table
 744             if (SrcDescriptor->AutomationTable)
 745             {
 746                 // it has, grab first entry
 747                 PropertyItem = (PPCPROPERTY_ITEM)SrcDescriptor->AutomationTable->Properties;
 748
 749                 // now add all supported property items
 750                 for(SubIndex = 0; SubIndex < SrcDescriptor->AutomationTable->PropertyCount; SubIndex++)
 751                 {
 752                     // add the property item to the table
 753                     Status = PcAddToPropertyTable(Descriptor, PropertyItem, FALSE);
 754
 755                     // check for success
 756                     if (Status != STATUS_SUCCESS)
 757                     {
 758                         // goto cleanup
 759                         goto cleanup;
 760                     }
 761
 762                     // move to next entry
 763                     PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + SrcDescriptor->AutomationTable->PropertyItemSize);
 764                 }
 765             }
 766
 767             // move to next entry
 768             SrcDescriptor = (PPCPIN_DESCRIPTOR)((ULONG_PTR)SrcDescriptor + FilterDescription->PinSize);
 769         }
 770     }
 771
 772     // allocate topology descriptor
 773     Descriptor->Topology = (PKSTOPOLOGY)AllocateItem(NonPagedPool, sizeof(KSTOPOLOGY), TAG_PORTCLASS);
 774     if (!Descriptor->Topology)
 775         goto cleanup;
 776
 777     // are there any connections
 778     if (FilterDescription->ConnectionCount)
 779     {
 780         // allocate connection descriptor
 781         Descriptor->Topology->TopologyConnections = (PKSTOPOLOGY_CONNECTION)AllocateItem(NonPagedPool, sizeof(KSTOPOLOGY_CONNECTION) * FilterDescription->ConnectionCount, TAG_PORTCLASS);
 782         if (!Descriptor->Topology->TopologyConnections)
 783             goto cleanup;
 784
 785         // copy connection descriptor
 786         RtlMoveMemory((PVOID)Descriptor->Topology->TopologyConnections, FilterDescription->Connections, FilterDescription->ConnectionCount * sizeof(PCCONNECTION_DESCRIPTOR));
 787
 788         // store connection count
 789         Descriptor->Topology->TopologyConnectionsCount = FilterDescription->ConnectionCount;
 790     }
 791
 792     // does the filter have nodes
 793     if (FilterDescription->NodeCount)
 794     {
 795         // allocate topology node types array
 796         Descriptor->Topology->TopologyNodes = (const GUID *)AllocateItem(NonPagedPool, sizeof(GUID) * FilterDescription->NodeCount, TAG_PORTCLASS);
 797         if (!Descriptor->Topology->TopologyNodes)
 798             goto cleanup;
 799
 800         // allocate topology node names array
 801         Descriptor->Topology->TopologyNodesNames = (const GUID *)AllocateItem(NonPagedPool, sizeof(GUID) * FilterDescription->NodeCount, TAG_PORTCLASS);
 802         if (!Descriptor->Topology->TopologyNodesNames)
 803             goto cleanup;
 804
 805         // grab first entry
 806        NodeDescriptor = (PPCNODE_DESCRIPTOR)FilterDescription->Nodes;
 807
 808        // iterate all nodes and copy node types / names and node properties
 809         for(Index = 0; Index < FilterDescription->NodeCount; Index++)
 810         {
 811             // does it have a type
 812             if (NodeDescriptor->Type)
 813             {
 814                 // copy node type
 815                 RtlMoveMemory((PVOID)&Descriptor->Topology->TopologyNodes[Index], NodeDescriptor->Type, sizeof(GUID));
 816             }
 817
 818             // does it have a node name
 819             if (NodeDescriptor->Name)
 820             {
 821                 // copy node name
 822                 RtlMoveMemory((PVOID)&Descriptor->Topology->TopologyNodesNames[Index], NodeDescriptor->Name, sizeof(GUID));
 823             }
 824
 825             // check if has an automation table
 826             if (NodeDescriptor->AutomationTable)
 827             {
 828                 // grab first entry
 829                 PropertyItem = (PPCPROPERTY_ITEM)NodeDescriptor->AutomationTable->Properties;
 830
 831                 // copy all node properties into the global property set
 832                 for(SubIndex = 0; SubIndex < NodeDescriptor->AutomationTable->PropertyCount; SubIndex++)
 833                 {
 834                     // add to property set
 835                     Status = PcAddToPropertyTable(Descriptor, PropertyItem, TRUE);
 836
 837                     // check for success
 838                     if (Status != STATUS_SUCCESS)
 839                     {
 840                         // failed
 841                         goto cleanup;
 842                     }
 843
 844                     // move to next property item
 845                     PropertyItem = (PPCPROPERTY_ITEM)((ULONG_PTR)PropertyItem + NodeDescriptor->AutomationTable->PropertyItemSize);
 846                 }
 847             }
 848
 849             // move to next descriptor
 850             NodeDescriptor = (PPCNODE_DESCRIPTOR)((ULONG_PTR)NodeDescriptor + FilterDescription->NodeSize);
 851         }
 852
 853         // now store the topology node count
 854         Descriptor->Topology->TopologyNodesCount = FilterDescription->NodeCount;
 855     }
 856
 857     // store descriptor
 858     Descriptor->DeviceDescriptor = FilterDescription;
 859
 860     // store result
 861     *OutSubdeviceDescriptor = Descriptor;
 862     // done
 863     return STATUS_SUCCESS;
 864
 865 cleanup:
 866     if (Descriptor)
 867     {
 868         if (Descriptor->Interfaces)
 869             FreeItem(Descriptor->Interfaces, TAG_PORTCLASS);
 870
 871         if (Descriptor->Factory.KsPinDescriptor)
 872             FreeItem(Descriptor->Factory.KsPinDescriptor, TAG_PORTCLASS);
 873
 874         FreeItem(Descriptor, TAG_PORTCLASS);
 875     }
 876     return Status;
 877 }
 878
 879 NTSTATUS
 880 NTAPI
 881 PcValidateConnectRequest(
 882     IN PIRP Irp,
 883     IN KSPIN_FACTORY * Factory,
 884     OUT PKSPIN_CONNECT * Connect)
 885 {
 886     return KsValidateConnectRequest(Irp, Factory->PinDescriptorCount, Factory->KsPinDescriptor, Connect);
 887 }
 888