drivers/bus/pci/pci.c

   1 /*
   2  * PROJECT:         ReactOS PCI Bus driver
   3  * FILE:            pci.c
   4  * PURPOSE:         Driver entry
   5  * PROGRAMMERS:     Casper S. Hornstrup (chorns@users.sourceforge.net)
   6  * UPDATE HISTORY:
   7  *      10-09-2001  CSH  Created
   8  */
   9
  10 #include "pci.h"
  11
  12 #include <stdio.h>
  13
  14 #define NDEBUG
  15 #include <debug.h>
  16
  17 static DRIVER_DISPATCH PciDispatchDeviceControl;
  18 static NTSTATUS NTAPI PciDispatchDeviceControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
  19
  20 static DRIVER_ADD_DEVICE PciAddDevice;
  21 static NTSTATUS NTAPI PciAddDevice(IN PDRIVER_OBJECT DriverObject, IN PDEVICE_OBJECT PhysicalDeviceObject);
  22
  23 static DRIVER_DISPATCH PciPowerControl;
  24 static NTSTATUS NTAPI PciPowerControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
  25
  26 static DRIVER_DISPATCH PciPnpControl;
  27 static NTSTATUS NTAPI PciPnpControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp);
  28
  29
  30 #ifdef  ALLOC_PRAGMA
  31
  32 // Make the initialization routines discardable, so that they
  33 // don't waste space
  34
  35 #pragma  alloc_text(init, DriverEntry)
  36
  37 #endif  /*  ALLOC_PRAGMA  */
  38
  39 /*** PUBLIC ******************************************************************/
  40
  41 PPCI_DRIVER_EXTENSION DriverExtension = NULL;
  42
  43 /*** PRIVATE *****************************************************************/
  44
  45 static NTSTATUS
  46 NTAPI
  47 PciDispatchDeviceControl(
  48     IN PDEVICE_OBJECT DeviceObject,
  49     IN PIRP Irp)
  50 {
  51     PIO_STACK_LOCATION IrpSp;
  52     NTSTATUS Status;
  53
  54     UNREFERENCED_PARAMETER(DeviceObject);
  55     DPRINT("Called. IRP is at (0x%p)\n", Irp);
  56
  57     Irp->IoStatus.Information = 0;
  58
  59     IrpSp = IoGetCurrentIrpStackLocation(Irp);
  60     switch (IrpSp->Parameters.DeviceIoControl.IoControlCode)
  61     {
  62         default:
  63             DPRINT("Unknown IOCTL 0x%X\n", IrpSp->Parameters.DeviceIoControl.IoControlCode);
  64             Status = STATUS_NOT_IMPLEMENTED;
  65             break;
  66     }
  67
  68     if (Status != STATUS_PENDING)
  69     {
  70         Irp->IoStatus.Status = Status;
  71
  72         DPRINT("Completing IRP at 0x%p\n", Irp);
  73
  74         IoCompleteRequest(Irp, IO_NO_INCREMENT);
  75     }
  76
  77     DPRINT("Leaving. Status 0x%X\n", Status);
  78
  79     return Status;
  80 }
  81
  82
  83 static NTSTATUS
  84 NTAPI
  85 PciPnpControl(
  86     IN PDEVICE_OBJECT DeviceObject,
  87     IN PIRP Irp)
  88 /*
  89  * FUNCTION: Handle Plug and Play IRPs
  90  * ARGUMENTS:
  91  *     DeviceObject = Pointer to PDO or FDO
  92  *     Irp          = Pointer to IRP that should be handled
  93  * RETURNS:
  94  *     Status
  95  */
  96 {
  97     PCOMMON_DEVICE_EXTENSION DeviceExtension;
  98     NTSTATUS Status;
  99
 100     DeviceExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 101
 102     DPRINT("IsFDO %u\n", DeviceExtension->IsFDO);
 103
 104     if (DeviceExtension->IsFDO)
 105     {
 106         Status = FdoPnpControl(DeviceObject, Irp);
 107     }
 108     else
 109     {
 110         Status = PdoPnpControl(DeviceObject, Irp);
 111     }
 112
 113     return Status;
 114 }
 115
 116
 117 static NTSTATUS
 118 NTAPI
 119 PciPowerControl(
 120     IN PDEVICE_OBJECT DeviceObject,
 121     IN PIRP Irp)
 122 /*
 123  * FUNCTION: Handle power management IRPs
 124  * ARGUMENTS:
 125  *     DeviceObject = Pointer to PDO or FDO
 126  *     Irp          = Pointer to IRP that should be handled
 127  * RETURNS:
 128  *     Status
 129  */
 130 {
 131     PCOMMON_DEVICE_EXTENSION DeviceExtension;
 132     NTSTATUS Status;
 133
 134     DeviceExtension = (PCOMMON_DEVICE_EXTENSION)DeviceObject->DeviceExtension;
 135
 136     if (DeviceExtension->IsFDO)
 137     {
 138         Status = FdoPowerControl(DeviceObject, Irp);
 139     }
 140     else
 141     {
 142         Status = PdoPowerControl(DeviceObject, Irp);
 143     }
 144
 145     return Status;
 146 }
 147
 148
 149 static NTSTATUS
 150 NTAPI
 151 PciAddDevice(
 152     IN PDRIVER_OBJECT DriverObject,
 153     IN PDEVICE_OBJECT PhysicalDeviceObject)
 154 {
 155     PFDO_DEVICE_EXTENSION DeviceExtension;
 156     PDEVICE_OBJECT Fdo;
 157     NTSTATUS Status;
 158
 159     DPRINT("Called\n");
 160     if (PhysicalDeviceObject == NULL)
 161         return STATUS_SUCCESS;
 162
 163     Status = IoCreateDevice(DriverObject,
 164                             sizeof(FDO_DEVICE_EXTENSION),
 165                             NULL,
 166                             FILE_DEVICE_BUS_EXTENDER,
 167                             FILE_DEVICE_SECURE_OPEN,
 168                             TRUE,
 169                             &Fdo);
 170     if (!NT_SUCCESS(Status))
 171     {
 172         DPRINT("IoCreateDevice() failed with status 0x%X\n", Status);
 173         return Status;
 174     }
 175
 176     DeviceExtension = (PFDO_DEVICE_EXTENSION)Fdo->DeviceExtension;
 177
 178     RtlZeroMemory(DeviceExtension, sizeof(FDO_DEVICE_EXTENSION));
 179
 180     DeviceExtension->Common.IsFDO = TRUE;
 181
 182     DeviceExtension->Ldo = IoAttachDeviceToDeviceStack(Fdo,
 183                                                        PhysicalDeviceObject);
 184
 185     DeviceExtension->State = dsStopped;
 186
 187     Fdo->Flags &= ~DO_DEVICE_INITIALIZING;
 188
 189     //Fdo->Flags |= DO_POWER_PAGABLE;
 190
 191     DPRINT("Done AddDevice\n");
 192
 193     return STATUS_SUCCESS;
 194 }
 195
 196 DRIVER_UNLOAD PciUnload;
 197
 198 VOID
 199 NTAPI
 200 PciUnload(
 201     IN PDRIVER_OBJECT DriverObject)
 202 {
 203     /* The driver object extension is destroyed by the I/O manager */
 204     UNREFERENCED_PARAMETER(DriverObject);
 205 }
 206
 207 NTSTATUS
 208 NTAPI
 209 DriverEntry(
 210     IN PDRIVER_OBJECT DriverObject,
 211     IN PUNICODE_STRING RegistryPath)
 212 {
 213     NTSTATUS Status;
 214
 215     UNREFERENCED_PARAMETER(RegistryPath);
 216     DPRINT("Peripheral Component Interconnect Bus Driver\n");
 217
 218     DriverObject->MajorFunction[IRP_MJ_DEVICE_CONTROL] = PciDispatchDeviceControl;
 219     DriverObject->MajorFunction[IRP_MJ_PNP] = PciPnpControl;
 220     DriverObject->MajorFunction[IRP_MJ_POWER] = PciPowerControl;
 221     DriverObject->DriverExtension->AddDevice = PciAddDevice;
 222     DriverObject->DriverUnload = PciUnload;
 223
 224     Status = IoAllocateDriverObjectExtension(DriverObject,
 225                                              DriverObject,
 226                                              sizeof(PCI_DRIVER_EXTENSION),
 227                                              (PVOID*)&DriverExtension);
 228     if (!NT_SUCCESS(Status))
 229         return Status;
 230
 231     RtlZeroMemory(DriverExtension, sizeof(PCI_DRIVER_EXTENSION));
 232
 233     InitializeListHead(&DriverExtension->BusListHead);
 234     KeInitializeSpinLock(&DriverExtension->BusListLock);
 235
 236     return STATUS_SUCCESS;
 237 }
 238
 239
 240 NTSTATUS
 241 PciCreateDeviceIDString(PUNICODE_STRING DeviceID,
 242                         PPCI_DEVICE Device)
 243 {
 244     WCHAR Buffer[256];
 245
 246     swprintf(Buffer,
 247              L"PCI\\VEN_%04X&DEV_%04X&SUBSYS_%08X&REV_%02X",
 248              Device->PciConfig.VendorID,
 249              Device->PciConfig.DeviceID,
 250              (Device->PciConfig.u.type0.SubSystemID << 16) +
 251              Device->PciConfig.u.type0.SubVendorID,
 252              Device->PciConfig.RevisionID);
 253
 254     return RtlCreateUnicodeString(DeviceID, Buffer) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
 255 }
 256
 257
 258 NTSTATUS
 259 PciCreateInstanceIDString(PUNICODE_STRING InstanceID,
 260                           PPCI_DEVICE Device)
 261 {
 262     WCHAR Buffer[3];
 263
 264     swprintf(Buffer, L"%02X", Device->SlotNumber.u.AsULONG & 0xff);
 265
 266     return RtlCreateUnicodeString(InstanceID, Buffer) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
 267 }
 268
 269
 270 NTSTATUS
 271 PciCreateHardwareIDsString(PUNICODE_STRING HardwareIDs,
 272                            PPCI_DEVICE Device)
 273 {
 274     WCHAR Buffer[256];
 275     UNICODE_STRING BufferU;
 276     ULONG Index;
 277
 278     Index = 0;
 279     Index += swprintf(&Buffer[Index],
 280                       L"PCI\\VEN_%04X&DEV_%04X&SUBSYS_%08X&REV_%02X",
 281                       Device->PciConfig.VendorID,
 282                       Device->PciConfig.DeviceID,
 283                       (Device->PciConfig.u.type0.SubSystemID << 16) +
 284                       Device->PciConfig.u.type0.SubVendorID,
 285                       Device->PciConfig.RevisionID);
 286     Index++;
 287
 288     Index += swprintf(&Buffer[Index],
 289                       L"PCI\\VEN_%04X&DEV_%04X&SUBSYS_%08X",
 290                       Device->PciConfig.VendorID,
 291                       Device->PciConfig.DeviceID,
 292                       (Device->PciConfig.u.type0.SubSystemID << 16) +
 293                       Device->PciConfig.u.type0.SubVendorID);
 294     Index++;
 295
 296     Index += swprintf(&Buffer[Index],
 297                       L"PCI\\VEN_%04X&DEV_%04X&CC_%02X%02X%02X",
 298                       Device->PciConfig.VendorID,
 299                       Device->PciConfig.DeviceID,
 300                       Device->PciConfig.BaseClass,
 301                       Device->PciConfig.SubClass,
 302                       Device->PciConfig.ProgIf);
 303     Index++;
 304
 305     Index += swprintf(&Buffer[Index],
 306                       L"PCI\\VEN_%04X&DEV_%04X&CC_%02X%02X",
 307                       Device->PciConfig.VendorID,
 308                       Device->PciConfig.DeviceID,
 309                       Device->PciConfig.BaseClass,
 310                       Device->PciConfig.SubClass);
 311     Index++;
 312
 313     Buffer[Index] = UNICODE_NULL;
 314
 315     BufferU.Length = BufferU.MaximumLength = (USHORT) Index * sizeof(WCHAR);
 316     BufferU.Buffer = Buffer;
 317
 318     return PciDuplicateUnicodeString(0, &BufferU, HardwareIDs);
 319 }
 320
 321
 322 NTSTATUS
 323 PciCreateCompatibleIDsString(PUNICODE_STRING CompatibleIDs,
 324                              PPCI_DEVICE Device)
 325 {
 326     WCHAR Buffer[256];
 327     UNICODE_STRING BufferU;
 328     ULONG Index;
 329
 330     Index = 0;
 331     Index += swprintf(&Buffer[Index],
 332                       L"PCI\\VEN_%04X&DEV_%04X&REV_%02X",
 333                       Device->PciConfig.VendorID,
 334                       Device->PciConfig.DeviceID,
 335                       Device->PciConfig.RevisionID);
 336     Index++;
 337
 338     Index += swprintf(&Buffer[Index],
 339                       L"PCI\\VEN_%04X&DEV_%04X",
 340                       Device->PciConfig.VendorID,
 341                       Device->PciConfig.DeviceID);
 342     Index++;
 343
 344     Index += swprintf(&Buffer[Index],
 345                       L"PCI\\VEN_%04X&CC_%02X%02X%02X",
 346                       Device->PciConfig.VendorID,
 347                       Device->PciConfig.BaseClass,
 348                       Device->PciConfig.SubClass,
 349                       Device->PciConfig.ProgIf);
 350     Index++;
 351
 352     Index += swprintf(&Buffer[Index],
 353                       L"PCI\\VEN_%04X&CC_%02X%02X",
 354                       Device->PciConfig.VendorID,
 355                       Device->PciConfig.BaseClass,
 356                       Device->PciConfig.SubClass);
 357     Index++;
 358
 359     Index += swprintf(&Buffer[Index],
 360                       L"PCI\\VEN_%04X",
 361                       Device->PciConfig.VendorID);
 362     Index++;
 363
 364     Index += swprintf(&Buffer[Index],
 365                       L"PCI\\CC_%02X%02X%02X",
 366                       Device->PciConfig.BaseClass,
 367                       Device->PciConfig.SubClass,
 368                       Device->PciConfig.ProgIf);
 369     Index++;
 370
 371     Index += swprintf(&Buffer[Index],
 372                       L"PCI\\CC_%02X%02X",
 373                       Device->PciConfig.BaseClass,
 374                       Device->PciConfig.SubClass);
 375     Index++;
 376
 377     Buffer[Index] = UNICODE_NULL;
 378
 379     BufferU.Length = BufferU.MaximumLength = (USHORT)Index * sizeof(WCHAR);
 380     BufferU.Buffer = Buffer;
 381
 382     return PciDuplicateUnicodeString(0, &BufferU, CompatibleIDs);
 383 }
 384
 385
 386 NTSTATUS
 387 PciCreateDeviceDescriptionString(PUNICODE_STRING DeviceDescription,
 388                                  PPCI_DEVICE Device)
 389 {
 390     PCWSTR Description;
 391
 392     switch (Device->PciConfig.BaseClass)
 393     {
 394         case PCI_CLASS_PRE_20:
 395             switch (Device->PciConfig.SubClass)
 396             {
 397                 case PCI_SUBCLASS_PRE_20_VGA:
 398                     Description = L"VGA device";
 399                     break;
 400
 401                 default:
 402                 case PCI_SUBCLASS_PRE_20_NON_VGA:
 403                     Description = L"PCI device";
 404                     break;
 405             }
 406             break;
 407
 408         case PCI_CLASS_MASS_STORAGE_CTLR:
 409             switch (Device->PciConfig.SubClass)
 410             {
 411                 case PCI_SUBCLASS_MSC_SCSI_BUS_CTLR:
 412                     Description = L"SCSI controller";
 413                     break;
 414
 415                 case PCI_SUBCLASS_MSC_IDE_CTLR:
 416                     Description = L"IDE controller";
 417                     break;
 418
 419                 case PCI_SUBCLASS_MSC_FLOPPY_CTLR:
 420                     Description = L"Floppy disk controller";
 421                     break;
 422
 423                 case PCI_SUBCLASS_MSC_IPI_CTLR:
 424                     Description = L"IPI controller";
 425                     break;
 426
 427                 case PCI_SUBCLASS_MSC_RAID_CTLR:
 428                     Description = L"RAID controller";
 429                     break;
 430
 431                 default:
 432                     Description = L"Mass storage controller";
 433                     break;
 434             }
 435             break;
 436
 437         case PCI_CLASS_NETWORK_CTLR:
 438             switch (Device->PciConfig.SubClass)
 439             {
 440                 case PCI_SUBCLASS_NET_ETHERNET_CTLR:
 441                     Description = L"Ethernet controller";
 442                     break;
 443
 444                 case PCI_SUBCLASS_NET_TOKEN_RING_CTLR:
 445                     Description = L"Token-Ring controller";
 446                     break;
 447
 448                 case PCI_SUBCLASS_NET_FDDI_CTLR:
 449                     Description = L"FDDI controller";
 450                     break;
 451
 452                 case PCI_SUBCLASS_NET_ATM_CTLR:
 453                     Description = L"ATM controller";
 454                     break;
 455
 456                 default:
 457                     Description = L"Network controller";
 458                     break;
 459             }
 460             break;
 461
 462         case PCI_CLASS_DISPLAY_CTLR:
 463             switch (Device->PciConfig.SubClass)
 464             {
 465                 case PCI_SUBCLASS_VID_VGA_CTLR:
 466                     Description = L"VGA display controller";
 467                     break;
 468
 469                 case PCI_SUBCLASS_VID_XGA_CTLR:
 470                     Description = L"XGA display controller";
 471                     break;
 472
 473                 case PCI_SUBCLASS_VID_3D_CTLR:
 474                     Description = L"Multimedia display controller";
 475                     break;
 476
 477                 default:
 478                     Description = L"Other display controller";
 479                     break;
 480             }
 481             break;
 482
 483         case PCI_CLASS_MULTIMEDIA_DEV:
 484             switch (Device->PciConfig.SubClass)
 485             {
 486                 case PCI_SUBCLASS_MM_VIDEO_DEV:
 487                     Description = L"Multimedia video device";
 488                     break;
 489
 490                 case PCI_SUBCLASS_MM_AUDIO_DEV:
 491                     Description = L"Multimedia audio device";
 492                     break;
 493
 494                 case PCI_SUBCLASS_MM_TELEPHONY_DEV:
 495                     Description = L"Multimedia telephony device";
 496                     break;
 497
 498                 default:
 499                     Description = L"Other multimedia device";
 500                     break;
 501             }
 502             break;
 503
 504         case PCI_CLASS_MEMORY_CTLR:
 505             switch (Device->PciConfig.SubClass)
 506             {
 507                 case PCI_SUBCLASS_MEM_RAM:
 508                     Description = L"PCI Memory";
 509                     break;
 510
 511                 case PCI_SUBCLASS_MEM_FLASH:
 512                     Description = L"PCI Flash Memory";
 513                     break;
 514
 515                 default:
 516                     Description = L"Other memory controller";
 517                     break;
 518             }
 519             break;
 520
 521         case PCI_CLASS_BRIDGE_DEV:
 522             switch (Device->PciConfig.SubClass)
 523             {
 524                 case PCI_SUBCLASS_BR_HOST:
 525                     Description = L"PCI-Host bridge";
 526                     break;
 527
 528                 case PCI_SUBCLASS_BR_ISA:
 529                     Description = L"PCI-ISA bridge";
 530                     break;
 531
 532                 case PCI_SUBCLASS_BR_EISA:
 533                     Description = L"PCI-EISA bridge";
 534                     break;
 535
 536                 case PCI_SUBCLASS_BR_MCA:
 537                     Description = L"PCI-Micro Channel bridge";
 538                     break;
 539
 540                 case PCI_SUBCLASS_BR_PCI_TO_PCI:
 541                     Description = L"PCI-PCI bridge";
 542                     break;
 543
 544                 case PCI_SUBCLASS_BR_PCMCIA:
 545                     Description = L"PCI-PCMCIA bridge";
 546                     break;
 547
 548                 case PCI_SUBCLASS_BR_NUBUS:
 549                     Description = L"PCI-NUBUS bridge";
 550                     break;
 551
 552                 case PCI_SUBCLASS_BR_CARDBUS:
 553                     Description = L"PCI-CARDBUS bridge";
 554                     break;
 555
 556                 default:
 557                     Description = L"Other bridge device";
 558                     break;
 559             }
 560             break;
 561
 562         case PCI_CLASS_SIMPLE_COMMS_CTLR:
 563             switch (Device->PciConfig.SubClass)
 564             {
 565
 566                 default:
 567                     Description = L"Communication device";
 568                     break;
 569             }
 570             break;
 571
 572         case PCI_CLASS_BASE_SYSTEM_DEV:
 573             switch (Device->PciConfig.SubClass)
 574             {
 575
 576                 default:
 577                     Description = L"System device";
 578                     break;
 579             }
 580             break;
 581
 582         case PCI_CLASS_INPUT_DEV:
 583             switch (Device->PciConfig.SubClass)
 584             {
 585
 586                 default:
 587                     Description = L"Input device";
 588                     break;
 589             }
 590             break;
 591
 592         case PCI_CLASS_DOCKING_STATION:
 593             switch (Device->PciConfig.SubClass)
 594             {
 595
 596                 default:
 597                     Description = L"Docking station";
 598                     break;
 599             }
 600             break;
 601
 602         case PCI_CLASS_PROCESSOR:
 603             switch (Device->PciConfig.SubClass)
 604             {
 605
 606                 default:
 607                     Description = L"Processor";
 608                     break;
 609             }
 610             break;
 611
 612         case PCI_CLASS_SERIAL_BUS_CTLR:
 613             switch (Device->PciConfig.SubClass)
 614             {
 615                 case PCI_SUBCLASS_SB_IEEE1394:
 616                     Description = L"FireWire controller";
 617                     break;
 618
 619                 case PCI_SUBCLASS_SB_ACCESS:
 620                     Description = L"ACCESS bus controller";
 621                     break;
 622
 623                 case PCI_SUBCLASS_SB_SSA:
 624                     Description = L"SSA controller";
 625                     break;
 626
 627                 case PCI_SUBCLASS_SB_USB:
 628                     Description = L"USB controller";
 629                     break;
 630
 631                 case PCI_SUBCLASS_SB_FIBRE_CHANNEL:
 632                     Description = L"Fibre Channel controller";
 633                     break;
 634
 635                 case PCI_SUBCLASS_SB_SMBUS:
 636                     Description = L"SMBus controller";
 637                     break;
 638
 639                 default:
 640                     Description = L"Other serial bus controller";
 641                     break;
 642             }
 643             break;
 644
 645         default:
 646             Description = L"Other PCI Device";
 647             break;
 648     }
 649
 650     return RtlCreateUnicodeString(DeviceDescription, Description) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
 651 }
 652
 653
 654 NTSTATUS
 655 PciCreateDeviceLocationString(PUNICODE_STRING DeviceLocation,
 656                               PPCI_DEVICE Device)
 657 {
 658     WCHAR Buffer[256];
 659
 660     swprintf(Buffer,
 661              L"PCI-Bus %lu, Device %u, Function %u",
 662              Device->BusNumber,
 663              Device->SlotNumber.u.bits.DeviceNumber,
 664              Device->SlotNumber.u.bits.FunctionNumber);
 665
 666     return RtlCreateUnicodeString(DeviceLocation, Buffer) ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
 667 }
 668
 669 NTSTATUS
 670 PciDuplicateUnicodeString(
 671     IN ULONG Flags,
 672     IN PCUNICODE_STRING SourceString,
 673     OUT PUNICODE_STRING DestinationString)
 674 {
 675     if (SourceString == NULL ||
 676         DestinationString == NULL ||
 677         SourceString->Length > SourceString->MaximumLength ||
 678         (SourceString->Length == 0 && SourceString->MaximumLength > 0 && SourceString->Buffer == NULL) ||
 679         Flags == RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING ||
 680         Flags >= 4)
 681     {
 682         return STATUS_INVALID_PARAMETER;
 683     }
 684
 685     if ((SourceString->Length == 0) &&
 686         (Flags != (RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE |
 687                    RTL_DUPLICATE_UNICODE_STRING_ALLOCATE_NULL_STRING)))
 688     {
 689         DestinationString->Length = 0;
 690         DestinationString->MaximumLength = 0;
 691         DestinationString->Buffer = NULL;
 692     }
 693     else
 694     {
 695         USHORT DestMaxLength = SourceString->Length;
 696
 697         if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
 698             DestMaxLength += sizeof(UNICODE_NULL);
 699
 700         DestinationString->Buffer = ExAllocatePoolWithTag(PagedPool, DestMaxLength, TAG_PCI);
 701         if (DestinationString->Buffer == NULL)
 702             return STATUS_NO_MEMORY;
 703
 704         RtlCopyMemory(DestinationString->Buffer, SourceString->Buffer, SourceString->Length);
 705         DestinationString->Length = SourceString->Length;
 706         DestinationString->MaximumLength = DestMaxLength;
 707
 708         if (Flags & RTL_DUPLICATE_UNICODE_STRING_NULL_TERMINATE)
 709             DestinationString->Buffer[DestinationString->Length / sizeof(WCHAR)] = 0;
 710     }
 711
 712     return STATUS_SUCCESS;
 713 }
 714
 715 /* EOF */