MdePkg/Library/UefiDriverModelLib/UefiDriverModelLib.c

   1 /** @file
   2   EFI Driver Model Library.
   3
   4   Copyright (c) 2006, Intel Corporation<BR>
   5   All rights reserved. This program and the accompanying materials
   6   are licensed and made available under the terms and conditions of the BSD License
   7   which accompanies this distribution.  The full text of the license may be found at
   8   http://opensource.org/licenses/bsd-license.php
   9
  10   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13   Module Name:  UefiDriverModelLib.c
  14
  15 **/
  16
  17
  18
  19 /**
  20   The constructor function installs the standard EFI Driver Model Protocols.
  21
  22   @param[in] ImageHandle The firmware allocated handle for the EFI image.
  23   @param[in] SystemTable A pointer to the EFI System Table.
  24
  25   @retval EFI_SUCCESS The constructor always return EFI_SUCCESS.
  26
  27 **/
  28 EFI_STATUS
  29 EFIAPI
  30 UefiDriverModelLibConstructor (
  31   IN EFI_HANDLE        ImageHandle,
  32   IN EFI_SYSTEM_TABLE  *SystemTable
  33   )
  34 {
  35   EFI_STATUS                   Status;
  36   UINTN                        Index;
  37   EFI_HANDLE                   DriverBindingHandle;
  38   EFI_DRIVER_BINDING_PROTOCOL  *DriverBinding;
  39
  40   //
  41   // If no Driver Binding Protocols are advertised by the driver then simply return
  42   //
  43   if (_gDriverModelProtocolListEntries == 0) {
  44     return EFI_SUCCESS;
  45   }
  46
  47   //
  48   // Install the first Driver Bindng Protocol onto ImageHandle
  49   //
  50   DriverBindingHandle = ImageHandle;
  51
  52   //
  53   // See if onle one Driver Binding Protocol is advertised by the driver
  54   //
  55   if (_gDriverModelProtocolListEntries == 1) {
  56     //
  57     // The Driver Binding Protocol must never be NULL
  58     //
  59     ASSERT(_gDriverModelProtocolList[0].DriverBinding != NULL);
  60
  61     //
  62     // Check for all 8 possible combinations of the ComponentName, DriverConfiguration, and DriverDiagnostics Protocol
  63     // These are all checks against const pointers, so the optimizing compiler will only select one of the
  64     // calls to InstallMultipleProtocolInterfaces()
  65     //
  66     if (_gDriverModelProtocolList[0].DriverDiagnostics == NULL) {
  67       if (_gDriverModelProtocolList[0].DriverConfiguration == NULL) {
  68         if (_gDriverModelProtocolList[0].ComponentName == NULL) {
  69           Status = gBS->InstallMultipleProtocolInterfaces (
  70                           &DriverBindingHandle,
  71                           &gEfiDriverBindingProtocolGuid, (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
  72                           NULL
  73                           );
  74         } else {
  75           Status = gBS->InstallMultipleProtocolInterfaces (
  76                           &DriverBindingHandle,
  77                           &gEfiDriverBindingProtocolGuid, (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
  78                           &gEfiComponentNameProtocolGuid, (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[0].ComponentName,
  79                           NULL
  80                           );
  81         }
  82       } else {
  83         if (_gDriverModelProtocolList[0].ComponentName == NULL) {
  84           Status = gBS->InstallMultipleProtocolInterfaces (
  85                           &DriverBindingHandle,
  86                           &gEfiDriverBindingProtocolGuid,       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
  87                           &gEfiDriverConfigurationProtocolGuid, (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[0].DriverConfiguration,
  88                           NULL
  89                           );
  90         } else {
  91           Status = gBS->InstallMultipleProtocolInterfaces (
  92                           &DriverBindingHandle,
  93                           &gEfiDriverBindingProtocolGuid,       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
  94                           &gEfiComponentNameProtocolGuid,       (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[0].ComponentName,
  95                           &gEfiDriverConfigurationProtocolGuid, (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[0].DriverConfiguration,
  96                           NULL
  97                           );
  98         }
  99       }
 100     } else {
 101       if (_gDriverModelProtocolList[0].DriverConfiguration == NULL) {
 102         if (_gDriverModelProtocolList[0].ComponentName == NULL) {
 103           Status = gBS->InstallMultipleProtocolInterfaces (
 104                           &DriverBindingHandle,
 105                           &gEfiDriverBindingProtocolGuid,     (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 106                           &gEfiDriverDiagnosticsProtocolGuid, (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[0].DriverDiagnostics,
 107                           NULL
 108                           );
 109         } else {
 110           Status = gBS->InstallMultipleProtocolInterfaces (
 111                           &DriverBindingHandle,
 112                           &gEfiDriverBindingProtocolGuid,     (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 113                           &gEfiComponentNameProtocolGuid,     (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[0].ComponentName,
 114                           &gEfiDriverDiagnosticsProtocolGuid, (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[0].DriverDiagnostics,
 115                           NULL
 116                           );
 117         }
 118       } else {
 119         if (_gDriverModelProtocolList[0].ComponentName == NULL) {
 120           Status = gBS->InstallMultipleProtocolInterfaces (
 121                           &DriverBindingHandle,
 122                           &gEfiDriverBindingProtocolGuid,       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 123                           &gEfiDriverConfigurationProtocolGuid, (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[0].DriverConfiguration,
 124                           &gEfiDriverDiagnosticsProtocolGuid,   (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[0].DriverDiagnostics,
 125                           NULL
 126                           );
 127         } else {
 128           Status = gBS->InstallMultipleProtocolInterfaces (
 129                           &DriverBindingHandle,
 130                           &gEfiDriverBindingProtocolGuid,       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 131                           &gEfiComponentNameProtocolGuid,       (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[0].ComponentName,
 132                           &gEfiDriverConfigurationProtocolGuid, (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[0].DriverConfiguration,
 133                           &gEfiDriverDiagnosticsProtocolGuid,   (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[0].DriverDiagnostics,
 134                           NULL
 135                           );
 136         }
 137       }
 138     }
 139
 140     //
 141     // ASSERT if the call to InstallMultipleProtocolInterfaces() failed
 142     //
 143     ASSERT_EFI_ERROR (Status);
 144
 145     //
 146     // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
 147     //
 148     DriverBinding = (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding;
 149     DriverBinding->ImageHandle         = ImageHandle;
 150     DriverBinding->DriverBindingHandle = DriverBindingHandle;
 151
 152   } else {
 153     for (Index = 0; Index < _gDriverModelProtocolListEntries; Index++) {
 154       //
 155       // The Driver Binding Protocol must never be NULL
 156       //
 157       ASSERT(_gDriverModelProtocolList[Index].DriverBinding != NULL);
 158
 159       //
 160       // Install the Driver Binding Protocol and ASSERT() if the installation fails
 161       //
 162       Status = gBS->InstallProtocolInterface (
 163                       &DriverBindingHandle,
 164                       &gEfiDriverBindingProtocolGuid,
 165                       EFI_NATIVE_INTERFACE,
 166                       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[Index].DriverBinding
 167                       );
 168       ASSERT_EFI_ERROR (Status);
 169
 170       //
 171       // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
 172       //
 173       DriverBinding = (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[Index].DriverBinding;
 174       DriverBinding->ImageHandle         = ImageHandle;
 175       DriverBinding->DriverBindingHandle = DriverBindingHandle;
 176
 177       //
 178       // If Component Name Protocol is specified then install it and ASSERT() if the installation fails
 179       //
 180       if ((_gDriverModelProtocolBitmask & UEFI_DRIVER_MODEL_LIBRARY_COMPONENT_NAME_PROTOCOL_ENABLED) != 0) {
 181         if (_gDriverModelProtocolList[Index].ComponentName != NULL) {
 182           Status = gBS->InstallProtocolInterface (
 183                           &DriverBindingHandle,
 184                           &gEfiComponentNameProtocolGuid,
 185                           EFI_NATIVE_INTERFACE,
 186                           (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[Index].ComponentName
 187                           );
 188           ASSERT_EFI_ERROR (Status);
 189         }
 190       }
 191
 192       //
 193       // If Driver Configuration Protocol is specified then install it and ASSERT() if the installation fails
 194       //
 195       if ((_gDriverModelProtocolBitmask & UEFI_DRIVER_MODEL_LIBRARY_DRIVER_CONFIGURATION_PROTOCOL_ENABLED) != 0) {
 196         if (_gDriverModelProtocolList[Index].DriverConfiguration != NULL) {
 197           Status = gBS->InstallProtocolInterface (
 198                           &DriverBindingHandle,
 199                           &gEfiDriverConfigurationProtocolGuid,
 200                           EFI_NATIVE_INTERFACE,
 201                           (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[Index].DriverConfiguration
 202                           );
 203           ASSERT_EFI_ERROR (Status);
 204         }
 205       }
 206
 207       //
 208       // If Driver Diagnostics Protocol is specified then install it and ASSERT() if the installation fails
 209       //
 210       if ((_gDriverModelProtocolBitmask & UEFI_DRIVER_MODEL_LIBRARY_DRIVER_DIAGNOSTICS_PROTOCOL_ENABLED) != 0) {
 211         if (_gDriverModelProtocolList[Index].DriverDiagnostics != NULL) {
 212           Status = gBS->InstallProtocolInterface (
 213                           &DriverBindingHandle,
 214                           &gEfiDriverDiagnosticsProtocolGuid,
 215                           EFI_NATIVE_INTERFACE,
 216                           (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[Index].DriverDiagnostics
 217                           );
 218           ASSERT_EFI_ERROR (Status);
 219         }
 220       }
 221
 222       //
 223       // Install subsequent Driver Bindng Protocols onto new handles
 224       //
 225       DriverBindingHandle = NULL;
 226     }
 227   }
 228   return EFI_SUCCESS;
 229 }
 230
 231 /**
 232   The destructor function uninstalls the standard EFI Driver Model Protocols.
 233
 234   @param[in] ImageHandle The firmware allocated handle for the EFI image.
 235   @param[in] SystemTable A pointer to the EFI System Table.
 236
 237   @retval EFI_SUCCESS The destructor always return EFI_SUCCESS.
 238
 239 **/
 240 EFI_STATUS
 241 EFIAPI
 242 UefiDriverModelLibDestructor (
 243   IN EFI_HANDLE        ImageHandle,
 244   IN EFI_SYSTEM_TABLE  *SystemTable
 245   )
 246 {
 247   EFI_STATUS  Status;
 248   UINTN       Index;
 249   EFI_HANDLE  DriverBindingHandle;
 250
 251   //
 252   // If no Driver Binding Protocols are advertised by the driver then simply return
 253   //
 254   if (_gDriverModelProtocolListEntries == 0) {
 255     return EFI_SUCCESS;
 256   }
 257
 258   //
 259   // See if onle one Driver Binding Protocol is advertised by the driver
 260   //
 261   if (_gDriverModelProtocolListEntries == 1) {
 262     //
 263     // The Driver Binding Protocol must never be NULL
 264     //
 265     ASSERT(_gDriverModelProtocolList[0].DriverBinding != NULL);
 266
 267     //
 268     // Retrieve the DriverBindingHandle from the Driver Binding Protocol
 269     //
 270     DriverBindingHandle = _gDriverModelProtocolList[0].DriverBinding->DriverBindingHandle;
 271
 272     //
 273     // Check for all 8 possible combinations of the ComponentName, DriverConfiguration, and DriverDiagnostics Protocol
 274     // These are all checks against const pointers, so the optimizing compiler will only select one of the
 275     // calls to InstallMultipleProtocolInterfaces()
 276     //
 277     if (_gDriverModelProtocolList[0].DriverDiagnostics == NULL) {
 278       if (_gDriverModelProtocolList[0].DriverConfiguration == NULL) {
 279         if (_gDriverModelProtocolList[0].ComponentName == NULL) {
 280           Status = gBS->UninstallMultipleProtocolInterfaces (
 281                           DriverBindingHandle,
 282                           &gEfiDriverBindingProtocolGuid, (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 283                           NULL
 284                           );
 285         } else {
 286           Status = gBS->UninstallMultipleProtocolInterfaces (
 287                           &DriverBindingHandle,
 288                           &gEfiDriverBindingProtocolGuid, (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 289                           &gEfiComponentNameProtocolGuid, (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[0].ComponentName,
 290                           NULL
 291                           );
 292         }
 293       } else {
 294         if (_gDriverModelProtocolList[0].ComponentName == NULL) {
 295           Status = gBS->UninstallMultipleProtocolInterfaces (
 296                           &DriverBindingHandle,
 297                           &gEfiDriverBindingProtocolGuid,       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 298                           &gEfiDriverConfigurationProtocolGuid, (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[0].DriverConfiguration,
 299                           NULL
 300                           );
 301         } else {
 302           Status = gBS->UninstallMultipleProtocolInterfaces (
 303                           &DriverBindingHandle,
 304                           &gEfiDriverBindingProtocolGuid,       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 305                           &gEfiComponentNameProtocolGuid,       (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[0].ComponentName,
 306                           &gEfiDriverConfigurationProtocolGuid, (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[0].DriverConfiguration,
 307                           NULL
 308                           );
 309         }
 310       }
 311     } else {
 312       if (_gDriverModelProtocolList[0].DriverConfiguration == NULL) {
 313         if (_gDriverModelProtocolList[0].ComponentName == NULL) {
 314           Status = gBS->UninstallMultipleProtocolInterfaces (
 315                           &DriverBindingHandle,
 316                           &gEfiDriverBindingProtocolGuid,     (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 317                           &gEfiDriverDiagnosticsProtocolGuid, (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[0].DriverDiagnostics,
 318                           NULL
 319                           );
 320         } else {
 321           Status = gBS->UninstallMultipleProtocolInterfaces (
 322                           &DriverBindingHandle,
 323                           &gEfiDriverBindingProtocolGuid,     (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 324                           &gEfiComponentNameProtocolGuid,     (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[0].ComponentName,
 325                           &gEfiDriverDiagnosticsProtocolGuid, (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[0].DriverDiagnostics,
 326                           NULL
 327                           );
 328         }
 329       } else {
 330         if (_gDriverModelProtocolList[0].ComponentName == NULL) {
 331           Status = gBS->UninstallMultipleProtocolInterfaces (
 332                           &DriverBindingHandle,
 333                           &gEfiDriverBindingProtocolGuid,       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 334                           &gEfiDriverConfigurationProtocolGuid, (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[0].DriverConfiguration,
 335                           &gEfiDriverDiagnosticsProtocolGuid,   (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[0].DriverDiagnostics,
 336                           NULL
 337                           );
 338         } else {
 339           Status = gBS->UninstallMultipleProtocolInterfaces (
 340                           &DriverBindingHandle,
 341                           &gEfiDriverBindingProtocolGuid,       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[0].DriverBinding,
 342                           &gEfiComponentNameProtocolGuid,       (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[0].ComponentName,
 343                           &gEfiDriverConfigurationProtocolGuid, (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[0].DriverConfiguration,
 344                           &gEfiDriverDiagnosticsProtocolGuid,   (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[0].DriverDiagnostics,
 345                           NULL
 346                           );
 347         }
 348       }
 349     }
 350
 351     //
 352     // ASSERT if the call to UninstallMultipleProtocolInterfaces() failed
 353     //
 354     ASSERT_EFI_ERROR (Status);
 355   } else {
 356     for (Index = 0; Index < _gDriverModelProtocolListEntries; Index++) {
 357       //
 358       // The Driver Binding Protocol must never be NULL
 359       //
 360       ASSERT(_gDriverModelProtocolList[Index].DriverBinding != NULL);
 361
 362       //
 363       // Retrieve the DriverBindingHandle from the Driver Binding Protocol
 364       //
 365       DriverBindingHandle = _gDriverModelProtocolList[0].DriverBinding->DriverBindingHandle;
 366
 367       //
 368       // Uninstall the Driver Binding Protocol and ASSERT() if the installation fails
 369       //
 370       Status = gBS->UninstallProtocolInterface (
 371                       DriverBindingHandle,
 372                       &gEfiDriverBindingProtocolGuid,
 373                       (EFI_DRIVER_BINDING_PROTOCOL *)_gDriverModelProtocolList[Index].DriverBinding
 374                       );
 375       ASSERT_EFI_ERROR (Status);
 376
 377       //
 378       // If Component Name Protocol is specified then uninstall it and ASSERT() if the uninstallation fails
 379       //
 380       if ((_gDriverModelProtocolBitmask & UEFI_DRIVER_MODEL_LIBRARY_COMPONENT_NAME_PROTOCOL_ENABLED) != 0) {
 381         if (_gDriverModelProtocolList[Index].ComponentName != NULL) {
 382           Status = gBS->UninstallProtocolInterface (
 383                           DriverBindingHandle,
 384                           &gEfiComponentNameProtocolGuid,
 385                           (EFI_COMPONENT_NAME_PROTOCOL *)_gDriverModelProtocolList[Index].ComponentName
 386                           );
 387           ASSERT_EFI_ERROR (Status);
 388         }
 389       }
 390
 391       //
 392       // If Driver Configuration Protocol is specified then uninstall it and ASSERT() if the uninstallation fails
 393       //
 394       if ((_gDriverModelProtocolBitmask & UEFI_DRIVER_MODEL_LIBRARY_DRIVER_CONFIGURATION_PROTOCOL_ENABLED) != 0) {
 395         if (_gDriverModelProtocolList[Index].DriverConfiguration != NULL) {
 396           Status = gBS->UninstallProtocolInterface (
 397                           DriverBindingHandle,
 398                           &gEfiDriverConfigurationProtocolGuid,
 399                           (EFI_DRIVER_CONFIGURATION_PROTOCOL *)_gDriverModelProtocolList[Index].DriverConfiguration
 400                           );
 401           ASSERT_EFI_ERROR (Status);
 402         }
 403       }
 404
 405       //
 406       // If Driver Diagnostics Protocol is specified then uninstall it and ASSERT() if the uninstallation fails
 407       //
 408       if ((_gDriverModelProtocolBitmask & UEFI_DRIVER_MODEL_LIBRARY_DRIVER_DIAGNOSTICS_PROTOCOL_ENABLED) != 0) {
 409         if (_gDriverModelProtocolList[Index].DriverDiagnostics != NULL) {
 410           Status = gBS->UninstallProtocolInterface (
 411                           DriverBindingHandle,
 412                           &gEfiDriverDiagnosticsProtocolGuid,
 413                           (EFI_DRIVER_DIAGNOSTICS_PROTOCOL *)_gDriverModelProtocolList[Index].DriverDiagnostics
 414                           );
 415           ASSERT_EFI_ERROR (Status);
 416         }
 417       }
 418     }
 419   }
 420   return EFI_SUCCESS;
 421 }