ntoskrnl/io/pnpmgr/pnpres.c

   1 /*
   2  * PROJECT:         ReactOS Kernel
   3  * COPYRIGHT:       GPL - See COPYING in the top level directory
   4  * FILE:            ntoskrnl/io/pnpmgr/pnpres.c
   5  * PURPOSE:         Resource handling code
   6  * PROGRAMMERS:     Cameron Gutman (cameron.gutman@reactos.org)
   7  *                  ReactOS Portable Systems Group
   8  */
   9
  10 #include <ntoskrnl.h>
  11
  12 #define NDEBUG
  13 #include <debug.h>
  14
  15 NTSTATUS
  16 IopDetectResourceConflict(
  17    IN PCM_RESOURCE_LIST ResourceList,
  18    IN BOOLEAN Silent,
  19    OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDescriptor);
  20
  21 ULONG
  22 NTAPI
  23 IopCalculateResourceListSize(
  24    IN PCM_RESOURCE_LIST ResourceList)
  25 {
  26    ULONG Size, i, j;
  27    PCM_PARTIAL_RESOURCE_LIST pPartialResourceList;
  28
  29    Size = FIELD_OFFSET(CM_RESOURCE_LIST, List);
  30    for (i = 0; i < ResourceList->Count; i++)
  31    {
  32       pPartialResourceList = &ResourceList->List[i].PartialResourceList;
  33       Size += FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList.PartialDescriptors) +
  34               pPartialResourceList->Count * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
  35       for (j = 0; j < pPartialResourceList->Count; j++)
  36       {
  37          if (pPartialResourceList->PartialDescriptors[j].Type == CmResourceTypeDeviceSpecific)
  38              Size += pPartialResourceList->PartialDescriptors[j].u.DeviceSpecificData.DataSize;
  39       }
  40    }
  41
  42    return Size;
  43 }
  44
  45 static
  46 BOOLEAN
  47 IopCheckDescriptorForConflict(PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc, OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDescriptor)
  48 {
  49    CM_RESOURCE_LIST CmList;
  50    NTSTATUS Status;
  51
  52    CmList.Count = 1;
  53    CmList.List[0].InterfaceType = InterfaceTypeUndefined;
  54    CmList.List[0].BusNumber = 0;
  55    CmList.List[0].PartialResourceList.Version = 1;
  56    CmList.List[0].PartialResourceList.Revision = 1;
  57    CmList.List[0].PartialResourceList.Count = 1;
  58    CmList.List[0].PartialResourceList.PartialDescriptors[0] = *CmDesc;
  59
  60    Status = IopDetectResourceConflict(&CmList, TRUE, ConflictingDescriptor);
  61    if (Status == STATUS_CONFLICTING_ADDRESSES)
  62        return TRUE;
  63
  64    return FALSE;
  65 }
  66
  67 static
  68 BOOLEAN
  69 IopFindBusNumberResource(
  70    IN PIO_RESOURCE_DESCRIPTOR IoDesc,
  71    OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
  72 {
  73    ULONG Start;
  74    CM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDesc;
  75
  76    ASSERT(IoDesc->Type == CmDesc->Type);
  77    ASSERT(IoDesc->Type == CmResourceTypeBusNumber);
  78
  79    for (Start = IoDesc->u.BusNumber.MinBusNumber;
  80         Start < IoDesc->u.BusNumber.MaxBusNumber;
  81         Start++)
  82    {
  83         CmDesc->u.BusNumber.Length = IoDesc->u.BusNumber.Length;
  84         CmDesc->u.BusNumber.Start = Start;
  85
  86         if (IopCheckDescriptorForConflict(CmDesc, &ConflictingDesc))
  87         {
  88             Start += ConflictingDesc.u.BusNumber.Start + ConflictingDesc.u.BusNumber.Length;
  89         }
  90         else
  91         {
  92             return TRUE;
  93         }
  94    }
  95
  96    return FALSE;
  97 }
  98
  99 static
 100 BOOLEAN
 101 IopFindMemoryResource(
 102    IN PIO_RESOURCE_DESCRIPTOR IoDesc,
 103    OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
 104 {
 105    ULONGLONG Start;
 106    CM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDesc;
 107
 108    ASSERT(IoDesc->Type == CmDesc->Type);
 109    ASSERT(IoDesc->Type == CmResourceTypeMemory);
 110
 111    for (Start = IoDesc->u.Memory.MinimumAddress.QuadPart;
 112         Start < IoDesc->u.Memory.MaximumAddress.QuadPart;
 113         Start++)
 114    {
 115         CmDesc->u.Memory.Length = IoDesc->u.Memory.Length;
 116         CmDesc->u.Memory.Start.QuadPart = Start;
 117
 118         if (IopCheckDescriptorForConflict(CmDesc, &ConflictingDesc))
 119         {
 120             Start += ConflictingDesc.u.Memory.Start.QuadPart + ConflictingDesc.u.Memory.Length;
 121         }
 122         else
 123         {
 124             return TRUE;
 125         }
 126    }
 127
 128    return FALSE;
 129 }
 130
 131 static
 132 BOOLEAN
 133 IopFindPortResource(
 134    IN PIO_RESOURCE_DESCRIPTOR IoDesc,
 135    OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
 136 {
 137    ULONGLONG Start;
 138    CM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDesc;
 139
 140    ASSERT(IoDesc->Type == CmDesc->Type);
 141    ASSERT(IoDesc->Type == CmResourceTypePort);
 142
 143    for (Start = IoDesc->u.Port.MinimumAddress.QuadPart;
 144         Start < IoDesc->u.Port.MaximumAddress.QuadPart;
 145         Start++)
 146    {
 147         CmDesc->u.Port.Length = IoDesc->u.Port.Length;
 148         CmDesc->u.Port.Start.QuadPart = Start;
 149
 150         if (IopCheckDescriptorForConflict(CmDesc, &ConflictingDesc))
 151         {
 152             Start += ConflictingDesc.u.Port.Start.QuadPart + ConflictingDesc.u.Port.Length;
 153         }
 154         else
 155         {
 156             return TRUE;
 157         }
 158    }
 159
 160    return FALSE;
 161 }
 162
 163 static
 164 BOOLEAN
 165 IopFindDmaResource(
 166    IN PIO_RESOURCE_DESCRIPTOR IoDesc,
 167    OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
 168 {
 169    ULONG Channel;
 170
 171    ASSERT(IoDesc->Type == CmDesc->Type);
 172    ASSERT(IoDesc->Type == CmResourceTypeDma);
 173
 174    for (Channel = IoDesc->u.Dma.MinimumChannel;
 175         Channel < IoDesc->u.Dma.MaximumChannel;
 176         Channel++)
 177    {
 178         CmDesc->u.Dma.Channel = Channel;
 179         CmDesc->u.Dma.Port = 0;
 180
 181         if (!IopCheckDescriptorForConflict(CmDesc, NULL))
 182             return TRUE;
 183    }
 184
 185    return FALSE;
 186 }
 187
 188 static
 189 BOOLEAN
 190 IopFindInterruptResource(
 191    IN PIO_RESOURCE_DESCRIPTOR IoDesc,
 192    OUT PCM_PARTIAL_RESOURCE_DESCRIPTOR CmDesc)
 193 {
 194    ULONG Vector;
 195
 196    ASSERT(IoDesc->Type == CmDesc->Type);
 197    ASSERT(IoDesc->Type == CmResourceTypeInterrupt);
 198
 199    for (Vector = IoDesc->u.Interrupt.MinimumVector;
 200         Vector < IoDesc->u.Interrupt.MaximumVector;
 201         Vector++)
 202    {
 203         CmDesc->u.Interrupt.Vector = Vector;
 204         CmDesc->u.Interrupt.Level = Vector;
 205         CmDesc->u.Interrupt.Affinity = (KAFFINITY)-1;
 206
 207         if (!IopCheckDescriptorForConflict(CmDesc, NULL))
 208             return TRUE;
 209    }
 210
 211    return FALSE;
 212 }
 213
 214 static
 215 NTSTATUS
 216 IopCreateResourceListFromRequirements(
 217    IN PIO_RESOURCE_REQUIREMENTS_LIST RequirementsList,
 218    OUT PCM_RESOURCE_LIST *ResourceList)
 219 {
 220    ULONG i, ii, Size;
 221    PCM_PARTIAL_RESOURCE_DESCRIPTOR ResDesc;
 222
 223    Size = FIELD_OFFSET(CM_RESOURCE_LIST, List);
 224    for (i = 0; i < RequirementsList->AlternativeLists; i++)
 225    {
 226       PIO_RESOURCE_LIST ResList = &RequirementsList->List[i];
 227       Size += FIELD_OFFSET(CM_FULL_RESOURCE_DESCRIPTOR, PartialResourceList.PartialDescriptors)
 228         + ResList->Count * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
 229    }
 230
 231    *ResourceList = ExAllocatePool(PagedPool, Size);
 232    if (!*ResourceList)
 233        return STATUS_INSUFFICIENT_RESOURCES;
 234
 235    (*ResourceList)->Count = 1;
 236    (*ResourceList)->List[0].BusNumber = RequirementsList->BusNumber;
 237    (*ResourceList)->List[0].InterfaceType = RequirementsList->InterfaceType;
 238    (*ResourceList)->List[0].PartialResourceList.Version = 1;
 239    (*ResourceList)->List[0].PartialResourceList.Revision = 1;
 240    (*ResourceList)->List[0].PartialResourceList.Count = 0;
 241
 242    ResDesc = &(*ResourceList)->List[0].PartialResourceList.PartialDescriptors[0];
 243
 244    for (i = 0; i < RequirementsList->AlternativeLists; i++)
 245    {
 246       PIO_RESOURCE_LIST ResList = &RequirementsList->List[i];
 247       for (ii = 0; ii < ResList->Count; ii++)
 248       {
 249          PIO_RESOURCE_DESCRIPTOR ReqDesc = &ResList->Descriptors[ii];
 250
 251          /* FIXME: Handle alternate ranges */
 252          if (ReqDesc->Option == IO_RESOURCE_ALTERNATIVE)
 253              continue;
 254
 255          ResDesc->Type = ReqDesc->Type;
 256          ResDesc->Flags = ReqDesc->Flags;
 257          ResDesc->ShareDisposition = ReqDesc->ShareDisposition;
 258
 259          switch (ReqDesc->Type)
 260          {
 261             case CmResourceTypeInterrupt:
 262               if (!IopFindInterruptResource(ReqDesc, ResDesc))
 263               {
 264                   DPRINT1("Failed to find an available interrupt resource (0x%x to 0x%x)\n",
 265                            ReqDesc->u.Interrupt.MinimumVector, ReqDesc->u.Interrupt.MaximumVector);
 266
 267                   if (ReqDesc->Option == 0)
 268                   {
 269                       ExFreePool(*ResourceList);
 270                       return STATUS_CONFLICTING_ADDRESSES;
 271                   }
 272               }
 273               break;
 274
 275             case CmResourceTypePort:
 276               if (!IopFindPortResource(ReqDesc, ResDesc))
 277               {
 278                   DPRINT1("Failed to find an available port resource (0x%x to 0x%x length: 0x%x)\n",
 279                           ReqDesc->u.Port.MinimumAddress.QuadPart, ReqDesc->u.Port.MaximumAddress.QuadPart,
 280                           ReqDesc->u.Port.Length);
 281
 282                   if (ReqDesc->Option == 0)
 283                   {
 284                       ExFreePool(*ResourceList);
 285                       return STATUS_CONFLICTING_ADDRESSES;
 286                   }
 287               }
 288               break;
 289
 290             case CmResourceTypeMemory:
 291               if (!IopFindMemoryResource(ReqDesc, ResDesc))
 292               {
 293                   DPRINT1("Failed to find an available memory resource (0x%x to 0x%x length: 0x%x)\n",
 294                           ReqDesc->u.Memory.MinimumAddress.QuadPart, ReqDesc->u.Memory.MaximumAddress.QuadPart,
 295                           ReqDesc->u.Memory.Length);
 296
 297                   if (ReqDesc->Option == 0)
 298                   {
 299                       ExFreePool(*ResourceList);
 300                       return STATUS_CONFLICTING_ADDRESSES;
 301                   }
 302               }
 303               break;
 304
 305             case CmResourceTypeBusNumber:
 306               if (!IopFindBusNumberResource(ReqDesc, ResDesc))
 307               {
 308                   DPRINT1("Failed to find an available bus number resource (0x%x to 0x%x length: 0x%x)\n",
 309                           ReqDesc->u.BusNumber.MinBusNumber, ReqDesc->u.BusNumber.MaxBusNumber,
 310                           ReqDesc->u.BusNumber.Length);
 311
 312                   if (ReqDesc->Option == 0)
 313                   {
 314                       ExFreePool(*ResourceList);
 315                       return STATUS_CONFLICTING_ADDRESSES;
 316                   }
 317               }
 318               break;
 319
 320             case CmResourceTypeDma:
 321               if (!IopFindDmaResource(ReqDesc, ResDesc))
 322               {
 323                   DPRINT1("Failed to find an available dma resource (0x%x to 0x%x)\n",
 324                           ReqDesc->u.Dma.MinimumChannel, ReqDesc->u.Dma.MaximumChannel);
 325
 326                   if (ReqDesc->Option == 0)
 327                   {
 328                       ExFreePool(*ResourceList);
 329                       return STATUS_CONFLICTING_ADDRESSES;
 330                   }
 331               }
 332               break;
 333
 334             default:
 335               DPRINT1("Unsupported resource type: %x\n", ReqDesc->Type);
 336               break;
 337          }
 338
 339          (*ResourceList)->List[0].PartialResourceList.Count++;
 340          ResDesc++;
 341       }
 342    }
 343
 344    return STATUS_SUCCESS;
 345 }
 346
 347 static
 348 BOOLEAN
 349 IopCheckResourceDescriptor(
 350    IN PCM_PARTIAL_RESOURCE_DESCRIPTOR ResDesc,
 351    IN PCM_RESOURCE_LIST ResourceList,
 352    IN BOOLEAN Silent,
 353    OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDescriptor)
 354 {
 355    ULONG i, ii;
 356    BOOLEAN Result = FALSE;
 357
 358    if (ResDesc->ShareDisposition == CmResourceShareShared)
 359        return FALSE;
 360
 361    for (i = 0; i < ResourceList->Count; i++)
 362    {
 363       PCM_PARTIAL_RESOURCE_LIST ResList = &ResourceList->List[i].PartialResourceList;
 364       for (ii = 0; ii < ResList->Count; ii++)
 365       {
 366          PCM_PARTIAL_RESOURCE_DESCRIPTOR ResDesc2 = &ResList->PartialDescriptors[ii];
 367
 368          /* We don't care about shared resources */
 369          if (ResDesc->ShareDisposition == CmResourceShareShared &&
 370              ResDesc2->ShareDisposition == CmResourceShareShared)
 371              continue;
 372
 373          /* Make sure we're comparing the same types */
 374          if (ResDesc->Type != ResDesc2->Type)
 375              continue;
 376
 377          switch (ResDesc->Type)
 378          {
 379              case CmResourceTypeMemory:
 380                  if ((ResDesc->u.Memory.Start.QuadPart < ResDesc2->u.Memory.Start.QuadPart &&
 381                       ResDesc->u.Memory.Start.QuadPart + ResDesc->u.Memory.Length >
 382                       ResDesc2->u.Memory.Start.QuadPart) || (ResDesc2->u.Memory.Start.QuadPart <
 383                       ResDesc->u.Memory.Start.QuadPart && ResDesc2->u.Memory.Start.QuadPart +
 384                       ResDesc2->u.Memory.Length > ResDesc->u.Memory.Start.QuadPart))
 385                  {
 386                       if (!Silent)
 387                       {
 388                           DPRINT1("Resource conflict: Memory (0x%x to 0x%x vs. 0x%x to 0x%x)\n",
 389                                   ResDesc->u.Memory.Start.QuadPart, ResDesc->u.Memory.Start.QuadPart +
 390                                   ResDesc->u.Memory.Length, ResDesc2->u.Memory.Start.QuadPart,
 391                                   ResDesc2->u.Memory.Start.QuadPart + ResDesc2->u.Memory.Length);
 392                       }
 393
 394                       Result = TRUE;
 395
 396                       goto ByeBye;
 397                  }
 398                  break;
 399
 400              case CmResourceTypePort:
 401                  if ((ResDesc->u.Port.Start.QuadPart < ResDesc2->u.Port.Start.QuadPart &&
 402                       ResDesc->u.Port.Start.QuadPart + ResDesc->u.Port.Length >
 403                       ResDesc2->u.Port.Start.QuadPart) || (ResDesc2->u.Port.Start.QuadPart <
 404                       ResDesc->u.Port.Start.QuadPart && ResDesc2->u.Port.Start.QuadPart +
 405                       ResDesc2->u.Port.Length > ResDesc->u.Port.Start.QuadPart))
 406                  {
 407                       if (!Silent)
 408                       {
 409                           DPRINT1("Resource conflict: Port (0x%x to 0x%x vs. 0x%x to 0x%x)\n",
 410                                   ResDesc->u.Port.Start.QuadPart, ResDesc->u.Port.Start.QuadPart +
 411                                   ResDesc->u.Port.Length, ResDesc2->u.Port.Start.QuadPart,
 412                                   ResDesc2->u.Port.Start.QuadPart + ResDesc2->u.Port.Length);
 413                       }
 414
 415                       Result = TRUE;
 416
 417                       goto ByeBye;
 418                  }
 419                  break;
 420
 421              case CmResourceTypeInterrupt:
 422                  if (ResDesc->u.Interrupt.Vector == ResDesc2->u.Interrupt.Vector)
 423                  {
 424                       if (!Silent)
 425                       {
 426                           DPRINT1("Resource conflict: IRQ (0x%x 0x%x vs. 0x%x 0x%x)\n",
 427                                   ResDesc->u.Interrupt.Vector, ResDesc->u.Interrupt.Level,
 428                                   ResDesc2->u.Interrupt.Vector, ResDesc2->u.Interrupt.Level);
 429                       }
 430
 431                       Result = TRUE;
 432
 433                       goto ByeBye;
 434                  }
 435                  break;
 436
 437              case CmResourceTypeBusNumber:
 438                  if ((ResDesc->u.BusNumber.Start < ResDesc2->u.BusNumber.Start &&
 439                       ResDesc->u.BusNumber.Start + ResDesc->u.BusNumber.Length >
 440                       ResDesc2->u.BusNumber.Start) || (ResDesc2->u.BusNumber.Start <
 441                       ResDesc->u.BusNumber.Start && ResDesc2->u.BusNumber.Start +
 442                       ResDesc2->u.BusNumber.Length > ResDesc->u.BusNumber.Start))
 443                  {
 444                       if (!Silent)
 445                       {
 446                           DPRINT1("Resource conflict: Bus number (0x%x to 0x%x vs. 0x%x to 0x%x)\n",
 447                                   ResDesc->u.BusNumber.Start, ResDesc->u.BusNumber.Start +
 448                                   ResDesc->u.BusNumber.Length, ResDesc2->u.BusNumber.Start,
 449                                   ResDesc2->u.BusNumber.Start + ResDesc2->u.BusNumber.Length);
 450                       }
 451
 452                       Result = TRUE;
 453
 454                       goto ByeBye;
 455                  }
 456                  break;
 457
 458              case CmResourceTypeDma:
 459                  if (ResDesc->u.Dma.Channel == ResDesc2->u.Dma.Channel)
 460                  {
 461                      if (!Silent)
 462                      {
 463                          DPRINT1("Resource conflict: Dma (0x%x 0x%x vs. 0x%x 0x%x)\n",
 464                                  ResDesc->u.Dma.Channel, ResDesc->u.Dma.Port,
 465                                  ResDesc2->u.Dma.Channel, ResDesc2->u.Dma.Port);
 466                      }
 467
 468                      Result = TRUE;
 469
 470                      goto ByeBye;
 471                  }
 472                  break;
 473          }
 474       }
 475    }
 476
 477 ByeBye:
 478
 479    if (Result && ConflictingDescriptor)
 480    {
 481        RtlCopyMemory(ConflictingDescriptor,
 482                      ResDesc,
 483                      sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
 484    }
 485
 486    return Result;
 487 }
 488
 489 static
 490 NTSTATUS
 491 IopUpdateControlKeyWithResources(IN PDEVICE_NODE DeviceNode)
 492 {
 493    UNICODE_STRING EnumRoot = RTL_CONSTANT_STRING(ENUM_ROOT);
 494    UNICODE_STRING Control = RTL_CONSTANT_STRING(L"Control");
 495    UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"AllocConfig");
 496    HANDLE EnumKey, InstanceKey, ControlKey;
 497    NTSTATUS Status;
 498    OBJECT_ATTRIBUTES ObjectAttributes;
 499
 500    /* Open the Enum key */
 501    Status = IopOpenRegistryKeyEx(&EnumKey, NULL, &EnumRoot, KEY_ENUMERATE_SUB_KEYS);
 502    if (!NT_SUCCESS(Status))
 503        return Status;
 504
 505    /* Open the instance key (eg. Root\PNP0A03) */
 506    Status = IopOpenRegistryKeyEx(&InstanceKey, EnumKey, &DeviceNode->InstancePath, KEY_ENUMERATE_SUB_KEYS);
 507    ZwClose(EnumKey);
 508
 509    if (!NT_SUCCESS(Status))
 510        return Status;
 511
 512    /* Create/Open the Control key */
 513    InitializeObjectAttributes(&ObjectAttributes,
 514                               &Control,
 515                               OBJ_CASE_INSENSITIVE,
 516                               InstanceKey,
 517                               NULL);
 518    Status = ZwCreateKey(&ControlKey,
 519                         KEY_SET_VALUE,
 520                         &ObjectAttributes,
 521                         0,
 522                         NULL,
 523                         REG_OPTION_VOLATILE,
 524                         NULL);
 525    ZwClose(InstanceKey);
 526
 527    if (!NT_SUCCESS(Status))
 528        return Status;
 529
 530    /* Write the resource list */
 531    Status = ZwSetValueKey(ControlKey,
 532                           &ValueName,
 533                           0,
 534                           REG_RESOURCE_LIST,
 535                           DeviceNode->ResourceList,
 536                           IopCalculateResourceListSize(DeviceNode->ResourceList));
 537    ZwClose(ControlKey);
 538
 539    if (!NT_SUCCESS(Status))
 540        return Status;
 541
 542    return STATUS_SUCCESS;
 543 }
 544
 545 static
 546 NTSTATUS
 547 IopFilterResourceRequirements(IN PDEVICE_NODE DeviceNode)
 548 {
 549    IO_STACK_LOCATION Stack;
 550    IO_STATUS_BLOCK IoStatusBlock;
 551    NTSTATUS Status;
 552
 553    DPRINT("Sending IRP_MN_FILTER_RESOURCE_REQUIREMENTS to device stack\n");
 554
 555    Stack.Parameters.FilterResourceRequirements.IoResourceRequirementList = DeviceNode->ResourceRequirements;
 556    Status = IopInitiatePnpIrp(
 557       DeviceNode->PhysicalDeviceObject,
 558       &IoStatusBlock,
 559       IRP_MN_FILTER_RESOURCE_REQUIREMENTS,
 560       &Stack);
 561    if (!NT_SUCCESS(Status) && Status != STATUS_NOT_SUPPORTED)
 562    {
 563       DPRINT("IopInitiatePnpIrp(IRP_MN_FILTER_RESOURCE_REQUIREMENTS) failed\n");
 564       return Status;
 565    }
 566    else if (NT_SUCCESS(Status))
 567    {
 568       DeviceNode->ResourceRequirements = (PIO_RESOURCE_REQUIREMENTS_LIST)IoStatusBlock.Information;
 569    }
 570
 571    return STATUS_SUCCESS;
 572 }
 573
 574
 575 NTSTATUS
 576 IopUpdateResourceMap(IN PDEVICE_NODE DeviceNode, PWCHAR Level1Key, PWCHAR Level2Key)
 577 {
 578   NTSTATUS Status;
 579   ULONG Disposition;
 580   HANDLE PnpMgrLevel1, PnpMgrLevel2, ResourceMapKey;
 581   UNICODE_STRING KeyName;
 582   OBJECT_ATTRIBUTES ObjectAttributes;
 583
 584   RtlInitUnicodeString(&KeyName,
 585                        L"\\Registry\\Machine\\HARDWARE\\RESOURCEMAP");
 586   InitializeObjectAttributes(&ObjectAttributes,
 587                              &KeyName,
 588                              OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
 589                              0,
 590                              NULL);
 591   Status = ZwCreateKey(&ResourceMapKey,
 592                        KEY_ALL_ACCESS,
 593                        &ObjectAttributes,
 594                        0,
 595                        NULL,
 596                        REG_OPTION_VOLATILE,
 597                        &Disposition);
 598   if (!NT_SUCCESS(Status))
 599       return Status;
 600
 601   RtlInitUnicodeString(&KeyName, Level1Key);
 602   InitializeObjectAttributes(&ObjectAttributes,
 603                              &KeyName,
 604                              OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
 605                              ResourceMapKey,
 606                              NULL);
 607   Status = ZwCreateKey(&PnpMgrLevel1,
 608                        KEY_ALL_ACCESS,
 609                        &ObjectAttributes,
 610                        0,
 611                        NULL,
 612                        REG_OPTION_VOLATILE,
 613                        &Disposition);
 614   ZwClose(ResourceMapKey);
 615   if (!NT_SUCCESS(Status))
 616       return Status;
 617
 618   RtlInitUnicodeString(&KeyName, Level2Key);
 619   InitializeObjectAttributes(&ObjectAttributes,
 620                              &KeyName,
 621                              OBJ_CASE_INSENSITIVE | OBJ_OPENIF,
 622                              PnpMgrLevel1,
 623                              NULL);
 624   Status = ZwCreateKey(&PnpMgrLevel2,
 625                        KEY_ALL_ACCESS,
 626                        &ObjectAttributes,
 627                        0,
 628                        NULL,
 629                        REG_OPTION_VOLATILE,
 630                        &Disposition);
 631   ZwClose(PnpMgrLevel1);
 632   if (!NT_SUCCESS(Status))
 633       return Status;
 634
 635   if (DeviceNode->ResourceList)
 636   {
 637       WCHAR NameBuff[256];
 638       UNICODE_STRING NameU;
 639       UNICODE_STRING Suffix;
 640       ULONG OldLength;
 641
 642       ASSERT(DeviceNode->ResourceListTranslated);
 643
 644       NameU.Buffer = NameBuff;
 645       NameU.Length = 0;
 646       NameU.MaximumLength = 256 * sizeof(WCHAR);
 647
 648       Status = IoGetDeviceProperty(DeviceNode->PhysicalDeviceObject,
 649                                    DevicePropertyPhysicalDeviceObjectName,
 650                                    NameU.MaximumLength,
 651                                    NameU.Buffer,
 652                                    &OldLength);
 653       ASSERT(Status == STATUS_SUCCESS);
 654
 655       NameU.Length = (USHORT)OldLength;
 656
 657       RtlInitUnicodeString(&Suffix, L".Raw");
 658       RtlAppendUnicodeStringToString(&NameU, &Suffix);
 659
 660       Status = ZwSetValueKey(PnpMgrLevel2,
 661                              &NameU,
 662                              0,
 663                              REG_RESOURCE_LIST,
 664                              DeviceNode->ResourceList,
 665                              IopCalculateResourceListSize(DeviceNode->ResourceList));
 666       if (!NT_SUCCESS(Status))
 667       {
 668           ZwClose(PnpMgrLevel2);
 669           return Status;
 670       }
 671
 672       /* "Remove" the suffix by setting the length back to what it used to be */
 673       NameU.Length = (USHORT)OldLength;
 674
 675       RtlInitUnicodeString(&Suffix, L".Translated");
 676       RtlAppendUnicodeStringToString(&NameU, &Suffix);
 677
 678       Status = ZwSetValueKey(PnpMgrLevel2,
 679                              &NameU,
 680                              0,
 681                              REG_RESOURCE_LIST,
 682                              DeviceNode->ResourceListTranslated,
 683                              IopCalculateResourceListSize(DeviceNode->ResourceListTranslated));
 684       ZwClose(PnpMgrLevel2);
 685       if (!NT_SUCCESS(Status))
 686           return Status;
 687   }
 688   else
 689   {
 690       ZwClose(PnpMgrLevel2);
 691   }
 692
 693   return STATUS_SUCCESS;
 694 }
 695
 696 NTSTATUS
 697 IopUpdateResourceMapForPnPDevice(IN PDEVICE_NODE DeviceNode)
 698 {
 699   return IopUpdateResourceMap(DeviceNode, L"PnP Manager", L"PnpManager");
 700 }
 701
 702 static
 703 NTSTATUS
 704 IopTranslateDeviceResources(
 705    IN PDEVICE_NODE DeviceNode)
 706 {
 707    PCM_PARTIAL_RESOURCE_LIST pPartialResourceList;
 708    PCM_PARTIAL_RESOURCE_DESCRIPTOR DescriptorRaw, DescriptorTranslated;
 709    ULONG i, j, ListSize;
 710    NTSTATUS Status;
 711
 712    if (!DeviceNode->ResourceList)
 713    {
 714       DeviceNode->ResourceListTranslated = NULL;
 715       return STATUS_SUCCESS;
 716    }
 717
 718    /* That's easy to translate a resource list. Just copy the
 719     * untranslated one and change few fields in the copy
 720     */
 721    ListSize = IopCalculateResourceListSize(DeviceNode->ResourceList);
 722
 723    DeviceNode->ResourceListTranslated = ExAllocatePool(PagedPool, ListSize);
 724    if (!DeviceNode->ResourceListTranslated)
 725    {
 726       Status =STATUS_NO_MEMORY;
 727       goto cleanup;
 728    }
 729    RtlCopyMemory(DeviceNode->ResourceListTranslated, DeviceNode->ResourceList, ListSize);
 730
 731    for (i = 0; i < DeviceNode->ResourceList->Count; i++)
 732    {
 733       pPartialResourceList = &DeviceNode->ResourceList->List[i].PartialResourceList;
 734       for (j = 0; j < pPartialResourceList->Count; j++)
 735       {
 736          DescriptorRaw = &pPartialResourceList->PartialDescriptors[j];
 737          DescriptorTranslated = &DeviceNode->ResourceListTranslated->List[i].PartialResourceList.PartialDescriptors[j];
 738          switch (DescriptorRaw->Type)
 739          {
 740             case CmResourceTypePort:
 741             {
 742                ULONG AddressSpace = 1; /* IO space */
 743                if (!HalTranslateBusAddress(
 744                   DeviceNode->ResourceList->List[i].InterfaceType,
 745                   DeviceNode->ResourceList->List[i].BusNumber,
 746                   DescriptorRaw->u.Port.Start,
 747                   &AddressSpace,
 748                   &DescriptorTranslated->u.Port.Start))
 749                {
 750                   Status = STATUS_UNSUCCESSFUL;
 751                   goto cleanup;
 752                }
 753                break;
 754             }
 755             case CmResourceTypeInterrupt:
 756             {
 757                DescriptorTranslated->u.Interrupt.Vector = HalGetInterruptVector(
 758                   DeviceNode->ResourceList->List[i].InterfaceType,
 759                   DeviceNode->ResourceList->List[i].BusNumber,
 760                   DescriptorRaw->u.Interrupt.Level,
 761                   DescriptorRaw->u.Interrupt.Vector,
 762                   (PKIRQL)&DescriptorTranslated->u.Interrupt.Level,
 763                   &DescriptorRaw->u.Interrupt.Affinity);
 764                break;
 765             }
 766             case CmResourceTypeMemory:
 767             {
 768                ULONG AddressSpace = 0; /* Memory space */
 769                if (!HalTranslateBusAddress(
 770                   DeviceNode->ResourceList->List[i].InterfaceType,
 771                   DeviceNode->ResourceList->List[i].BusNumber,
 772                   DescriptorRaw->u.Memory.Start,
 773                   &AddressSpace,
 774                   &DescriptorTranslated->u.Memory.Start))
 775                {
 776                   Status = STATUS_UNSUCCESSFUL;
 777                   goto cleanup;
 778                }
 779             }
 780
 781             case CmResourceTypeDma:
 782             case CmResourceTypeBusNumber:
 783             case CmResourceTypeDeviceSpecific:
 784                /* Nothing to do */
 785                break;
 786             default:
 787                DPRINT1("Unknown resource descriptor type 0x%x\n", DescriptorRaw->Type);
 788                Status = STATUS_NOT_IMPLEMENTED;
 789                goto cleanup;
 790          }
 791       }
 792    }
 793    return STATUS_SUCCESS;
 794
 795 cleanup:
 796    /* Yes! Also delete ResourceList because ResourceList and
 797     * ResourceListTranslated should be a pair! */
 798    ExFreePool(DeviceNode->ResourceList);
 799    DeviceNode->ResourceList = NULL;
 800    if (DeviceNode->ResourceListTranslated)
 801    {
 802       ExFreePool(DeviceNode->ResourceListTranslated);
 803       DeviceNode->ResourceList = NULL;
 804    }
 805    return Status;
 806 }
 807
 808 NTSTATUS
 809 NTAPI
 810 IopAssignDeviceResources(
 811    IN PDEVICE_NODE DeviceNode)
 812 {
 813    NTSTATUS Status;
 814    ULONG ListSize;
 815
 816    IopDeviceNodeSetFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
 817
 818    Status = IopFilterResourceRequirements(DeviceNode);
 819    if (!NT_SUCCESS(Status))
 820        goto ByeBye;
 821
 822    if (!DeviceNode->BootResources && !DeviceNode->ResourceRequirements)
 823    {
 824       DeviceNode->Flags |= DNF_NO_RESOURCE_REQUIRED;
 825       DeviceNode->Flags &= ~DNF_ASSIGNING_RESOURCES;
 826
 827       /* No resource needed for this device */
 828       DeviceNode->ResourceList = NULL;
 829       DeviceNode->ResourceListTranslated = NULL;
 830
 831       return STATUS_SUCCESS;
 832    }
 833
 834    /* Fill DeviceNode->ResourceList
 835     * FIXME: the PnP arbiter should go there!
 836     * Actually, use the BootResources if provided, else the resource requirements
 837     */
 838
 839    if (DeviceNode->BootResources)
 840    {
 841       ListSize = IopCalculateResourceListSize(DeviceNode->BootResources);
 842
 843       DeviceNode->ResourceList = ExAllocatePool(PagedPool, ListSize);
 844       if (!DeviceNode->ResourceList)
 845       {
 846          Status = STATUS_NO_MEMORY;
 847          goto ByeBye;
 848       }
 849       RtlCopyMemory(DeviceNode->ResourceList, DeviceNode->BootResources, ListSize);
 850
 851       Status = IopDetectResourceConflict(DeviceNode->ResourceList, FALSE, NULL);
 852       if (NT_SUCCESS(Status) || !DeviceNode->ResourceRequirements)
 853       {
 854           if (!NT_SUCCESS(Status) && !DeviceNode->ResourceRequirements)
 855           {
 856               DPRINT1("Using conflicting boot resources because no requirements were supplied!\n");
 857           }
 858
 859           goto Finish;
 860       }
 861       else
 862       {
 863           DPRINT1("Boot resources for %wZ cause a resource conflict!\n", &DeviceNode->InstancePath);
 864           ExFreePool(DeviceNode->ResourceList);
 865       }
 866    }
 867
 868    Status = IopCreateResourceListFromRequirements(DeviceNode->ResourceRequirements,
 869                                                   &DeviceNode->ResourceList);
 870    if (!NT_SUCCESS(Status))
 871        goto ByeBye;
 872
 873    Status = IopDetectResourceConflict(DeviceNode->ResourceList, FALSE, NULL);
 874    if (!NT_SUCCESS(Status))
 875        goto ByeBye;
 876
 877 Finish:
 878    Status = IopTranslateDeviceResources(DeviceNode);
 879    if (!NT_SUCCESS(Status))
 880        goto ByeBye;
 881
 882    Status = IopUpdateResourceMapForPnPDevice(DeviceNode);
 883    if (!NT_SUCCESS(Status))
 884        goto ByeBye;
 885
 886    Status = IopUpdateControlKeyWithResources(DeviceNode);
 887    if (!NT_SUCCESS(Status))
 888        goto ByeBye;
 889
 890    IopDeviceNodeSetFlag(DeviceNode, DNF_RESOURCE_ASSIGNED);
 891
 892    IopDeviceNodeClearFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
 893
 894    return STATUS_SUCCESS;
 895
 896 ByeBye:
 897    if (DeviceNode->ResourceList)
 898    {
 899       ExFreePool(DeviceNode->ResourceList);
 900       DeviceNode->ResourceList = NULL;
 901    }
 902
 903    DeviceNode->ResourceListTranslated = NULL;
 904
 905    IopDeviceNodeClearFlag(DeviceNode, DNF_ASSIGNING_RESOURCES);
 906
 907    return Status;
 908 }
 909
 910 static
 911 BOOLEAN
 912 IopCheckForResourceConflict(
 913    IN PCM_RESOURCE_LIST ResourceList1,
 914    IN PCM_RESOURCE_LIST ResourceList2,
 915    IN BOOLEAN Silent,
 916    OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDescriptor)
 917 {
 918    ULONG i, ii;
 919    BOOLEAN Result = FALSE;
 920
 921    for (i = 0; i < ResourceList1->Count; i++)
 922    {
 923       PCM_PARTIAL_RESOURCE_LIST ResList = &ResourceList1->List[i].PartialResourceList;
 924       for (ii = 0; ii < ResList->Count; ii++)
 925       {
 926          PCM_PARTIAL_RESOURCE_DESCRIPTOR ResDesc = &ResList->PartialDescriptors[ii];
 927
 928          Result = IopCheckResourceDescriptor(ResDesc,
 929                                              ResourceList2,
 930                                              Silent,
 931                                              ConflictingDescriptor);
 932          if (Result) goto ByeBye;
 933       }
 934    }
 935
 936
 937 ByeBye:
 938
 939    return Result;
 940 }
 941
 942 NTSTATUS
 943 IopDetectResourceConflict(
 944    IN PCM_RESOURCE_LIST ResourceList,
 945    IN BOOLEAN Silent,
 946    OUT OPTIONAL PCM_PARTIAL_RESOURCE_DESCRIPTOR ConflictingDescriptor)
 947 {
 948    OBJECT_ATTRIBUTES ObjectAttributes;
 949    UNICODE_STRING KeyName;
 950    HANDLE ResourceMapKey = INVALID_HANDLE_VALUE, ChildKey2 = INVALID_HANDLE_VALUE, ChildKey3 = INVALID_HANDLE_VALUE;
 951    ULONG KeyInformationLength, RequiredLength, KeyValueInformationLength, KeyNameInformationLength;
 952    PKEY_BASIC_INFORMATION KeyInformation;
 953    PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
 954    PKEY_VALUE_BASIC_INFORMATION KeyNameInformation;
 955    ULONG ChildKeyIndex1 = 0, ChildKeyIndex2 = 0, ChildKeyIndex3 = 0;
 956    NTSTATUS Status;
 957
 958    RtlInitUnicodeString(&KeyName, L"\\Registry\\Machine\\HARDWARE\\RESOURCEMAP");
 959    InitializeObjectAttributes(&ObjectAttributes, &KeyName, OBJ_CASE_INSENSITIVE, 0, NULL);
 960    Status = ZwOpenKey(&ResourceMapKey, KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &ObjectAttributes);
 961    if (!NT_SUCCESS(Status))
 962    {
 963       /* The key is missing which means we are the first device */
 964       return STATUS_SUCCESS;
 965    }
 966
 967    while (TRUE)
 968    {
 969       Status = ZwEnumerateKey(ResourceMapKey,
 970                               ChildKeyIndex1,
 971                               KeyBasicInformation,
 972                               NULL,
 973                               0,
 974                               &RequiredLength);
 975       if (Status == STATUS_NO_MORE_ENTRIES)
 976           break;
 977       else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
 978       {
 979           KeyInformationLength = RequiredLength;
 980           KeyInformation = ExAllocatePool(PagedPool, KeyInformationLength);
 981           if (!KeyInformation)
 982           {
 983               Status = STATUS_INSUFFICIENT_RESOURCES;
 984               goto cleanup;
 985           }
 986
 987           Status = ZwEnumerateKey(ResourceMapKey,
 988                                   ChildKeyIndex1,
 989                                   KeyBasicInformation,
 990                                   KeyInformation,
 991                                   KeyInformationLength,
 992                                   &RequiredLength);
 993       }
 994       else
 995          goto cleanup;
 996       ChildKeyIndex1++;
 997       if (!NT_SUCCESS(Status))
 998           goto cleanup;
 999
1000       KeyName.Buffer = KeyInformation->Name;
1001       KeyName.MaximumLength = KeyName.Length = KeyInformation->NameLength;
1002       InitializeObjectAttributes(&ObjectAttributes,
1003                                  &KeyName,
1004                                  OBJ_CASE_INSENSITIVE,
1005                                  ResourceMapKey,
1006                                  NULL);
1007       Status = ZwOpenKey(&ChildKey2, KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE, &ObjectAttributes);
1008       ExFreePool(KeyInformation);
1009       if (!NT_SUCCESS(Status))
1010           goto cleanup;
1011
1012       while (TRUE)
1013       {
1014           Status = ZwEnumerateKey(ChildKey2,
1015                                   ChildKeyIndex2,
1016                                   KeyBasicInformation,
1017                                   NULL,
1018                                   0,
1019                                   &RequiredLength);
1020           if (Status == STATUS_NO_MORE_ENTRIES)
1021               break;
1022           else if (Status == STATUS_BUFFER_TOO_SMALL)
1023           {
1024               KeyInformationLength = RequiredLength;
1025               KeyInformation = ExAllocatePool(PagedPool, KeyInformationLength);
1026               if (!KeyInformation)
1027               {
1028                   Status = STATUS_INSUFFICIENT_RESOURCES;
1029                   goto cleanup;
1030               }
1031
1032               Status = ZwEnumerateKey(ChildKey2,
1033                                       ChildKeyIndex2,
1034                                       KeyBasicInformation,
1035                                       KeyInformation,
1036                                       KeyInformationLength,
1037                                       &RequiredLength);
1038           }
1039           else
1040               goto cleanup;
1041           ChildKeyIndex2++;
1042           if (!NT_SUCCESS(Status))
1043               goto cleanup;
1044
1045           KeyName.Buffer = KeyInformation->Name;
1046           KeyName.MaximumLength = KeyName.Length = KeyInformation->NameLength;
1047           InitializeObjectAttributes(&ObjectAttributes,
1048                                      &KeyName,
1049                                      OBJ_CASE_INSENSITIVE,
1050                                      ChildKey2,
1051                                      NULL);
1052           Status = ZwOpenKey(&ChildKey3, KEY_QUERY_VALUE, &ObjectAttributes);
1053           ExFreePool(KeyInformation);
1054           if (!NT_SUCCESS(Status))
1055               goto cleanup;
1056
1057           while (TRUE)
1058           {
1059               Status = ZwEnumerateValueKey(ChildKey3,
1060                                            ChildKeyIndex3,
1061                                            KeyValuePartialInformation,
1062                                            NULL,
1063                                            0,
1064                                            &RequiredLength);
1065               if (Status == STATUS_NO_MORE_ENTRIES)
1066                   break;
1067               else if (Status == STATUS_BUFFER_TOO_SMALL)
1068               {
1069                   KeyValueInformationLength = RequiredLength;
1070                   KeyValueInformation = ExAllocatePool(PagedPool, KeyValueInformationLength);
1071                   if (!KeyValueInformation)
1072                   {
1073                       Status = STATUS_INSUFFICIENT_RESOURCES;
1074                       goto cleanup;
1075                   }
1076
1077                   Status = ZwEnumerateValueKey(ChildKey3,
1078                                                ChildKeyIndex3,
1079                                                KeyValuePartialInformation,
1080                                                KeyValueInformation,
1081                                                KeyValueInformationLength,
1082                                                &RequiredLength);
1083               }
1084               else
1085                   goto cleanup;
1086               if (!NT_SUCCESS(Status))
1087                   goto cleanup;
1088
1089               Status = ZwEnumerateValueKey(ChildKey3,
1090                                            ChildKeyIndex3,
1091                                            KeyValueBasicInformation,
1092                                            NULL,
1093                                            0,
1094                                            &RequiredLength);
1095               if (Status == STATUS_BUFFER_TOO_SMALL)
1096               {
1097                   KeyNameInformationLength = RequiredLength;
1098                   KeyNameInformation = ExAllocatePool(PagedPool, KeyNameInformationLength + sizeof(WCHAR));
1099                   if (!KeyNameInformation)
1100                   {
1101                       Status = STATUS_INSUFFICIENT_RESOURCES;
1102                       goto cleanup;
1103                   }
1104
1105                   Status = ZwEnumerateValueKey(ChildKey3,
1106                                                ChildKeyIndex3,
1107                                                KeyValueBasicInformation,
1108                                                KeyNameInformation,
1109                                                KeyNameInformationLength,
1110                                                &RequiredLength);
1111               }
1112               else
1113                   goto cleanup;
1114
1115               ChildKeyIndex3++;
1116
1117               if (!NT_SUCCESS(Status))
1118                   goto cleanup;
1119
1120               KeyNameInformation->Name[KeyNameInformation->NameLength / sizeof(WCHAR)] = UNICODE_NULL;
1121
1122               /* Skip translated entries */
1123               if (wcsstr(KeyNameInformation->Name, L".Translated"))
1124               {
1125                   ExFreePool(KeyNameInformation);
1126                   continue;
1127               }
1128
1129               ExFreePool(KeyNameInformation);
1130
1131               if (IopCheckForResourceConflict(ResourceList,
1132                                               (PCM_RESOURCE_LIST)KeyValueInformation->Data,
1133                                               Silent,
1134                                               ConflictingDescriptor))
1135               {
1136                   ExFreePool(KeyValueInformation);
1137                   Status = STATUS_CONFLICTING_ADDRESSES;
1138                   goto cleanup;
1139               }
1140
1141               ExFreePool(KeyValueInformation);
1142           }
1143       }
1144    }
1145
1146 cleanup:
1147    if (ResourceMapKey != INVALID_HANDLE_VALUE)
1148        ZwClose(ResourceMapKey);
1149    if (ChildKey2 != INVALID_HANDLE_VALUE)
1150        ZwClose(ChildKey2);
1151    if (ChildKey3 != INVALID_HANDLE_VALUE)
1152        ZwClose(ChildKey3);
1153
1154    if (Status == STATUS_NO_MORE_ENTRIES)
1155        Status = STATUS_SUCCESS;
1156
1157    return Status;
1158 }
1159