drivers/usb/usbccgp/pdo.c

   1 /*
   2  * PROJECT:     ReactOS Universal Serial Bus Bulk Enhanced Host Controller Interface
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        drivers/usb/usbccgp/pdo.c
   5  * PURPOSE:     USB  device driver.
   6  * PROGRAMMERS:
   7  *              Michael Martin (michael.martin@reactos.org)
   8  *              Johannes Anderwald (johannes.anderwald@reactos.org)
   9  *              Cameron Gutman
  10  */
  11
  12 #include "usbccgp.h"
  13
  14 #include <ntddk.h>
  15
  16 #define NDEBUG
  17 #include <debug.h>
  18
  19 NTSTATUS
  20 USBCCGP_PdoHandleQueryDeviceText(
  21     IN PDEVICE_OBJECT DeviceObject,
  22     IN OUT PIRP Irp)
  23 {
  24     LPWSTR Buffer;
  25     PPDO_DEVICE_EXTENSION PDODeviceExtension;
  26     LPWSTR GenericString = L"Composite USB Device";
  27     //
  28     // get device extension
  29     //
  30     PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
  31
  32     //
  33     // is there a device description
  34     //
  35     if (PDODeviceExtension->FunctionDescriptor->FunctionDescription.Length)
  36     {
  37         //
  38         // allocate buffer
  39         //
  40         Buffer = AllocateItem(NonPagedPool, PDODeviceExtension->FunctionDescriptor->FunctionDescription.Length + sizeof(WCHAR));
  41         if (!Buffer)
  42         {
  43             //
  44             // no memory
  45             //
  46             return STATUS_INSUFFICIENT_RESOURCES;
  47         }
  48
  49         //
  50         // copy buffer
  51         //
  52         Irp->IoStatus.Information = (ULONG_PTR)Buffer;
  53         RtlCopyMemory(Buffer, PDODeviceExtension->FunctionDescriptor->FunctionDescription.Buffer, PDODeviceExtension->FunctionDescriptor->FunctionDescription.Length);
  54         return STATUS_SUCCESS;
  55     }
  56
  57     //
  58     // FIXME use GenericCompositeUSBDeviceString
  59     //
  60     UNIMPLEMENTED
  61     Buffer = AllocateItem(PagedPool, (wcslen(GenericString) + 1) * sizeof(WCHAR));
  62     if (!Buffer)
  63     {
  64         //
  65         // no memory
  66         //
  67         return STATUS_INSUFFICIENT_RESOURCES;
  68     }
  69     RtlCopyMemory(Buffer, GenericString, (wcslen(GenericString) + 1) * sizeof(WCHAR));
  70     Irp->IoStatus.Information = (ULONG_PTR)Buffer;
  71
  72     return STATUS_SUCCESS;
  73 }
  74
  75 NTSTATUS
  76 USBCCGP_PdoHandleDeviceRelations(
  77     IN PDEVICE_OBJECT DeviceObject,
  78     IN OUT PIRP Irp)
  79 {
  80     PDEVICE_RELATIONS DeviceRelations;
  81     PIO_STACK_LOCATION IoStack;
  82
  83     DPRINT("USBCCGP_PdoHandleDeviceRelations\n");
  84
  85     //
  86     // get current irp stack location
  87     //
  88     IoStack = IoGetCurrentIrpStackLocation(Irp);
  89
  90     //
  91     // check if relation type is BusRelations
  92     //
  93     if (IoStack->Parameters.QueryDeviceRelations.Type != TargetDeviceRelation)
  94     {
  95         //
  96         // PDO handles only target device relation
  97         //
  98         return Irp->IoStatus.Status;
  99     }
 100
 101     //
 102     // allocate device relations
 103     //
 104     DeviceRelations = (PDEVICE_RELATIONS)AllocateItem(PagedPool, sizeof(DEVICE_RELATIONS));
 105     if (!DeviceRelations)
 106     {
 107         //
 108         // no memory
 109         //
 110         return STATUS_INSUFFICIENT_RESOURCES;
 111     }
 112
 113     //
 114     // initialize device relations
 115     //
 116     DeviceRelations->Count = 1;
 117     DeviceRelations->Objects[0] = DeviceObject;
 118     ObReferenceObject(DeviceObject);
 119
 120     //
 121     // store result
 122     //
 123     Irp->IoStatus.Information = (ULONG_PTR)DeviceRelations;
 124
 125     //
 126     // completed successfully
 127     //
 128     return STATUS_SUCCESS;
 129 }
 130
 131 NTSTATUS
 132 USBCCGP_PdoAppendInterfaceNumber(
 133     IN LPWSTR DeviceId,
 134     IN ULONG InterfaceNumber,
 135     OUT LPWSTR *OutString)
 136 {
 137     ULONG Length = 0, StringLength;
 138     LPWSTR String;
 139
 140     //
 141     // count length of string
 142     //
 143     String = DeviceId;
 144     while (*String)
 145     {
 146         StringLength = wcslen(String) + 1;
 147         Length += StringLength;
 148         Length += 6; //&MI_XX
 149         String += StringLength;
 150     }
 151
 152     //
 153     // now allocate the buffer
 154     //
 155     String = AllocateItem(NonPagedPool, (Length + 2) * sizeof(WCHAR));
 156     if (!String)
 157     {
 158         //
 159         // no memory
 160         //
 161         return STATUS_INSUFFICIENT_RESOURCES;
 162     }
 163
 164     //
 165     // store result
 166     //
 167     *OutString = String;
 168
 169     while (*DeviceId)
 170     {
 171         StringLength = swprintf(String, L"%s&MI_%02x", DeviceId, InterfaceNumber) + 1;
 172         Length = wcslen(DeviceId) + 1;
 173         DPRINT("String %p\n", String);
 174
 175         //
 176         // next string
 177         //
 178         String += StringLength;
 179         DeviceId += Length;
 180     }
 181
 182     //
 183     // success
 184     //
 185     return STATUS_SUCCESS;
 186 }
 187
 188
 189 NTSTATUS
 190 USBCCGP_PdoHandleQueryId(
 191     PDEVICE_OBJECT DeviceObject,
 192     PIRP Irp)
 193 {
 194     PIO_STACK_LOCATION IoStack;
 195     PUNICODE_STRING DeviceString = NULL;
 196     PPDO_DEVICE_EXTENSION PDODeviceExtension;
 197     NTSTATUS Status;
 198     LPWSTR Buffer;
 199
 200     //
 201     // get current irp stack location
 202     //
 203     IoStack = IoGetCurrentIrpStackLocation(Irp);
 204
 205     //
 206     // get device extension
 207     //
 208     PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 209
 210
 211     if (IoStack->Parameters.QueryId.IdType == BusQueryDeviceID)
 212     {
 213         //
 214         // handle query device id
 215         //
 216         Status = USBCCGP_SyncForwardIrp(PDODeviceExtension->NextDeviceObject, Irp);
 217         if (NT_SUCCESS(Status))
 218         {
 219             //
 220             // allocate buffer
 221             //
 222             Buffer = AllocateItem(NonPagedPool, (wcslen((LPWSTR)Irp->IoStatus.Information) + 7) * sizeof(WCHAR));
 223             if (Buffer)
 224             {
 225                 //
 226                 // append interface number
 227                 //
 228                 ASSERT(Irp->IoStatus.Information);
 229                 swprintf(Buffer, L"%s&MI_%02x", (LPWSTR)Irp->IoStatus.Information, PDODeviceExtension->FunctionDescriptor->FunctionNumber);
 230                 DPRINT("BusQueryDeviceID %S\n", Buffer);
 231
 232                 ExFreePool((PVOID)Irp->IoStatus.Information);
 233                 Irp->IoStatus.Information = (ULONG_PTR)Buffer;
 234             }
 235             else
 236             {
 237                 //
 238                 // no memory
 239                 //
 240                 Status = STATUS_INSUFFICIENT_RESOURCES;
 241             }
 242         }
 243         return Status;
 244     }
 245     else if (IoStack->Parameters.QueryId.IdType == BusQueryHardwareIDs)
 246     {
 247         //
 248         // handle instance id
 249         //
 250         DeviceString = &PDODeviceExtension->FunctionDescriptor->HardwareId;
 251     }
 252     else if (IoStack->Parameters.QueryId.IdType == BusQueryInstanceID)
 253     {
 254         //
 255         // handle instance id
 256         //
 257         Buffer = AllocateItem(NonPagedPool, 5 * sizeof(WCHAR));
 258         if (!Buffer)
 259         {
 260             //
 261             // no memory
 262             //
 263             return STATUS_INSUFFICIENT_RESOURCES;
 264         }
 265
 266         //
 267         // use function number
 268         //
 269         swprintf(Buffer, L"%04x", PDODeviceExtension->FunctionDescriptor->FunctionNumber);
 270         Irp->IoStatus.Information = (ULONG_PTR)Buffer;
 271         return STATUS_SUCCESS;
 272     }
 273     else if (IoStack->Parameters.QueryId.IdType == BusQueryCompatibleIDs)
 274     {
 275         //
 276         // handle instance id
 277         //
 278         DeviceString = &PDODeviceExtension->FunctionDescriptor->CompatibleId;
 279     }
 280     else
 281     {
 282         //
 283         // unsupported query
 284         //
 285         return Irp->IoStatus.Status;
 286     }
 287
 288     //
 289     // sanity check
 290     //
 291     ASSERT(DeviceString != NULL);
 292
 293     //
 294     // allocate buffer
 295     //
 296     Buffer = AllocateItem(NonPagedPool, DeviceString->Length + sizeof(WCHAR));
 297     if (!Buffer)
 298     {
 299         //
 300         // no memory
 301         //
 302         return STATUS_INSUFFICIENT_RESOURCES;
 303     }
 304
 305     //
 306     // copy buffer
 307     //
 308     RtlCopyMemory(Buffer, DeviceString->Buffer, DeviceString->Length);
 309     Buffer[DeviceString->Length / sizeof(WCHAR)] = UNICODE_NULL;
 310     Irp->IoStatus.Information = (ULONG_PTR)Buffer;
 311
 312     return STATUS_SUCCESS;
 313 }
 314
 315 NTSTATUS
 316 PDO_HandlePnp(
 317     PDEVICE_OBJECT DeviceObject,
 318     PIRP Irp)
 319 {
 320     PIO_STACK_LOCATION IoStack;
 321     PPDO_DEVICE_EXTENSION PDODeviceExtension;
 322     NTSTATUS Status;
 323     ULONG Index, bFound;
 324
 325     //
 326     // get current stack location
 327     //
 328     IoStack = IoGetCurrentIrpStackLocation(Irp);
 329
 330     //
 331     // get device extension
 332     //
 333     PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 334
 335     //
 336     // sanity check
 337     //
 338     ASSERT(PDODeviceExtension->Common.IsFDO == FALSE);
 339
 340     switch(IoStack->MinorFunction)
 341     {
 342         case IRP_MN_QUERY_DEVICE_RELATIONS:
 343         {
 344             //
 345             // handle device relations
 346             //
 347             Status = USBCCGP_PdoHandleDeviceRelations(DeviceObject, Irp);
 348             break;
 349         }
 350         case IRP_MN_QUERY_DEVICE_TEXT:
 351         {
 352             //
 353             // handle query device text
 354             //
 355             Status = USBCCGP_PdoHandleQueryDeviceText(DeviceObject, Irp);
 356             break;
 357         }
 358         case IRP_MN_QUERY_ID:
 359         {
 360             //
 361             // handle request
 362             //
 363             Status = USBCCGP_PdoHandleQueryId(DeviceObject, Irp);
 364             break;
 365         }
 366         case IRP_MN_REMOVE_DEVICE:
 367         {
 368             //
 369             // remove us from the fdo's pdo list
 370             //
 371             bFound = FALSE;
 372             for(Index = 0; Index < PDODeviceExtension->FDODeviceExtension->FunctionDescriptorCount; Index++)
 373             {
 374                 if (PDODeviceExtension->FDODeviceExtension->ChildPDO[Index] == DeviceObject)
 375                 {
 376                     //
 377                     // remove us
 378                     //
 379                     PDODeviceExtension->FDODeviceExtension->ChildPDO[Index] = NULL;
 380                     bFound = TRUE;
 381                     break;
 382                 }
 383             }
 384
 385             //
 386             // Complete the IRP
 387             //
 388             Irp->IoStatus.Status = STATUS_SUCCESS;
 389             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 390
 391             if (bFound)
 392             {
 393                 //
 394                 // Delete the device object
 395                 //
 396                 IoDeleteDevice(DeviceObject);
 397             }
 398             return STATUS_SUCCESS;
 399         }
 400         case IRP_MN_QUERY_CAPABILITIES:
 401         {
 402             //
 403             // copy device capabilities
 404             //
 405             RtlCopyMemory(IoStack->Parameters.DeviceCapabilities.Capabilities, &PDODeviceExtension->Capabilities, sizeof(DEVICE_CAPABILITIES));
 406
 407             /* Complete the IRP */
 408             Irp->IoStatus.Status = STATUS_SUCCESS;
 409             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 410             return STATUS_SUCCESS;
 411         }
 412         case IRP_MN_QUERY_REMOVE_DEVICE:
 413         case IRP_MN_QUERY_STOP_DEVICE:
 414         {
 415             //
 416             // sure
 417             //
 418             Status = STATUS_SUCCESS;
 419             break;
 420         }
 421         case IRP_MN_START_DEVICE:
 422         {
 423             //
 424             // no-op for PDO
 425             //
 426             DPRINT("[USBCCGP] PDO IRP_MN_START\n");
 427             Status = STATUS_SUCCESS;
 428             break;
 429         }
 430         case IRP_MN_QUERY_INTERFACE:
 431         {
 432             //
 433             // forward to lower device object
 434             //
 435             IoSkipCurrentIrpStackLocation(Irp);
 436             return IoCallDriver(PDODeviceExtension->NextDeviceObject, Irp);
 437         }
 438         default:
 439         {
 440             //
 441             // do nothing
 442             //
 443             Status = Irp->IoStatus.Status;
 444             break;
 445         }
 446     }
 447
 448     //
 449     // complete request
 450     //
 451     if (Status != STATUS_PENDING)
 452     {
 453         //
 454         // store result
 455         //
 456         Irp->IoStatus.Status = Status;
 457
 458         //
 459         // complete request
 460         //
 461         IoCompleteRequest(Irp, IO_NO_INCREMENT);
 462     }
 463
 464     //
 465     // done processing
 466     //
 467     return Status;
 468
 469 }
 470
 471 NTSTATUS
 472 USBCCGP_BuildConfigurationDescriptor(
 473     PDEVICE_OBJECT DeviceObject,
 474     PIRP Irp)
 475 {
 476     PIO_STACK_LOCATION IoStack;
 477     PPDO_DEVICE_EXTENSION PDODeviceExtension;
 478     PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor;
 479     PUSB_INTERFACE_DESCRIPTOR InterfaceDescriptor;
 480     ULONG TotalSize, Index;
 481     ULONG Size;
 482     PURB Urb;
 483     PVOID Buffer;
 484     PUCHAR BufferPtr;
 485     UCHAR InterfaceNumber;
 486
 487     //
 488     // get current stack location
 489     //
 490     IoStack = IoGetCurrentIrpStackLocation(Irp);
 491
 492     DPRINT("USBCCGP_BuildConfigurationDescriptor\n");
 493
 494     //
 495     // get device extension
 496     //
 497     PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 498
 499     //
 500     // get configuration descriptor
 501     //
 502     ConfigurationDescriptor = PDODeviceExtension->ConfigurationDescriptor;
 503
 504     //
 505     // calculate size of configuration descriptor
 506     //
 507     TotalSize = sizeof(USB_CONFIGURATION_DESCRIPTOR);
 508
 509     for (Index = 0; Index < PDODeviceExtension->FunctionDescriptor->NumberOfInterfaces; Index++)
 510     {
 511         //
 512         // get current interface descriptor
 513         //
 514         InterfaceDescriptor = PDODeviceExtension->FunctionDescriptor->InterfaceDescriptorList[Index];
 515         InterfaceNumber = InterfaceDescriptor->bInterfaceNumber;
 516
 517         //
 518         // add to size and move to next descriptor
 519         //
 520         TotalSize += InterfaceDescriptor->bLength;
 521         InterfaceDescriptor = (PUSB_INTERFACE_DESCRIPTOR)((ULONG_PTR)InterfaceDescriptor + InterfaceDescriptor->bLength);
 522
 523         do
 524         {
 525             if ((ULONG_PTR)InterfaceDescriptor >= ((ULONG_PTR)ConfigurationDescriptor + ConfigurationDescriptor->wTotalLength))
 526             {
 527                 //
 528                 // reached end of configuration descriptor
 529                 //
 530                 break;
 531             }
 532
 533             //
 534             // association descriptors are removed
 535             //
 536             if (InterfaceDescriptor->bDescriptorType != USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE)
 537             {
 538                 if (InterfaceDescriptor->bDescriptorType == USB_INTERFACE_DESCRIPTOR_TYPE)
 539                 {
 540                     if (InterfaceNumber != InterfaceDescriptor->bInterfaceNumber)
 541                     {
 542                         //
 543                         // reached next descriptor
 544                         //
 545                         break;
 546                     }
 547
 548                     //
 549                     // include alternate descriptor
 550                     //
 551                 }
 552
 553                 //
 554                 // append size
 555                 //
 556                 TotalSize += InterfaceDescriptor->bLength;
 557             }
 558
 559             //
 560             // move to next descriptor
 561             //
 562             InterfaceDescriptor = (PUSB_INTERFACE_DESCRIPTOR)((ULONG_PTR)InterfaceDescriptor + InterfaceDescriptor->bLength);
 563         } while(TRUE);
 564     }
 565
 566     //
 567     // now allocate temporary buffer for the configuration descriptor
 568     //
 569     Buffer = AllocateItem(NonPagedPool, TotalSize);
 570     if (!Buffer)
 571     {
 572         //
 573         // failed to allocate buffer
 574         //
 575         DPRINT1("[USBCCGP] Failed to allocate %lu Bytes\n", TotalSize);
 576         return STATUS_INSUFFICIENT_RESOURCES;
 577     }
 578
 579     //
 580     // first copy the configuration descriptor
 581     //
 582     RtlCopyMemory(Buffer, ConfigurationDescriptor, sizeof(USB_CONFIGURATION_DESCRIPTOR));
 583     BufferPtr = (PUCHAR)((ULONG_PTR)Buffer + ConfigurationDescriptor->bLength);
 584
 585     for (Index = 0; Index < PDODeviceExtension->FunctionDescriptor->NumberOfInterfaces; Index++)
 586     {
 587         //
 588         // get current interface descriptor
 589         //
 590         InterfaceDescriptor = PDODeviceExtension->FunctionDescriptor->InterfaceDescriptorList[Index];
 591         InterfaceNumber = InterfaceDescriptor->bInterfaceNumber;
 592
 593         //
 594         // copy descriptor and move to next descriptor
 595         //
 596         RtlCopyMemory(BufferPtr, InterfaceDescriptor, InterfaceDescriptor->bLength);
 597         BufferPtr += InterfaceDescriptor->bLength;
 598         InterfaceDescriptor = (PUSB_INTERFACE_DESCRIPTOR)((ULONG_PTR)InterfaceDescriptor + InterfaceDescriptor->bLength);
 599
 600         do
 601         {
 602             if ((ULONG_PTR)InterfaceDescriptor >= ((ULONG_PTR)ConfigurationDescriptor + ConfigurationDescriptor->wTotalLength))
 603             {
 604                 //
 605                 // reached end of configuration descriptor
 606                 //
 607                 break;
 608             }
 609
 610             //
 611             // association descriptors are removed
 612             //
 613             if (InterfaceDescriptor->bDescriptorType != USB_INTERFACE_ASSOCIATION_DESCRIPTOR_TYPE)
 614             {
 615                 if (InterfaceDescriptor->bDescriptorType == USB_INTERFACE_DESCRIPTOR_TYPE)
 616                 {
 617                     if (InterfaceNumber != InterfaceDescriptor->bInterfaceNumber)
 618                     {
 619                         //
 620                         // reached next descriptor
 621                         //
 622                         break;
 623                     }
 624
 625                     //
 626                     // include alternate descriptor
 627                     //
 628                     DPRINT("InterfaceDescriptor %p Alternate %x InterfaceNumber %x\n", InterfaceDescriptor, InterfaceDescriptor->bAlternateSetting, InterfaceDescriptor->bInterfaceNumber);
 629                 }
 630
 631                 //
 632                 // copy descriptor
 633                 //
 634                 RtlCopyMemory(BufferPtr, InterfaceDescriptor, InterfaceDescriptor->bLength);
 635                 BufferPtr += InterfaceDescriptor->bLength;
 636             }
 637
 638             //
 639             // move to next descriptor
 640             //
 641             InterfaceDescriptor = (PUSB_INTERFACE_DESCRIPTOR)((ULONG_PTR)InterfaceDescriptor + InterfaceDescriptor->bLength);
 642         } while(TRUE);
 643     }
 644
 645     //
 646     // modify configuration descriptor
 647     //
 648     ConfigurationDescriptor = Buffer;
 649     ConfigurationDescriptor->wTotalLength = (USHORT)TotalSize;
 650     ConfigurationDescriptor->bNumInterfaces = PDODeviceExtension->FunctionDescriptor->NumberOfInterfaces;
 651
 652     //
 653     // get urb
 654     //
 655     Urb = (PURB)IoStack->Parameters.Others.Argument1;
 656     ASSERT(Urb);
 657
 658     //
 659     // copy descriptor
 660     //
 661     Size = min(TotalSize, Urb->UrbControlDescriptorRequest.TransferBufferLength);
 662     RtlCopyMemory(Urb->UrbControlDescriptorRequest.TransferBuffer, Buffer, Size);
 663
 664     //
 665     // store final size
 666     //
 667     Urb->UrbControlDescriptorRequest.TransferBufferLength = Size;
 668
 669     //
 670     // free buffer
 671     //
 672     FreeItem(Buffer);
 673
 674     //
 675     // done
 676     //
 677     return STATUS_SUCCESS;
 678 }
 679
 680 NTSTATUS
 681 USBCCGP_PDOSelectConfiguration(
 682     PDEVICE_OBJECT DeviceObject,
 683     PIRP Irp)
 684 {
 685     PIO_STACK_LOCATION IoStack;
 686     PPDO_DEVICE_EXTENSION PDODeviceExtension;
 687     PURB Urb, NewUrb;
 688     PUSBD_INTERFACE_INFORMATION InterfaceInformation;
 689     ULONG InterfaceIndex, Length;
 690     PUSBD_INTERFACE_LIST_ENTRY Entry;
 691     ULONG NeedSelect, FoundInterface;
 692     NTSTATUS Status;
 693
 694     //
 695     // get current stack location
 696     //
 697     IoStack = IoGetCurrentIrpStackLocation(Irp);
 698
 699     //
 700     // get device extension
 701     //
 702     PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 703
 704     //
 705     // get urb
 706     //
 707     Urb = (PURB)IoStack->Parameters.Others.Argument1;
 708     ASSERT(Urb);
 709
 710     //
 711     // is there already an configuration handle
 712     //
 713     if (Urb->UrbSelectConfiguration.ConfigurationHandle)
 714     {
 715         //
 716         // nothing to do
 717         //
 718         return STATUS_SUCCESS;
 719     }
 720
 721     // sanity checks
 722     //C_ASSERT(sizeof(struct _URB_HEADER) == 16);
 723     //C_ASSERT(FIELD_OFFSET(struct _URB_SELECT_CONFIGURATION, Interface.Length) == 24);
 724     //C_ASSERT(sizeof(USBD_INTERFACE_INFORMATION) == 36);
 725     //C_ASSERT(sizeof(struct _URB_SELECT_CONFIGURATION) == 0x3C);
 726
 727     // available buffer length
 728     Length = Urb->UrbSelectConfiguration.Hdr.Length - FIELD_OFFSET(struct _URB_SELECT_CONFIGURATION, Interface.Length);
 729
 730     //
 731     // check all interfaces
 732     //
 733     InterfaceInformation = &Urb->UrbSelectConfiguration.Interface;
 734
 735     Entry = NULL;
 736     do
 737     {
 738         DPRINT1("[USBCCGP] SelectConfiguration Function %x InterfaceNumber %x Alternative %x Length %lu InterfaceInformation->Length %lu\n", PDODeviceExtension->FunctionDescriptor->FunctionNumber, InterfaceInformation->InterfaceNumber, InterfaceInformation->AlternateSetting, Length, InterfaceInformation->Length);
 739         ASSERT(InterfaceInformation->Length);
 740         //
 741         // search for the interface in the local interface list
 742         //
 743         FoundInterface = FALSE;
 744         for (InterfaceIndex = 0; InterfaceIndex < PDODeviceExtension->FunctionDescriptor->NumberOfInterfaces; InterfaceIndex++)
 745         {
 746             if (PDODeviceExtension->FunctionDescriptor->InterfaceDescriptorList[InterfaceIndex]->bInterfaceNumber == InterfaceInformation->InterfaceNumber)
 747             {
 748                 // found interface entry
 749                 FoundInterface = TRUE;
 750                 break;
 751             }
 752         }
 753
 754         if (!FoundInterface)
 755         {
 756             //
 757             // invalid parameter
 758             //
 759             DPRINT1("InterfaceInformation InterfaceNumber %x Alternative %x NumberOfPipes %x not found\n", InterfaceInformation->InterfaceNumber, InterfaceInformation->AlternateSetting, InterfaceInformation->NumberOfPipes);
 760             return STATUS_INVALID_PARAMETER;
 761         }
 762
 763         //
 764         // now query the total interface list
 765         //
 766         Entry = NULL;
 767         for (InterfaceIndex = 0; InterfaceIndex < PDODeviceExtension->InterfaceListCount; InterfaceIndex++)
 768         {
 769             if (PDODeviceExtension->InterfaceList[InterfaceIndex].Interface->InterfaceNumber == InterfaceInformation->InterfaceNumber)
 770             {
 771                 //
 772                 // found entry
 773                 //
 774                 Entry = &PDODeviceExtension->InterfaceList[InterfaceIndex];
 775             }
 776         }
 777
 778         //
 779         // sanity check
 780         //
 781         ASSERT(Entry);
 782         if (!Entry)
 783         {
 784             //
 785             // corruption detected
 786             //
 787             KeBugCheck(0);
 788         }
 789
 790         NeedSelect = FALSE;
 791         if (Entry->InterfaceDescriptor->bAlternateSetting == InterfaceInformation->AlternateSetting)
 792         {
 793             for(InterfaceIndex = 0; InterfaceIndex < InterfaceInformation->NumberOfPipes; InterfaceIndex++)
 794             {
 795                 if (InterfaceInformation->Pipes[InterfaceIndex].MaximumTransferSize != Entry->Interface->Pipes[InterfaceIndex].MaximumTransferSize)
 796                 {
 797                     //
 798                     // changed interface
 799                     //
 800                     NeedSelect = TRUE;
 801                 }
 802             }
 803         }
 804         else
 805         {
 806             //
 807             // need select as the interface number differ
 808             //
 809             NeedSelect = TRUE;
 810         }
 811
 812         if (!NeedSelect)
 813         {
 814             //
 815             // interface is already selected
 816             //
 817             ASSERT(Length >= Entry->Interface->Length);
 818             RtlCopyMemory(InterfaceInformation, Entry->Interface, Entry->Interface->Length);
 819
 820             //
 821             // adjust remaining buffer size
 822             //
 823             ASSERT(Entry->Interface->Length);
 824             Length -= Entry->Interface->Length;
 825
 826             //
 827             // move to next output interface information
 828             //
 829             InterfaceInformation = (PUSBD_INTERFACE_INFORMATION)((ULONG_PTR)InterfaceInformation + Entry->Interface->Length);
 830         }
 831         else
 832         {
 833             //
 834             // select interface
 835             //
 836             DPRINT1("Selecting InterfaceIndex %lu AlternateSetting %lu NumberOfPipes %lu\n", InterfaceInformation->InterfaceNumber, InterfaceInformation->AlternateSetting, InterfaceInformation->NumberOfPipes);
 837             ASSERT(InterfaceInformation->Length == Entry->Interface->Length);
 838
 839             //
 840             // build urb
 841             //
 842             NewUrb = AllocateItem(NonPagedPool, GET_SELECT_INTERFACE_REQUEST_SIZE(InterfaceInformation->NumberOfPipes));
 843             if (!NewUrb)
 844             {
 845                 //
 846                 // no memory
 847                 //
 848                 return STATUS_INSUFFICIENT_RESOURCES;
 849             }
 850
 851             //
 852             // now prepare interface urb
 853             //
 854             UsbBuildSelectInterfaceRequest(NewUrb, (USHORT)GET_SELECT_INTERFACE_REQUEST_SIZE(InterfaceInformation->NumberOfPipes), PDODeviceExtension->ConfigurationHandle, InterfaceInformation->InterfaceNumber, InterfaceInformation->AlternateSetting);
 855
 856             //
 857             // now select the interface
 858             //
 859             Status = USBCCGP_SyncUrbRequest(PDODeviceExtension->NextDeviceObject, NewUrb);
 860             DPRINT1("SelectInterface Status %x\n", Status);
 861
 862             if (!NT_SUCCESS(Status))
 863             {
 864                  //
 865                  // failed
 866                  //
 867                  break;
 868             }
 869
 870             //
 871             // update configuration info
 872             //
 873             ASSERT(Entry->Interface->Length >= NewUrb->UrbSelectInterface.Interface.Length);
 874             ASSERT(Length >= NewUrb->UrbSelectInterface.Interface.Length);
 875             RtlCopyMemory(Entry->Interface, &NewUrb->UrbSelectInterface.Interface, NewUrb->UrbSelectInterface.Interface.Length);
 876
 877             //
 878             // update provided interface information
 879             //
 880             ASSERT(Length >= Entry->Interface->Length);
 881             RtlCopyMemory(InterfaceInformation, Entry->Interface, Entry->Interface->Length);
 882
 883             //
 884             // decrement remaining buffer size
 885             //
 886             ASSERT(Entry->Interface->Length);
 887             Length -= Entry->Interface->Length;
 888
 889             //
 890             // adjust output buffer offset
 891             //
 892             InterfaceInformation = (PUSBD_INTERFACE_INFORMATION)((ULONG_PTR)InterfaceInformation + Entry->Interface->Length);
 893
 894             //
 895             // free urb
 896             //
 897             FreeItem(NewUrb);
 898         }
 899
 900     } while(Length);
 901
 902     //
 903     // store configuration handle
 904     //
 905     Urb->UrbSelectConfiguration.ConfigurationHandle = PDODeviceExtension->ConfigurationHandle;
 906
 907     DPRINT1("[USBCCGP] SelectConfiguration Function %x Completed\n", PDODeviceExtension->FunctionDescriptor->FunctionNumber);
 908
 909     //
 910     // done
 911     //
 912     return STATUS_SUCCESS;
 913 }
 914
 915 NTSTATUS
 916 PDO_HandleInternalDeviceControl(
 917     PDEVICE_OBJECT DeviceObject,
 918     PIRP Irp)
 919 {
 920     PIO_STACK_LOCATION IoStack;
 921     PPDO_DEVICE_EXTENSION PDODeviceExtension;
 922     NTSTATUS Status;
 923     PURB Urb;
 924
 925     //
 926     // get current stack location
 927     //
 928     IoStack = IoGetCurrentIrpStackLocation(Irp);
 929
 930     //
 931     // get device extension
 932     //
 933     PDODeviceExtension = (PPDO_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 934
 935     if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_SUBMIT_URB)
 936     {
 937         //
 938         // get urb
 939         //
 940         Urb = (PURB)IoStack->Parameters.Others.Argument1;
 941         ASSERT(Urb);
 942         DPRINT("IOCTL_INTERNAL_USB_SUBMIT_URB Function %x\n", Urb->UrbHeader.Function);
 943
 944         if (Urb->UrbHeader.Function == URB_FUNCTION_SELECT_CONFIGURATION)
 945         {
 946             //
 947             // select configuration
 948             //
 949             Status = USBCCGP_PDOSelectConfiguration(DeviceObject, Irp);
 950             Irp->IoStatus.Status = Status;
 951             IoCompleteRequest(Irp, IO_NO_INCREMENT);
 952             return Status;
 953         }
 954         else if (Urb->UrbHeader.Function == URB_FUNCTION_GET_DESCRIPTOR_FROM_DEVICE)
 955         {
 956             if (Urb->UrbControlDescriptorRequest.DescriptorType == USB_DEVICE_DESCRIPTOR_TYPE)
 957             {
 958                 //
 959                 // is the buffer big enough
 960                 //
 961                 if (Urb->UrbControlDescriptorRequest.TransferBufferLength < sizeof(USB_DEVICE_DESCRIPTOR))
 962                 {
 963                     //
 964                     // invalid buffer size
 965                     //
 966                     DPRINT1("[USBCCGP] invalid device descriptor size %lu\n", Urb->UrbControlDescriptorRequest.TransferBufferLength);
 967                     Urb->UrbControlDescriptorRequest.TransferBufferLength = sizeof(USB_DEVICE_DESCRIPTOR);
 968                     Irp->IoStatus.Status = STATUS_INVALID_BUFFER_SIZE;
 969                     IoCompleteRequest(Irp, IO_NO_INCREMENT);
 970                     return STATUS_INVALID_BUFFER_SIZE;
 971                 }
 972
 973                 //
 974                 // copy device descriptor
 975                 //
 976                 ASSERT(Urb->UrbControlDescriptorRequest.TransferBuffer);
 977                 RtlCopyMemory(Urb->UrbControlDescriptorRequest.TransferBuffer, &PDODeviceExtension->DeviceDescriptor, sizeof(USB_DEVICE_DESCRIPTOR));
 978                 Irp->IoStatus.Status = STATUS_SUCCESS;
 979                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
 980                 return STATUS_SUCCESS;
 981             }
 982             else if (Urb->UrbControlDescriptorRequest.DescriptorType == USB_CONFIGURATION_DESCRIPTOR_TYPE)
 983             {
 984                 //
 985                 // build configuration descriptor
 986                 //
 987                 Status = USBCCGP_BuildConfigurationDescriptor(DeviceObject, Irp);
 988                 Irp->IoStatus.Status = Status;
 989                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
 990                 return Status;
 991             }
 992             else if (Urb->UrbControlDescriptorRequest.DescriptorType == USB_STRING_DESCRIPTOR_TYPE)
 993             {
 994                 PUSB_STRING_DESCRIPTOR StringDescriptor;
 995
 996                 //
 997                 // get the requested string descriptor
 998                 //
 999                 ASSERT(Urb->UrbControlDescriptorRequest.TransferBuffer);
1000                 Status = USBCCGP_GetDescriptor(PDODeviceExtension->FDODeviceExtension->NextDeviceObject,
1001                                                USB_STRING_DESCRIPTOR_TYPE,
1002                                                Urb->UrbControlDescriptorRequest.TransferBufferLength,
1003                                                Urb->UrbControlDescriptorRequest.Index,
1004                                                Urb->UrbControlDescriptorRequest.LanguageId,
1005                                                (PVOID*)&StringDescriptor);
1006                 if (NT_SUCCESS(Status))
1007                 {
1008                     if (StringDescriptor->bLength == 2)
1009                     {
1010                         FreeItem(StringDescriptor);
1011                         Status = STATUS_DEVICE_DATA_ERROR;
1012                     }
1013                     else
1014                     {
1015                         RtlCopyMemory(Urb->UrbControlDescriptorRequest.TransferBuffer,
1016                                       StringDescriptor->bString,
1017                                       StringDescriptor->bLength + sizeof(WCHAR));
1018                         FreeItem(StringDescriptor);
1019                         Status = STATUS_SUCCESS;
1020                     }
1021                 }
1022                 Irp->IoStatus.Status = Status;
1023                 IoCompleteRequest(Irp, IO_NO_INCREMENT);
1024                 return Status;
1025             }
1026         }
1027         else
1028         {
1029             IoSkipCurrentIrpStackLocation(Irp);
1030             Status = IoCallDriver(PDODeviceExtension->NextDeviceObject, Irp);
1031             return Status;
1032         }
1033     }
1034     else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_GET_PORT_STATUS)
1035     {
1036         IoSkipCurrentIrpStackLocation(Irp);
1037         Status = IoCallDriver(PDODeviceExtension->NextDeviceObject, Irp);
1038         return Status;
1039     }
1040     else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_RESET_PORT)
1041     {
1042         IoSkipCurrentIrpStackLocation(Irp);
1043         Status = IoCallDriver(PDODeviceExtension->NextDeviceObject, Irp);
1044         return Status;
1045     }
1046     else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_INTERNAL_USB_CYCLE_PORT)
1047     {
1048         IoSkipCurrentIrpStackLocation(Irp);
1049         Status = IoCallDriver(PDODeviceExtension->NextDeviceObject, Irp);
1050         return Status;
1051     }
1052
1053     DPRINT1("IOCTL %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
1054     DPRINT1("InputBufferLength %lu\n", IoStack->Parameters.DeviceIoControl.InputBufferLength);
1055     DPRINT1("OutputBufferLength %lu\n", IoStack->Parameters.DeviceIoControl.OutputBufferLength);
1056     DPRINT1("Type3InputBuffer %p\n", IoStack->Parameters.DeviceIoControl.Type3InputBuffer);
1057
1058     ASSERT(FALSE);
1059
1060     Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
1061     IoCompleteRequest(Irp, IO_NO_INCREMENT);
1062     return STATUS_NOT_IMPLEMENTED;
1063 }
1064
1065
1066 NTSTATUS
1067 PDO_Dispatch(
1068     PDEVICE_OBJECT DeviceObject,
1069     PIRP Irp)
1070 {
1071     PIO_STACK_LOCATION IoStack;
1072     NTSTATUS Status;
1073
1074     /* get stack location */
1075     IoStack = IoGetCurrentIrpStackLocation(Irp);
1076
1077     switch(IoStack->MajorFunction)
1078     {
1079         case IRP_MJ_PNP:
1080             return PDO_HandlePnp(DeviceObject, Irp);
1081         case IRP_MJ_INTERNAL_DEVICE_CONTROL:
1082             return PDO_HandleInternalDeviceControl(DeviceObject, Irp);
1083         case IRP_MJ_POWER:
1084             PoStartNextPowerIrp(Irp);
1085             Irp->IoStatus.Status = STATUS_SUCCESS;
1086             IoCompleteRequest(Irp, IO_NO_INCREMENT);
1087             return STATUS_SUCCESS;
1088         default:
1089             DPRINT1("PDO_Dispatch Function %x not implemented\n", IoStack->MajorFunction);
1090             Status = Irp->IoStatus.Status;
1091             IoCompleteRequest(Irp, IO_NO_INCREMENT);
1092             return Status;
1093     }
1094 }