CorebootModulePkg/PciBusNoEnumerationDxe/PciDeviceSupport.c

   1 /*++
   2
   3 Copyright (c) 2005 - 2006, Intel Corporation. All rights reserved.<BR>
   4 This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   PciDeviceSupport.c
  15
  16 Abstract:
  17
  18   This file provides routine to support Pci device node manipulation
  19
  20 Revision History
  21
  22 --*/
  23
  24 #include "PciBus.h"
  25
  26 //
  27 // This device structure is serviced as a header.
  28 // Its Next field points to the first root bridge device node
  29 //
  30 LIST_ENTRY  gPciDevicePool;
  31
  32 EFI_STATUS
  33 InitializePciDevicePool (
  34   VOID
  35   )
  36 /*++
  37
  38 Routine Description:
  39
  40   Initialize the gPciDevicePool
  41
  42 Arguments:
  43
  44 Returns:
  45
  46   None
  47
  48 --*/
  49 {
  50   InitializeListHead (&gPciDevicePool);
  51
  52   return EFI_SUCCESS;
  53 }
  54
  55 EFI_STATUS
  56 InsertRootBridge (
  57   IN PCI_IO_DEVICE *RootBridge
  58   )
  59 /*++
  60
  61 Routine Description:
  62
  63   Insert a root bridge into PCI device pool
  64
  65 Arguments:
  66
  67   RootBridge    - A pointer to the PCI_IO_DEVICE.
  68
  69 Returns:
  70
  71   None
  72
  73 --*/
  74 {
  75   InsertTailList (&gPciDevicePool, &(RootBridge->Link));
  76
  77   return EFI_SUCCESS;
  78 }
  79
  80 EFI_STATUS
  81 InsertPciDevice (
  82   PCI_IO_DEVICE *Bridge,
  83   PCI_IO_DEVICE *PciDeviceNode
  84   )
  85 /*++
  86
  87 Routine Description:
  88
  89   This function is used to insert a PCI device node under
  90   a bridge
  91
  92 Arguments:
  93   Bridge        - A pointer to the PCI_IO_DEVICE.
  94   PciDeviceNode - A pointer to the PCI_IO_DEVICE.
  95
  96 Returns:
  97
  98   None
  99
 100 --*/
 101
 102 {
 103
 104   InsertTailList (&Bridge->ChildList, &(PciDeviceNode->Link));
 105   PciDeviceNode->Parent = Bridge;
 106
 107   return EFI_SUCCESS;
 108 }
 109
 110 EFI_STATUS
 111 DestroyRootBridge (
 112   IN PCI_IO_DEVICE *RootBridge
 113   )
 114 /*++
 115
 116 Routine Description:
 117
 118
 119 Arguments:
 120
 121   RootBridge   - A pointer to the PCI_IO_DEVICE.
 122
 123 Returns:
 124
 125   None
 126
 127 --*/
 128 {
 129   DestroyPciDeviceTree (RootBridge);
 130
 131   gBS->FreePool (RootBridge);
 132
 133   return EFI_SUCCESS;
 134 }
 135
 136 EFI_STATUS
 137 DestroyPciDeviceTree (
 138   IN PCI_IO_DEVICE *Bridge
 139   )
 140 /*++
 141
 142 Routine Description:
 143
 144   Destroy all the pci device node under the bridge.
 145   Bridge itself is not included.
 146
 147 Arguments:
 148
 149   Bridge   - A pointer to the PCI_IO_DEVICE.
 150
 151 Returns:
 152
 153   None
 154
 155 --*/
 156 {
 157   LIST_ENTRY  *CurrentLink;
 158   PCI_IO_DEVICE   *Temp;
 159
 160   while (!IsListEmpty (&Bridge->ChildList)) {
 161
 162     CurrentLink = Bridge->ChildList.ForwardLink;
 163
 164     //
 165     // Remove this node from the linked list
 166     //
 167     RemoveEntryList (CurrentLink);
 168
 169     Temp = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 170
 171     if (IS_PCI_BRIDGE (&(Temp->Pci))) {
 172       DestroyPciDeviceTree (Temp);
 173     }
 174     gBS->FreePool (Temp);
 175   }
 176
 177   return EFI_SUCCESS;
 178 }
 179
 180 EFI_STATUS
 181 DestroyRootBridgeByHandle (
 182   EFI_HANDLE Controller
 183   )
 184 /*++
 185
 186 Routine Description:
 187
 188   Destroy all device nodes under the root bridge
 189   specified by Controller.
 190   The root bridge itself is also included.
 191
 192 Arguments:
 193
 194   Controller   - An efi handle.
 195
 196 Returns:
 197
 198   None
 199
 200 --*/
 201 {
 202
 203   LIST_ENTRY  *CurrentLink;
 204   PCI_IO_DEVICE   *Temp;
 205
 206   CurrentLink = gPciDevicePool.ForwardLink;
 207
 208   while (CurrentLink && CurrentLink != &gPciDevicePool) {
 209     Temp = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 210
 211     if (Temp->Handle == Controller) {
 212
 213       RemoveEntryList (CurrentLink);
 214
 215       DestroyPciDeviceTree (Temp);
 216
 217       gBS->FreePool(Temp);
 218
 219       return EFI_SUCCESS;
 220     }
 221
 222     CurrentLink = CurrentLink->ForwardLink;
 223   }
 224
 225   return EFI_NOT_FOUND;
 226 }
 227
 228 EFI_STATUS
 229 RegisterPciDevice (
 230   IN  EFI_HANDLE                     Controller,
 231   IN  PCI_IO_DEVICE                  *PciIoDevice,
 232   OUT EFI_HANDLE                     *Handle OPTIONAL
 233   )
 234 /*++
 235
 236 Routine Description:
 237
 238   This function registers the PCI IO device. It creates a handle for this PCI IO device
 239   (if the handle does not exist), attaches appropriate protocols onto the handle, does
 240   necessary initialization, and sets up parent/child relationship with its bus controller.
 241
 242 Arguments:
 243
 244   Controller    - An EFI handle for the PCI bus controller.
 245   PciIoDevice   - A PCI_IO_DEVICE pointer to the PCI IO device to be registered.
 246   Handle        - A pointer to hold the EFI handle for the PCI IO device.
 247
 248 Returns:
 249
 250   EFI_SUCCESS   - The PCI device is successfully registered.
 251   Others        - An error occurred when registering the PCI device.
 252
 253 --*/
 254 {
 255   EFI_STATUS          Status;
 256   UINT8               PciExpressCapRegOffset;
 257
 258   //
 259   // Install the pciio protocol, device path protocol and
 260   // Bus Specific Driver Override Protocol
 261   //
 262
 263   if (PciIoDevice->BusOverride) {
 264     Status = gBS->InstallMultipleProtocolInterfaces (
 265                   &PciIoDevice->Handle,
 266                   &gEfiDevicePathProtocolGuid,
 267                   PciIoDevice->DevicePath,
 268                   &gEfiPciIoProtocolGuid,
 269                   &PciIoDevice->PciIo,
 270                   &gEfiBusSpecificDriverOverrideProtocolGuid,
 271                   &PciIoDevice->PciDriverOverride,
 272                   NULL
 273                   );
 274   } else {
 275     Status = gBS->InstallMultipleProtocolInterfaces (
 276                   &PciIoDevice->Handle,
 277                   &gEfiDevicePathProtocolGuid,
 278                   PciIoDevice->DevicePath,
 279                   &gEfiPciIoProtocolGuid,
 280                   &PciIoDevice->PciIo,
 281                   NULL
 282                   );
 283   }
 284
 285   if (EFI_ERROR (Status)) {
 286     return Status;
 287   } else {
 288     Status = gBS->OpenProtocol (
 289                     Controller,
 290                     &gEfiPciRootBridgeIoProtocolGuid,
 291                     (VOID **)&(PciIoDevice->PciRootBridgeIo),
 292                     gPciBusDriverBinding.DriverBindingHandle,
 293                     PciIoDevice->Handle,
 294                     EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 295                     );
 296     if (EFI_ERROR (Status)) {
 297       return Status;
 298     }
 299   }
 300
 301   if (Handle != NULL) {
 302     *Handle = PciIoDevice->Handle;
 303   }
 304
 305   //
 306   // Detect if PCI Express Device
 307   //
 308   PciExpressCapRegOffset = 0;
 309   Status = LocateCapabilityRegBlock (
 310              PciIoDevice,
 311              EFI_PCI_CAPABILITY_ID_PCIEXP,
 312              &PciExpressCapRegOffset,
 313              NULL
 314              );
 315   if (!EFI_ERROR (Status)) {
 316     PciIoDevice->IsPciExp = TRUE;
 317     DEBUG ((EFI_D_ERROR, "PciExp - %x (B-%x, D-%x, F-%x)\n", PciIoDevice->IsPciExp, PciIoDevice->BusNumber, PciIoDevice->DeviceNumber, PciIoDevice->FunctionNumber));
 318   }
 319
 320   //
 321   // Indicate the pci device is registered
 322   //
 323   PciIoDevice->Registered = TRUE;
 324
 325   return EFI_SUCCESS;
 326 }
 327
 328
 329 EFI_STATUS
 330 DeRegisterPciDevice (
 331   IN  EFI_HANDLE                     Controller,
 332   IN  EFI_HANDLE                     Handle
 333   )
 334 /*++
 335
 336 Routine Description:
 337
 338   This function is used to de-register the PCI device from the EFI,
 339   That includes un-installing PciIo protocol from the specified PCI
 340   device handle.
 341
 342 Arguments:
 343
 344   Controller   - An efi handle.
 345   Handle       - An efi handle.
 346
 347 Returns:
 348
 349   None
 350
 351 --*/
 352 {
 353   EFI_PCI_IO_PROTOCOL             *PciIo;
 354   EFI_STATUS                      Status;
 355   PCI_IO_DEVICE                   *PciIoDevice;
 356   PCI_IO_DEVICE                   *Node;
 357   LIST_ENTRY                  *CurrentLink;
 358   EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *PciRootBridgeIo;
 359
 360   Status = gBS->OpenProtocol (
 361                   Handle,
 362                   &gEfiPciIoProtocolGuid,
 363                   (VOID **) &PciIo,
 364                   gPciBusDriverBinding.DriverBindingHandle,
 365                   Controller,
 366                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 367                   );
 368   if (!EFI_ERROR (Status)) {
 369     PciIoDevice = PCI_IO_DEVICE_FROM_PCI_IO_THIS (PciIo);
 370
 371     //
 372     // If it is already de-registered
 373     //
 374     if (!PciIoDevice->Registered) {
 375       return EFI_SUCCESS;
 376     }
 377
 378     //
 379     // If it is PPB, first de-register its children
 380     //
 381
 382     if (IS_PCI_BRIDGE (&(PciIoDevice->Pci))) {
 383
 384       CurrentLink = PciIoDevice->ChildList.ForwardLink;
 385
 386       while (CurrentLink && CurrentLink != &PciIoDevice->ChildList) {
 387         Node    = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 388         Status  = DeRegisterPciDevice (Controller, Node->Handle);
 389
 390         if (EFI_ERROR (Status)) {
 391           return Status;
 392         }
 393
 394         CurrentLink = CurrentLink->ForwardLink;
 395       }
 396     }
 397
 398     //
 399     // First disconnect this device
 400     //
 401 //    PciIoDevice->PciIo.Attributes(&(PciIoDevice->PciIo),
 402 //                                    EfiPciIoAttributeOperationDisable,
 403 //                                    EFI_PCI_DEVICE_ENABLE,
 404 //                                    NULL
 405 //                                    );
 406
 407     //
 408     // Close the child handle
 409     //
 410     Status = gBS->CloseProtocol (
 411                     Controller,
 412                     &gEfiPciRootBridgeIoProtocolGuid,
 413                     gPciBusDriverBinding.DriverBindingHandle,
 414                     Handle
 415                     );
 416
 417     //
 418     // Un-install the device path protocol and pci io protocol
 419     //
 420     if (PciIoDevice->BusOverride) {
 421       Status = gBS->UninstallMultipleProtocolInterfaces (
 422                       Handle,
 423                       &gEfiDevicePathProtocolGuid,
 424                       PciIoDevice->DevicePath,
 425                       &gEfiPciIoProtocolGuid,
 426                       &PciIoDevice->PciIo,
 427                       &gEfiBusSpecificDriverOverrideProtocolGuid,
 428                       &PciIoDevice->PciDriverOverride,
 429                       NULL
 430                       );
 431     } else {
 432       Status = gBS->UninstallMultipleProtocolInterfaces (
 433                       Handle,
 434                       &gEfiDevicePathProtocolGuid,
 435                       PciIoDevice->DevicePath,
 436                       &gEfiPciIoProtocolGuid,
 437                       &PciIoDevice->PciIo,
 438                       NULL
 439                       );
 440     }
 441
 442     if (EFI_ERROR (Status)) {
 443       gBS->OpenProtocol (
 444             Controller,
 445             &gEfiPciRootBridgeIoProtocolGuid,
 446             (VOID **) &PciRootBridgeIo,
 447             gPciBusDriverBinding.DriverBindingHandle,
 448             Handle,
 449             EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 450             );
 451       return Status;
 452     }
 453
 454     //
 455     // The Device Driver should disable this device after disconnect
 456     // so the Pci Bus driver will not touch this device any more.
 457     // Restore the register field to the original value
 458     //
 459     PciIoDevice->Registered = FALSE;
 460     PciIoDevice->Handle     = NULL;
 461   } else {
 462
 463     //
 464     // Handle may be closed before
 465     //
 466     return EFI_SUCCESS;
 467   }
 468
 469   return EFI_SUCCESS;
 470 }
 471
 472 EFI_STATUS
 473 EnableBridgeAttributes (
 474   IN PCI_IO_DEVICE                       *PciIoDevice
 475   )
 476 {
 477   PCI_TYPE01                PciData;
 478
 479   //
 480   // NOTE: We should not set EFI_PCI_DEVICE_ENABLE for a bridge
 481   //       directly, because some legacy BIOS will NOT assign
 482   //       IO or Memory resource for a bridge who has no child
 483   //       device. So we add check IO or Memory here.
 484   //
 485
 486   PciIoDevice->PciIo.Pci.Read (
 487                            &PciIoDevice->PciIo,
 488                            EfiPciIoWidthUint8,
 489                            0,
 490                            sizeof (PciData),
 491                            &PciData
 492                            );
 493
 494   if ((((PciData.Bridge.IoBase & 0xF) == 0) &&
 495         (PciData.Bridge.IoBase != 0 || PciData.Bridge.IoLimit != 0)) ||
 496       (((PciData.Bridge.IoBase & 0xF) == 1) &&
 497         ((PciData.Bridge.IoBase & 0xF0) != 0 || (PciData.Bridge.IoLimit & 0xF0) != 0 || PciData.Bridge.IoBaseUpper16 != 0 || PciData.Bridge.IoLimitUpper16 != 0))) {
 498     PciIoDevice->PciIo.Attributes(
 499                          &(PciIoDevice->PciIo),
 500                          EfiPciIoAttributeOperationEnable,
 501                          (EFI_PCI_IO_ATTRIBUTE_IO | EFI_PCI_IO_ATTRIBUTE_BUS_MASTER),
 502                          NULL
 503                          );
 504   }
 505   if ((PciData.Bridge.MemoryBase & 0xFFF0) != 0 || (PciData.Bridge.MemoryLimit & 0xFFF0) != 0) {
 506     PciIoDevice->PciIo.Attributes(
 507                          &(PciIoDevice->PciIo),
 508                          EfiPciIoAttributeOperationEnable,
 509                          (EFI_PCI_IO_ATTRIBUTE_MEMORY | EFI_PCI_IO_ATTRIBUTE_BUS_MASTER),
 510                          NULL
 511                          );
 512   }
 513   if ((((PciData.Bridge.PrefetchableMemoryBase & 0xF) == 0) &&
 514         (PciData.Bridge.PrefetchableMemoryBase != 0 || PciData.Bridge.PrefetchableMemoryLimit != 0)) ||
 515       (((PciData.Bridge.PrefetchableMemoryBase & 0xF) == 1) &&
 516         ((PciData.Bridge.PrefetchableMemoryBase & 0xFFF0) != 0 || (PciData.Bridge.PrefetchableMemoryLimit & 0xFFF0) != 0 || PciData.Bridge.PrefetchableBaseUpper32 != 0 || PciData.Bridge.PrefetchableLimitUpper32 != 0))) {
 517     PciIoDevice->PciIo.Attributes(
 518                          &(PciIoDevice->PciIo),
 519                          EfiPciIoAttributeOperationEnable,
 520                          (EFI_PCI_IO_ATTRIBUTE_MEMORY | EFI_PCI_IO_ATTRIBUTE_BUS_MASTER),
 521                          NULL
 522                          );
 523   }
 524
 525   return EFI_SUCCESS;
 526 }
 527
 528 EFI_STATUS
 529 StartPciDevicesOnBridge (
 530   IN EFI_HANDLE                          Controller,
 531   IN PCI_IO_DEVICE                       *RootBridge,
 532   IN EFI_DEVICE_PATH_PROTOCOL            *RemainingDevicePath
 533   )
 534 /*++
 535
 536 Routine Description:
 537
 538   Start to manage the PCI device on specified the root bridge or PCI-PCI Bridge
 539
 540 Arguments:
 541
 542   Controller          - An efi handle.
 543   RootBridge          - A pointer to the PCI_IO_DEVICE.
 544   RemainingDevicePath - A pointer to the EFI_DEVICE_PATH_PROTOCOL.
 545   NumberOfChildren    - Children number.
 546   ChildHandleBuffer   - A pointer to the child handle buffer.
 547
 548 Returns:
 549
 550   None
 551
 552 --*/
 553 {
 554   PCI_IO_DEVICE             *Temp;
 555   PCI_IO_DEVICE             *PciIoDevice;
 556   EFI_DEV_PATH_PTR          Node;
 557   EFI_DEVICE_PATH_PROTOCOL  *CurrentDevicePath;
 558   EFI_STATUS                Status;
 559   LIST_ENTRY            *CurrentLink;
 560
 561   CurrentLink = RootBridge->ChildList.ForwardLink;
 562
 563   while (CurrentLink && CurrentLink != &RootBridge->ChildList) {
 564
 565     Temp = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 566     if (RemainingDevicePath != NULL) {
 567
 568       Node.DevPath = RemainingDevicePath;
 569
 570       if (Node.Pci->Device != Temp->DeviceNumber ||
 571           Node.Pci->Function != Temp->FunctionNumber) {
 572         CurrentLink = CurrentLink->ForwardLink;
 573         continue;
 574       }
 575
 576       //
 577       // Check if the device has been assigned with required resource
 578       //
 579       if (!Temp->Allocated) {
 580         return EFI_NOT_READY;
 581       }
 582
 583       //
 584       // Check if the current node has been registered before
 585       // If it is not, register it
 586       //
 587       if (!Temp->Registered) {
 588         PciIoDevice = Temp;
 589
 590         Status = RegisterPciDevice (
 591                   Controller,
 592                   PciIoDevice,
 593                   NULL
 594                   );
 595
 596       }
 597
 598       //
 599       // Get the next device path
 600       //
 601       CurrentDevicePath = NextDevicePathNode (RemainingDevicePath);
 602       if (IsDevicePathEnd (CurrentDevicePath)) {
 603         return EFI_SUCCESS;
 604       }
 605
 606       //
 607       // If it is a PPB
 608       //
 609       if (IS_PCI_BRIDGE (&(Temp->Pci))) {
 610         Status = StartPciDevicesOnBridge (
 611                   Controller,
 612                   Temp,
 613                   CurrentDevicePath
 614                   );
 615         EnableBridgeAttributes (Temp);
 616
 617         return Status;
 618       } else {
 619
 620         //
 621         // Currently, the PCI bus driver only support PCI-PCI bridge
 622         //
 623         return EFI_UNSUPPORTED;
 624       }
 625
 626     } else {
 627
 628       //
 629       // If remaining device path is NULL,
 630       // try to enable all the pci devices under this bridge
 631       //
 632
 633       if (!Temp->Registered && Temp->Allocated) {
 634
 635         PciIoDevice = Temp;
 636
 637         Status = RegisterPciDevice (
 638                   Controller,
 639                   PciIoDevice,
 640                   NULL
 641                   );
 642
 643       }
 644
 645       if (IS_PCI_BRIDGE (&(Temp->Pci))) {
 646         Status = StartPciDevicesOnBridge (
 647                    Controller,
 648                    Temp,
 649                    RemainingDevicePath
 650                    );
 651         EnableBridgeAttributes (Temp);
 652       }
 653
 654       CurrentLink = CurrentLink->ForwardLink;
 655       continue;
 656     }
 657   }
 658
 659   return EFI_NOT_FOUND;
 660 }
 661
 662 EFI_STATUS
 663 StartPciDevices (
 664   IN EFI_HANDLE                         Controller,
 665   IN EFI_DEVICE_PATH_PROTOCOL           *RemainingDevicePath
 666   )
 667 /*++
 668
 669 Routine Description:
 670
 671   Start to manage the PCI device according to RemainingDevicePath
 672   If RemainingDevicePath == NULL, the PCI bus driver will start
 673   to manage all the PCI devices it found previously
 674
 675 Arguments:
 676   Controller          - An efi handle.
 677   RemainingDevicePath - A pointer to the EFI_DEVICE_PATH_PROTOCOL.
 678
 679 Returns:
 680
 681   None
 682
 683 --*/
 684 {
 685   EFI_DEV_PATH_PTR  Node;
 686   PCI_IO_DEVICE     *RootBridge;
 687   LIST_ENTRY    *CurrentLink;
 688
 689   if (RemainingDevicePath != NULL) {
 690
 691     //
 692     // Check if the RemainingDevicePath is valid
 693     //
 694     Node.DevPath = RemainingDevicePath;
 695     if (Node.DevPath->Type != HARDWARE_DEVICE_PATH ||
 696         Node.DevPath->SubType != HW_PCI_DP         ||
 697         DevicePathNodeLength (Node.DevPath) != sizeof (PCI_DEVICE_PATH)
 698         ) {
 699       return EFI_UNSUPPORTED;
 700     }
 701   }
 702
 703   CurrentLink = gPciDevicePool.ForwardLink;
 704
 705   while (CurrentLink && CurrentLink != &gPciDevicePool) {
 706
 707     RootBridge = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 708     //
 709     // Locate the right root bridge to start
 710     //
 711     if (RootBridge->Handle == Controller) {
 712       StartPciDevicesOnBridge (
 713         Controller,
 714         RootBridge,
 715         RemainingDevicePath
 716         );
 717     }
 718
 719     CurrentLink = CurrentLink->ForwardLink;
 720   }
 721
 722   return EFI_SUCCESS;
 723 }
 724
 725 PCI_IO_DEVICE *
 726 CreateRootBridge (
 727   IN EFI_HANDLE RootBridgeHandle
 728   )
 729 /*++
 730
 731 Routine Description:
 732
 733
 734 Arguments:
 735   RootBridgeHandle   - An efi handle.
 736
 737 Returns:
 738
 739   None
 740
 741 --*/
 742 {
 743
 744   EFI_STATUS                      Status;
 745   PCI_IO_DEVICE                   *Dev;
 746
 747   Dev = NULL;
 748   Status = gBS->AllocatePool (
 749                   EfiBootServicesData,
 750                   sizeof (PCI_IO_DEVICE),
 751                   (VOID **) &Dev
 752                   );
 753
 754   if (EFI_ERROR (Status)) {
 755     return NULL;
 756   }
 757
 758   ZeroMem (Dev, sizeof (PCI_IO_DEVICE));
 759   Dev->Signature  = PCI_IO_DEVICE_SIGNATURE;
 760   Dev->Handle     = RootBridgeHandle;
 761   InitializeListHead (&Dev->ChildList);
 762
 763   return Dev;
 764 }
 765
 766 PCI_IO_DEVICE *
 767 GetRootBridgeByHandle (
 768   EFI_HANDLE RootBridgeHandle
 769   )
 770 /*++
 771
 772 Routine Description:
 773
 774
 775 Arguments:
 776
 777   RootBridgeHandle    - An efi handle.
 778
 779 Returns:
 780
 781   None
 782
 783 --*/
 784 {
 785   PCI_IO_DEVICE   *RootBridgeDev;
 786   LIST_ENTRY  *CurrentLink;
 787
 788   CurrentLink = gPciDevicePool.ForwardLink;
 789
 790   while (CurrentLink && CurrentLink != &gPciDevicePool) {
 791
 792     RootBridgeDev = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 793     if (RootBridgeDev->Handle == RootBridgeHandle) {
 794       return RootBridgeDev;
 795     }
 796
 797     CurrentLink = CurrentLink->ForwardLink;
 798   }
 799
 800   return NULL;
 801 }
 802
 803 BOOLEAN
 804 RootBridgeExisted (
 805   IN EFI_HANDLE RootBridgeHandle
 806   )
 807 /*++
 808
 809 Routine Description:
 810
 811   This function searches if RootBridgeHandle has already existed
 812   in current device pool.
 813
 814   If so, it means the given root bridge has been already enumerated.
 815
 816 Arguments:
 817
 818   RootBridgeHandle   - An efi handle.
 819
 820 Returns:
 821
 822   None
 823
 824 --*/
 825 {
 826   PCI_IO_DEVICE *Bridge;
 827
 828   Bridge = GetRootBridgeByHandle (RootBridgeHandle);
 829
 830   if (Bridge != NULL) {
 831     return TRUE;
 832   }
 833
 834   return FALSE;
 835 }
 836
 837 BOOLEAN
 838 PciDeviceExisted (
 839   IN PCI_IO_DEVICE    *Bridge,
 840   IN PCI_IO_DEVICE    *PciIoDevice
 841   )
 842 /*++
 843
 844 Routine Description:
 845
 846 Arguments:
 847
 848   Bridge       - A pointer to the PCI_IO_DEVICE.
 849   PciIoDevice  - A pointer to the PCI_IO_DEVICE.
 850
 851 Returns:
 852
 853   None
 854
 855 --*/
 856 {
 857
 858   PCI_IO_DEVICE   *Temp;
 859   LIST_ENTRY  *CurrentLink;
 860
 861   CurrentLink = Bridge->ChildList.ForwardLink;
 862
 863   while (CurrentLink && CurrentLink != &Bridge->ChildList) {
 864
 865     Temp = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 866
 867     if (Temp == PciIoDevice) {
 868       return TRUE;
 869     }
 870
 871     if (!IsListEmpty (&Temp->ChildList)) {
 872       if (PciDeviceExisted (Temp, PciIoDevice)) {
 873         return TRUE;
 874       }
 875     }
 876
 877     CurrentLink = CurrentLink->ForwardLink;
 878   }
 879
 880   return FALSE;
 881 }
 882
 883 PCI_IO_DEVICE *
 884 ActiveVGADeviceOnTheSameSegment (
 885   IN PCI_IO_DEVICE        *VgaDevice
 886   )
 887 /*++
 888
 889 Routine Description:
 890
 891 Arguments:
 892
 893   VgaDevice    - A pointer to the PCI_IO_DEVICE.
 894
 895 Returns:
 896
 897   None
 898
 899 --*/
 900 {
 901   LIST_ENTRY  *CurrentLink;
 902   PCI_IO_DEVICE   *Temp;
 903
 904   CurrentLink = gPciDevicePool.ForwardLink;
 905
 906   while (CurrentLink && CurrentLink != &gPciDevicePool) {
 907
 908     Temp = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 909
 910     if (Temp->PciRootBridgeIo->SegmentNumber == VgaDevice->PciRootBridgeIo->SegmentNumber) {
 911
 912       Temp = ActiveVGADeviceOnTheRootBridge (Temp);
 913
 914       if (Temp != NULL) {
 915         return Temp;
 916       }
 917     }
 918
 919     CurrentLink = CurrentLink->ForwardLink;
 920   }
 921
 922   return NULL;
 923 }
 924
 925 PCI_IO_DEVICE *
 926 ActiveVGADeviceOnTheRootBridge (
 927   IN PCI_IO_DEVICE        *RootBridge
 928   )
 929 /*++
 930
 931 Routine Description:
 932
 933 Arguments:
 934
 935   RootBridge    - A pointer to the PCI_IO_DEVICE.
 936
 937 Returns:
 938
 939   None
 940
 941 --*/
 942 {
 943   LIST_ENTRY  *CurrentLink;
 944   PCI_IO_DEVICE   *Temp;
 945
 946   CurrentLink = RootBridge->ChildList.ForwardLink;
 947
 948   while (CurrentLink && CurrentLink != &RootBridge->ChildList) {
 949
 950     Temp = PCI_IO_DEVICE_FROM_LINK (CurrentLink);
 951
 952     if (IS_PCI_VGA(&Temp->Pci) &&
 953         (Temp->Attributes &
 954          (EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY |
 955           EFI_PCI_IO_ATTRIBUTE_VGA_IO     |
 956           EFI_PCI_IO_ATTRIBUTE_VGA_IO_16))) {
 957       return Temp;
 958     }
 959
 960     if (IS_PCI_BRIDGE (&Temp->Pci)) {
 961
 962       Temp = ActiveVGADeviceOnTheRootBridge (Temp);
 963
 964       if (Temp != NULL) {
 965         return Temp;
 966       }
 967     }
 968
 969     CurrentLink = CurrentLink->ForwardLink;
 970   }
 971
 972   return NULL;
 973 }