DuetPkg/PciBusNoEnumerationDxe/PciDriverOverride.c

   1 /*++
   2
   3 Copyright (c) 2005 - 2007, Intel Corporation
   4 All rights reserved. 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   PciDriverOverride.c
  15
  16 Abstract:
  17
  18   PCI Bus Driver
  19
  20 Revision History
  21
  22 --*/
  23
  24 #include "PciBus.h"
  25
  26 EFI_STATUS
  27 EFIAPI
  28 GetDriver(
  29   IN     EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL          *This,
  30   IN OUT EFI_HANDLE                                         *DriverImageHandle
  31   );
  32
  33
  34
  35 EFI_STATUS
  36 InitializePciDriverOverrideInstance (
  37   PCI_IO_DEVICE  *PciIoDevice
  38   )
  39 /*++
  40
  41 Routine Description:
  42
  43   Initializes a PCI Driver Override Instance
  44
  45 Arguments:
  46
  47 Returns:
  48
  49   None
  50
  51 --*/
  52
  53 {
  54   PciIoDevice->PciDriverOverride.GetDriver = GetDriver;
  55   return EFI_SUCCESS;
  56 }
  57
  58 EFI_STATUS
  59 EFIAPI
  60 GetDriver (
  61   IN EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL              *This,
  62   IN OUT EFI_HANDLE                                         *DriverImageHandle
  63   )
  64 /*++
  65
  66 Routine Description:
  67
  68   Get a overriding driver image
  69
  70 Arguments:
  71
  72 Returns:
  73
  74   None
  75
  76 --*/
  77 {
  78   PCI_IO_DEVICE             *PciIoDevice;
  79   LIST_ENTRY            *CurrentLink;
  80   PCI_DRIVER_OVERRIDE_LIST  *Node;
  81
  82   PciIoDevice = PCI_IO_DEVICE_FROM_PCI_DRIVER_OVERRIDE_THIS (This);
  83
  84   CurrentLink = PciIoDevice->OptionRomDriverList.ForwardLink;
  85
  86   while (CurrentLink && CurrentLink != &PciIoDevice->OptionRomDriverList) {
  87
  88     Node = DRIVER_OVERRIDE_FROM_LINK (CurrentLink);
  89
  90     if (*DriverImageHandle == NULL) {
  91
  92       *DriverImageHandle = Node->DriverImageHandle;
  93       return EFI_SUCCESS;
  94     }
  95
  96     if (*DriverImageHandle == Node->DriverImageHandle) {
  97
  98       if (CurrentLink->ForwardLink == &PciIoDevice->OptionRomDriverList ||
  99           CurrentLink->ForwardLink == NULL) {
 100         return EFI_NOT_FOUND;
 101       }
 102
 103       //
 104       // Get next node
 105       //
 106       Node                = DRIVER_OVERRIDE_FROM_LINK (CurrentLink->ForwardLink);
 107       *DriverImageHandle  = Node->DriverImageHandle;
 108       return EFI_SUCCESS;
 109     }
 110
 111     CurrentLink = CurrentLink->ForwardLink;
 112   }
 113
 114   return EFI_INVALID_PARAMETER;
 115 }
 116
 117 EFI_STATUS
 118 AddDriver (
 119   IN PCI_IO_DEVICE     *PciIoDevice,
 120   IN EFI_HANDLE        DriverImageHandle
 121   )
 122 /*++
 123
 124 Routine Description:
 125
 126   Add a overriding driver image
 127
 128 Arguments:
 129
 130 Returns:
 131
 132   None
 133
 134 --*/
 135
 136 {
 137   EFI_STATUS                    Status;
 138   EFI_LOADED_IMAGE_PROTOCOL     *LoadedImage;
 139   PE_COFF_LOADER_IMAGE_CONTEXT  ImageContext;
 140   PCI_DRIVER_OVERRIDE_LIST      *Node;
 141 #if (EFI_SPECIFICATION_VERSION < 0x00020000)
 142   EFI_DRIVER_OS_HANDOFF_HEADER  *DriverOsHandoffHeader;
 143   EFI_DRIVER_OS_HANDOFF_HEADER  *NewDriverOsHandoffHeader;
 144   EFI_DRIVER_OS_HANDOFF         *DriverOsHandoff;
 145   EFI_DEVICE_PATH_PROTOCOL      *DevicePath;
 146   EFI_HANDLE                    DeviceHandle;
 147   UINTN                         NumberOfEntries;
 148   UINTN                         Size;
 149   UINTN                         Index;
 150 #endif
 151
 152   Status = gBS->HandleProtocol (DriverImageHandle, &gEfiLoadedImageProtocolGuid, (VOID **) &LoadedImage);
 153   if (EFI_ERROR (Status)) {
 154     return Status;
 155   }
 156
 157   Node = AllocatePool (sizeof (PCI_DRIVER_OVERRIDE_LIST));
 158   if (Node == NULL) {
 159     return EFI_OUT_OF_RESOURCES;
 160   }
 161
 162   Node->Signature         = DRIVER_OVERRIDE_SIGNATURE;
 163   Node->DriverImageHandle = DriverImageHandle;
 164
 165   InsertTailList (&PciIoDevice->OptionRomDriverList, &(Node->Link));
 166
 167   PciIoDevice->BusOverride  = TRUE;
 168
 169
 170   ImageContext.Handle    = LoadedImage->ImageBase;
 171   ImageContext.ImageRead = PeCoffLoaderImageReadFromMemory;
 172
 173   //
 174   // Get information about the image
 175   //
 176   Status = PeCoffLoaderGetImageInfo (&ImageContext);
 177   if (EFI_ERROR (Status)) {
 178     return EFI_SUCCESS;
 179   }
 180
 181   if (ImageContext.Machine != EFI_IMAGE_MACHINE_EBC) {
 182     return EFI_SUCCESS;
 183   }
 184
 185 #if (EFI_SPECIFICATION_VERSION < 0x00020000)
 186   DriverOsHandoffHeader = NULL;
 187   Status                = EfiLibGetSystemConfigurationTable (&gEfiUgaIoProtocolGuid, (VOID **) &DriverOsHandoffHeader);
 188   if (!EFI_ERROR (Status) && DriverOsHandoffHeader != NULL) {
 189     for (Index = 0; Index < DriverOsHandoffHeader->NumberOfEntries; Index++) {
 190       DriverOsHandoff = (EFI_DRIVER_OS_HANDOFF *)((UINTN)(DriverOsHandoffHeader)    +
 191                                                   DriverOsHandoffHeader->HeaderSize +
 192                                                   Index * DriverOsHandoffHeader->SizeOfEntries);
 193       DevicePath  = DriverOsHandoff->DevicePath;
 194       Status      = gBS->LocateDevicePath (&gEfiDevicePathProtocolGuid, &DevicePath, &DeviceHandle);
 195       if (!EFI_ERROR (Status) && DeviceHandle != NULL && IsDevicePathEnd (DevicePath)) {
 196         if (DeviceHandle == PciIoDevice->Handle) {
 197           return EFI_SUCCESS;
 198         }
 199       }
 200     }
 201
 202     NumberOfEntries = DriverOsHandoffHeader->NumberOfEntries + 1;
 203   } else {
 204     NumberOfEntries = 1;
 205   }
 206
 207   Status = gBS->AllocatePool (
 208                   EfiRuntimeServicesData,
 209                   sizeof (EFI_DRIVER_OS_HANDOFF_HEADER) + NumberOfEntries * sizeof (EFI_DRIVER_OS_HANDOFF),
 210                   (VOID **) &NewDriverOsHandoffHeader
 211                   );
 212   if (EFI_ERROR (Status)) {
 213     return Status;
 214   }
 215
 216   if (DriverOsHandoffHeader == NULL) {
 217     NewDriverOsHandoffHeader->Version         = 0;
 218     NewDriverOsHandoffHeader->HeaderSize      = sizeof (EFI_DRIVER_OS_HANDOFF_HEADER);
 219     NewDriverOsHandoffHeader->SizeOfEntries   = sizeof (EFI_DRIVER_OS_HANDOFF);
 220     NewDriverOsHandoffHeader->NumberOfEntries = (UINT32) NumberOfEntries;
 221   } else {
 222     gBS->CopyMem (
 223           NewDriverOsHandoffHeader,
 224           DriverOsHandoffHeader,
 225           DriverOsHandoffHeader->HeaderSize + (NumberOfEntries - 1) * DriverOsHandoffHeader->SizeOfEntries
 226           );
 227     NewDriverOsHandoffHeader->NumberOfEntries = (UINT32) NumberOfEntries;
 228   }
 229
 230   DriverOsHandoff = (EFI_DRIVER_OS_HANDOFF *)((UINTN)NewDriverOsHandoffHeader      +
 231                                               NewDriverOsHandoffHeader->HeaderSize +
 232                                               (NumberOfEntries - 1) * NewDriverOsHandoffHeader->SizeOfEntries);
 233
 234   //
 235   // Fill in the EFI_DRIVER_OS_HANDOFF structure
 236   //
 237   DriverOsHandoff->Type = EfiUgaDriverFromPciRom;
 238
 239   //
 240   // Compute the size of the device path
 241   //
 242   Size = EfiDevicePathSize (PciIoDevice->DevicePath);
 243   if (Size == 0) {
 244     DriverOsHandoff->DevicePath = NULL;
 245   } else {
 246
 247     //
 248     // Allocate space for duplicate device path
 249     //
 250     Status = gBS->AllocatePool (
 251                     EfiRuntimeServicesData,
 252                     Size,
 253                     (VOID **) &DriverOsHandoff->DevicePath
 254                     );
 255     if (EFI_ERROR (Status)) {
 256       gBS->FreePool (NewDriverOsHandoffHeader);
 257       return Status;
 258     }
 259
 260     //
 261     // Make copy of device path
 262     //
 263     CopyMem (DriverOsHandoff->DevicePath, PciIoDevice->DevicePath, Size);
 264   }
 265
 266   DriverOsHandoff->PciRomSize = (UINT64) PciIoDevice->PciIo.RomSize;
 267   Status = gBS->AllocatePool (
 268                   EfiRuntimeServicesData,
 269                   (UINTN) DriverOsHandoff->PciRomSize,
 270                   (VOID **) &DriverOsHandoff->PciRomImage
 271                   );
 272   if (EFI_ERROR (Status)) {
 273     gBS->FreePool (NewDriverOsHandoffHeader);
 274     return Status;
 275   }
 276
 277   gBS->CopyMem (
 278         DriverOsHandoff->PciRomImage,
 279         PciIoDevice->PciIo.RomImage,
 280         (UINTN) DriverOsHandoff->PciRomSize
 281         );
 282
 283   Status = gBS->InstallConfigurationTable (&gEfiUgaIoProtocolGuid, NewDriverOsHandoffHeader);
 284   if (EFI_ERROR (Status)) {
 285     return Status;
 286   }
 287
 288   if (DriverOsHandoffHeader != NULL) {
 289     gBS->FreePool (DriverOsHandoffHeader);
 290   }
 291 #endif
 292
 293   return EFI_SUCCESS;
 294 }