EdkModulePkg/Bus/Pci/PciBus/Dxe/PciDriverOverride.c

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