IntelFrameworkPkg/Library/FrameworkUefiLib/UefiDriverModel.c

   1 /** @file
   2   Library functions that abstract driver model protocols
   3   installation.
   4
   5   Copyright (c) 2006 - 2008, Intel Corporation. All rights reserved.<BR>
   6   This program and the accompanying materials are
   7   licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "UefiLibInternal.h"
  17
  18 /**
  19   Installs and completes the initialization of a Driver Binding Protocol instance.
  20
  21   Installs the Driver Binding Protocol specified by DriverBinding onto the handle
  22   specified by DriverBindingHandle. If DriverBindingHandle is NULL, then DriverBinding
  23   is installed onto a newly created handle. DriverBindingHandle is typically the same
  24   as the driver's ImageHandle, but it can be different if the driver produces multiple
  25   Driver Binding Protocols.
  26   If DriverBinding is NULL, then ASSERT().
  27   If DriverBinding can not be installed onto a handle, then ASSERT().
  28
  29   @param  ImageHandle          The image handle of the driver.
  30   @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
  31   @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
  32   @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
  33                                parameter is NULL, then a new handle is created.
  34
  35   @retval EFI_SUCCESS           The protocol installation is completed successfully.
  36   @retval EFI_OUT_OF_RESOURCES  There was not enough system resources to install the protocol.
  37   @retval Others                Status from gBS->InstallMultipleProtocolInterfaces().
  38 **/
  39 EFI_STATUS
  40 EFIAPI
  41 EfiLibInstallDriverBinding (
  42   IN CONST EFI_HANDLE               ImageHandle,
  43   IN CONST EFI_SYSTEM_TABLE         *SystemTable,
  44   IN EFI_DRIVER_BINDING_PROTOCOL    *DriverBinding,
  45   IN EFI_HANDLE                     DriverBindingHandle
  46   )
  47 {
  48   EFI_STATUS                        Status;
  49
  50   ASSERT (DriverBinding != NULL);
  51
  52   Status = gBS->InstallMultipleProtocolInterfaces (
  53                   &DriverBindingHandle,
  54                   &gEfiDriverBindingProtocolGuid, DriverBinding,
  55                   NULL
  56                   );
  57   ASSERT_EFI_ERROR (Status);
  58
  59   //
  60   // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
  61   //
  62   DriverBinding->ImageHandle         = ImageHandle;
  63   DriverBinding->DriverBindingHandle = DriverBindingHandle;
  64
  65   return Status;
  66 }
  67
  68 /**
  69   Installs and completes the initialization of a Driver Binding Protocol instance and
  70   optionally installs the Component Name, Driver Configuration and Driver Diagnostics Protocols.
  71
  72   Initializes a driver by installing the Driver Binding Protocol together with the
  73   optional Component Name, optional Driver Configure and optional Driver Diagnostic
  74   Protocols onto the driver's DriverBindingHandle. If DriverBindingHandle is NULL,
  75   then the protocols are  installed onto a newly created handle. DriverBindingHandle
  76   is typically the same as the driver's ImageHandle, but it can be different if the
  77   driver produces multiple Driver Binding Protocols.
  78   If DriverBinding is NULL, then ASSERT().
  79   If the installation fails, then ASSERT().
  80
  81   @param  ImageHandle          The image handle of the driver.
  82   @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
  83   @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
  84   @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
  85                                parameter is NULL, then a new handle is created.
  86   @param  ComponentName        A Component Name Protocol instance that this driver is producing.
  87   @param  DriverConfiguration  A Driver Configuration Protocol instance that this driver is producing.
  88   @param  DriverDiagnostics    A Driver Diagnostics Protocol instance that this driver is producing.
  89
  90   @retval EFI_SUCCESS           The protocol installation is completed successfully.
  91   @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
  92
  93 **/
  94 EFI_STATUS
  95 EFIAPI
  96 EfiLibInstallAllDriverProtocols (
  97   IN CONST EFI_HANDLE                         ImageHandle,
  98   IN CONST EFI_SYSTEM_TABLE                   *SystemTable,
  99   IN EFI_DRIVER_BINDING_PROTOCOL              *DriverBinding,
 100   IN EFI_HANDLE                               DriverBindingHandle,
 101   IN CONST EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,       OPTIONAL
 102   IN CONST EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration, OPTIONAL
 103   IN CONST EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics    OPTIONAL
 104   )
 105 {
 106   EFI_STATUS                                  Status;
 107
 108   if (DriverBinding == NULL) {
 109     return EFI_INVALID_PARAMETER;
 110   }
 111
 112   if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
 113     if (DriverConfiguration == NULL) {
 114       if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 115         Status = gBS->InstallMultipleProtocolInterfaces (
 116                         &DriverBindingHandle,
 117                         &gEfiDriverBindingProtocolGuid, DriverBinding,
 118                         NULL
 119                         );
 120       } else {
 121         Status = gBS->InstallMultipleProtocolInterfaces (
 122                         &DriverBindingHandle,
 123                         &gEfiDriverBindingProtocolGuid, DriverBinding,
 124                         &gEfiComponentNameProtocolGuid, ComponentName,
 125                         NULL
 126                         );
 127       }
 128     } else {
 129       if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 130         Status = gBS->InstallMultipleProtocolInterfaces (
 131                         &DriverBindingHandle,
 132                         &gEfiDriverBindingProtocolGuid,       DriverBinding,
 133                         &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 134                         NULL
 135                         );
 136       } else {
 137         Status = gBS->InstallMultipleProtocolInterfaces (
 138                         &DriverBindingHandle,
 139                         &gEfiDriverBindingProtocolGuid,       DriverBinding,
 140                         &gEfiComponentNameProtocolGuid,       ComponentName,
 141                         &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 142                         NULL
 143                         );
 144       }
 145     }
 146   } else {
 147     if (DriverConfiguration == NULL) {
 148       if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 149         Status = gBS->InstallMultipleProtocolInterfaces (
 150                         &DriverBindingHandle,
 151                         &gEfiDriverBindingProtocolGuid,     DriverBinding,
 152                         &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 153                         NULL
 154                         );
 155       } else {
 156         Status = gBS->InstallMultipleProtocolInterfaces (
 157                         &DriverBindingHandle,
 158                         &gEfiDriverBindingProtocolGuid,     DriverBinding,
 159                         &gEfiComponentNameProtocolGuid,     ComponentName,
 160                         &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 161                         NULL
 162                         );
 163       }
 164     } else {
 165       if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 166        Status = gBS->InstallMultipleProtocolInterfaces (
 167                         &DriverBindingHandle,
 168                         &gEfiDriverBindingProtocolGuid,       DriverBinding,
 169                         &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 170                         &gEfiDriverDiagnosticsProtocolGuid,   DriverDiagnostics,
 171                         NULL
 172                         );
 173       } else {
 174         Status = gBS->InstallMultipleProtocolInterfaces (
 175                         &DriverBindingHandle,
 176                         &gEfiDriverBindingProtocolGuid,       DriverBinding,
 177                         &gEfiComponentNameProtocolGuid,       ComponentName,
 178                         &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 179                         &gEfiDriverDiagnosticsProtocolGuid,   DriverDiagnostics,
 180                         NULL
 181                         );
 182       }
 183     }
 184   }
 185
 186   //
 187   // ASSERT if the call to InstallMultipleProtocolInterfaces() failed
 188   //
 189   ASSERT_EFI_ERROR (Status);
 190
 191   //
 192   // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
 193   //
 194   DriverBinding->ImageHandle         = ImageHandle;
 195   DriverBinding->DriverBindingHandle = DriverBindingHandle;
 196
 197   return Status;
 198 }
 199
 200
 201
 202 /**
 203   Installs Driver Binding Protocol with optional Component Name and Component Name 2 Protocols.
 204
 205   Initializes a driver by installing the Driver Binding Protocol together with the
 206   optional Component Name and optional Component Name 2 protocols onto the driver's
 207   DriverBindingHandle.  If DriverBindingHandle is NULL, then the protocols are installed
 208   onto a newly created handle.  DriverBindingHandle is typically the same as the driver's
 209   ImageHandle, but it can be different if the driver produces multiple Driver Binding Protocols.
 210   If DriverBinding is NULL, then ASSERT().
 211   If the installation fails, then ASSERT().
 212
 213   @param  ImageHandle          The image handle of the driver.
 214   @param  SystemTable          The EFI System Table that was passed to the driver's entry point.
 215   @param  DriverBinding        A Driver Binding Protocol instance that this driver is producing.
 216   @param  DriverBindingHandle  The handle that DriverBinding is to be installed onto.  If this
 217                                parameter is NULL, then a new handle is created.
 218   @param  ComponentName        A Component Name Protocol instance that this driver is producing.
 219   @param  ComponentName2       A Component Name 2 Protocol instance that this driver is producing.
 220
 221   @retval EFI_SUCCESS           The protocol installation is completed successfully.
 222   @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
 223
 224 **/
 225 EFI_STATUS
 226 EFIAPI
 227 EfiLibInstallDriverBindingComponentName2 (
 228   IN CONST EFI_HANDLE                    ImageHandle,
 229   IN CONST EFI_SYSTEM_TABLE              *SystemTable,
 230   IN EFI_DRIVER_BINDING_PROTOCOL         *DriverBinding,
 231   IN EFI_HANDLE                          DriverBindingHandle,
 232   IN CONST EFI_COMPONENT_NAME_PROTOCOL   *ComponentName,  OPTIONAL
 233   IN CONST EFI_COMPONENT_NAME2_PROTOCOL  *ComponentName2  OPTIONAL
 234   )
 235 {
 236   EFI_STATUS                             Status;
 237
 238   ASSERT (DriverBinding != NULL);
 239
 240   if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 241     if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 242       Status = gBS->InstallMultipleProtocolInterfaces (
 243                       &DriverBindingHandle,
 244                       &gEfiDriverBindingProtocolGuid, DriverBinding,
 245                       NULL
 246                       );
 247       } else {
 248       Status = gBS->InstallMultipleProtocolInterfaces (
 249                       &DriverBindingHandle,
 250                       &gEfiDriverBindingProtocolGuid, DriverBinding,
 251                       &gEfiComponentName2ProtocolGuid, ComponentName2,
 252                       NULL
 253                       );
 254      }
 255   } else {
 256      if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 257        Status = gBS->InstallMultipleProtocolInterfaces (
 258                        &DriverBindingHandle,
 259                        &gEfiDriverBindingProtocolGuid, DriverBinding,
 260                        &gEfiComponentNameProtocolGuid, ComponentName,
 261                        NULL
 262                        );
 263      } else {
 264        Status = gBS->InstallMultipleProtocolInterfaces (
 265                        &DriverBindingHandle,
 266                        &gEfiDriverBindingProtocolGuid, DriverBinding,
 267                        &gEfiComponentNameProtocolGuid, ComponentName,
 268                        &gEfiComponentName2ProtocolGuid, ComponentName2,
 269                        NULL
 270                        );
 271     }
 272   }
 273   //
 274   // ASSERT if the call to InstallMultipleProtocolInterfaces() failed
 275   //
 276   ASSERT_EFI_ERROR (Status);
 277
 278   //
 279   // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
 280   //
 281   DriverBinding->ImageHandle         = ImageHandle;
 282   DriverBinding->DriverBindingHandle = DriverBindingHandle;
 283
 284   return Status;
 285 }
 286
 287
 288
 289 /**
 290   Installs Driver Binding Protocol with optional Component Name, Component Name 2, Driver
 291   Configuration, Driver Configuration 2, Driver Diagnostics, and Driver Diagnostics 2 Protocols.
 292
 293   Initializes a driver by installing the Driver Binding Protocol together with the optional
 294   Component Name, optional Component Name 2, optional Driver Configuration, optional Driver
 295   Configuration 2, optional Driver Diagnostic, and optional Driver Diagnostic 2 Protocols
 296   onto the driver's DriverBindingHandle. DriverBindingHandle is typically the same as the
 297   driver's ImageHandle, but it can be different if the driver produces multiple Driver Binding Protocols.
 298   If DriverBinding is NULL, then ASSERT().
 299   If the installation fails, then ASSERT().
 300
 301   @param  ImageHandle           The image handle of the driver.
 302   @param  SystemTable           The EFI System Table that was passed to the driver's entry point.
 303   @param  DriverBinding         A Driver Binding Protocol instance that this driver is producing.
 304   @param  DriverBindingHandle   The handle that DriverBinding is to be installe onto.  If this
 305                                 parameter is NULL, then a new handle is created.
 306   @param  ComponentName         A Component Name Protocol instance that this driver is producing.
 307   @param  ComponentName2        A Component Name 2 Protocol instance that this driver is producing.
 308   @param  DriverConfiguration   A Driver Configuration Protocol instance that this driver is producing.
 309   @param  DriverConfiguration2  A Driver Configuration Protocol 2 instance that this driver is producing.
 310   @param  DriverDiagnostics     A Driver Diagnostics Protocol instance that this driver is producing.
 311   @param  DriverDiagnostics2    A Driver Diagnostics Protocol 2 instance that this driver is producing.
 312
 313   @retval EFI_SUCCESS           The protocol installation is completed successfully.
 314   @retval EFI_OUT_OF_RESOURCES  There was not enough memory in pool to install all the protocols.
 315
 316 **/
 317 EFI_STATUS
 318 EFIAPI
 319 EfiLibInstallAllDriverProtocols2 (
 320   IN CONST EFI_HANDLE                         ImageHandle,
 321   IN CONST EFI_SYSTEM_TABLE                   *SystemTable,
 322   IN EFI_DRIVER_BINDING_PROTOCOL              *DriverBinding,
 323   IN EFI_HANDLE                               DriverBindingHandle,
 324   IN CONST EFI_COMPONENT_NAME_PROTOCOL        *ComponentName,        OPTIONAL
 325   IN CONST EFI_COMPONENT_NAME2_PROTOCOL       *ComponentName2,       OPTIONAL
 326   IN CONST EFI_DRIVER_CONFIGURATION_PROTOCOL  *DriverConfiguration,  OPTIONAL
 327   IN CONST EFI_DRIVER_CONFIGURATION2_PROTOCOL *DriverConfiguration2, OPTIONAL
 328   IN CONST EFI_DRIVER_DIAGNOSTICS_PROTOCOL    *DriverDiagnostics,    OPTIONAL
 329   IN CONST EFI_DRIVER_DIAGNOSTICS2_PROTOCOL   *DriverDiagnostics2    OPTIONAL
 330   )
 331 {
 332   EFI_STATUS  Status;
 333
 334   ASSERT (DriverBinding != NULL);
 335
 336   if (DriverConfiguration2 == NULL) {
 337     if (DriverConfiguration == NULL) {
 338       if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
 339         if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
 340           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 341             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 342               Status = gBS->InstallMultipleProtocolInterfaces (
 343                               &DriverBindingHandle,
 344                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 345                               NULL
 346                               );
 347             } else {
 348               Status = gBS->InstallMultipleProtocolInterfaces (
 349                               &DriverBindingHandle,
 350                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 351                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 352                               NULL
 353                               );
 354             }
 355           } else {
 356             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 357               Status = gBS->InstallMultipleProtocolInterfaces (
 358                               &DriverBindingHandle,
 359                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 360                               &gEfiComponentNameProtocolGuid, ComponentName,
 361                               NULL
 362                               );
 363             } else {
 364               Status = gBS->InstallMultipleProtocolInterfaces (
 365                               &DriverBindingHandle,
 366                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 367                               &gEfiComponentNameProtocolGuid, ComponentName,
 368                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 369                               NULL
 370                               );
 371             }
 372           }
 373         } else {
 374           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 375             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 376               Status = gBS->InstallMultipleProtocolInterfaces (
 377                               &DriverBindingHandle,
 378                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 379                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 380                               NULL
 381                               );
 382             } else {
 383               Status = gBS->InstallMultipleProtocolInterfaces (
 384                               &DriverBindingHandle,
 385                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 386                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 387                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 388                               NULL
 389                               );
 390             }
 391           } else {
 392             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 393               Status = gBS->InstallMultipleProtocolInterfaces (
 394                               &DriverBindingHandle,
 395                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 396                               &gEfiComponentNameProtocolGuid, ComponentName,
 397                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 398                               NULL
 399                               );
 400             } else {
 401               Status = gBS->InstallMultipleProtocolInterfaces (
 402                               &DriverBindingHandle,
 403                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 404                               &gEfiComponentNameProtocolGuid, ComponentName,
 405                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 406                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 407                               NULL
 408                               );
 409             }
 410           }
 411         }
 412       } else {
 413         if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
 414           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 415             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 416               Status = gBS->InstallMultipleProtocolInterfaces (
 417                               &DriverBindingHandle,
 418                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 419                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 420                               NULL
 421                               );
 422             } else {
 423               Status = gBS->InstallMultipleProtocolInterfaces (
 424                               &DriverBindingHandle,
 425                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 426                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 427                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 428                               NULL
 429                               );
 430             }
 431           } else {
 432             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 433               Status = gBS->InstallMultipleProtocolInterfaces (
 434                               &DriverBindingHandle,
 435                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 436                               &gEfiComponentNameProtocolGuid, ComponentName,
 437                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 438                               NULL
 439                               );
 440             } else {
 441               Status = gBS->InstallMultipleProtocolInterfaces (
 442                               &DriverBindingHandle,
 443                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 444                               &gEfiComponentNameProtocolGuid, ComponentName,
 445                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 446                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 447                               NULL
 448                               );
 449             }
 450           }
 451         } else {
 452           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 453             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 454               Status = gBS->InstallMultipleProtocolInterfaces (
 455                               &DriverBindingHandle,
 456                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 457                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 458                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 459                               NULL
 460                               );
 461             } else {
 462               Status = gBS->InstallMultipleProtocolInterfaces (
 463                               &DriverBindingHandle,
 464                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 465                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 466                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 467                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 468                               NULL
 469                               );
 470             }
 471           } else {
 472             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 473               Status = gBS->InstallMultipleProtocolInterfaces (
 474                               &DriverBindingHandle,
 475                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 476                               &gEfiComponentNameProtocolGuid, ComponentName,
 477                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 478                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 479                               NULL
 480                               );
 481             } else {
 482               Status = gBS->InstallMultipleProtocolInterfaces (
 483                               &DriverBindingHandle,
 484                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 485                               &gEfiComponentNameProtocolGuid, ComponentName,
 486                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 487                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 488                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 489                               NULL
 490                               );
 491             }
 492           }
 493         }
 494       }
 495     } else {
 496       if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
 497         if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
 498           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 499             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 500               Status = gBS->InstallMultipleProtocolInterfaces (
 501                               &DriverBindingHandle,
 502                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 503                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 504                               NULL
 505                               );
 506             } else {
 507               Status = gBS->InstallMultipleProtocolInterfaces (
 508                               &DriverBindingHandle,
 509                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 510                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 511                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 512                               NULL
 513                               );
 514             }
 515           } else {
 516             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 517               Status = gBS->InstallMultipleProtocolInterfaces (
 518                               &DriverBindingHandle,
 519                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 520                               &gEfiComponentNameProtocolGuid, ComponentName,
 521                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 522                               NULL
 523                               );
 524             } else {
 525               Status = gBS->InstallMultipleProtocolInterfaces (
 526                               &DriverBindingHandle,
 527                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 528                               &gEfiComponentNameProtocolGuid, ComponentName,
 529                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 530                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 531                               NULL
 532                               );
 533             }
 534           }
 535         } else {
 536           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 537             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 538               Status = gBS->InstallMultipleProtocolInterfaces (
 539                               &DriverBindingHandle,
 540                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 541                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 542                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 543                               NULL
 544                               );
 545             } else {
 546               Status = gBS->InstallMultipleProtocolInterfaces (
 547                               &DriverBindingHandle,
 548                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 549                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 550                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 551                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 552                               NULL
 553                               );
 554             }
 555           } else {
 556             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 557               Status = gBS->InstallMultipleProtocolInterfaces (
 558                               &DriverBindingHandle,
 559                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 560                               &gEfiComponentNameProtocolGuid, ComponentName,
 561                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 562                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 563                               NULL
 564                               );
 565             } else {
 566               Status = gBS->InstallMultipleProtocolInterfaces (
 567                               &DriverBindingHandle,
 568                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 569                               &gEfiComponentNameProtocolGuid, ComponentName,
 570                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 571                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 572                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 573                               NULL
 574                               );
 575             }
 576           }
 577         }
 578       } else {
 579         if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
 580           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 581             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 582               Status = gBS->InstallMultipleProtocolInterfaces (
 583                               &DriverBindingHandle,
 584                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 585                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 586                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 587                               NULL
 588                               );
 589             } else {
 590               Status = gBS->InstallMultipleProtocolInterfaces (
 591                               &DriverBindingHandle,
 592                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 593                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 594                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 595                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 596                               NULL
 597                               );
 598             }
 599           } else {
 600             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 601               Status = gBS->InstallMultipleProtocolInterfaces (
 602                               &DriverBindingHandle,
 603                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 604                               &gEfiComponentNameProtocolGuid, ComponentName,
 605                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 606                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 607                               NULL
 608                               );
 609             } else {
 610               Status = gBS->InstallMultipleProtocolInterfaces (
 611                               &DriverBindingHandle,
 612                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 613                               &gEfiComponentNameProtocolGuid, ComponentName,
 614                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 615                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 616                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 617                               NULL
 618                               );
 619             }
 620           }
 621         } else {
 622           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 623             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 624               Status = gBS->InstallMultipleProtocolInterfaces (
 625                               &DriverBindingHandle,
 626                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 627                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 628                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 629                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 630                               NULL
 631                               );
 632             } else {
 633               Status = gBS->InstallMultipleProtocolInterfaces (
 634                               &DriverBindingHandle,
 635                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 636                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 637                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 638                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 639                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 640                               NULL
 641                               );
 642             }
 643           } else {
 644             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 645               Status = gBS->InstallMultipleProtocolInterfaces (
 646                               &DriverBindingHandle,
 647                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 648                               &gEfiComponentNameProtocolGuid, ComponentName,
 649                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 650                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 651                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 652                               NULL
 653                               );
 654             } else {
 655               Status = gBS->InstallMultipleProtocolInterfaces (
 656                               &DriverBindingHandle,
 657                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 658                               &gEfiComponentNameProtocolGuid, ComponentName,
 659                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 660                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 661                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 662                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 663                               NULL
 664                               );
 665             }
 666           }
 667         }
 668       }
 669     }
 670   } else {
 671     if (DriverConfiguration == NULL) {
 672       if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
 673         if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
 674           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 675             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 676               Status = gBS->InstallMultipleProtocolInterfaces (
 677                               &DriverBindingHandle,
 678                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 679                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 680                               NULL
 681                               );
 682             } else {
 683               Status = gBS->InstallMultipleProtocolInterfaces (
 684                               &DriverBindingHandle,
 685                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 686                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 687                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 688                               NULL
 689                               );
 690             }
 691           } else {
 692             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 693               Status = gBS->InstallMultipleProtocolInterfaces (
 694                               &DriverBindingHandle,
 695                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 696                               &gEfiComponentNameProtocolGuid, ComponentName,
 697                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 698                               NULL
 699                               );
 700             } else {
 701               Status = gBS->InstallMultipleProtocolInterfaces (
 702                               &DriverBindingHandle,
 703                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 704                               &gEfiComponentNameProtocolGuid, ComponentName,
 705                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 706                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 707                               NULL
 708                               );
 709             }
 710           }
 711         } else {
 712           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 713             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 714               Status = gBS->InstallMultipleProtocolInterfaces (
 715                               &DriverBindingHandle,
 716                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 717                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 718                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 719                               NULL
 720                               );
 721             } else {
 722               Status = gBS->InstallMultipleProtocolInterfaces (
 723                               &DriverBindingHandle,
 724                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 725                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 726                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 727                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 728                               NULL
 729                               );
 730             }
 731           } else {
 732             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 733               Status = gBS->InstallMultipleProtocolInterfaces (
 734                               &DriverBindingHandle,
 735                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 736                               &gEfiComponentNameProtocolGuid, ComponentName,
 737                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 738                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 739                               NULL
 740                               );
 741             } else {
 742               Status = gBS->InstallMultipleProtocolInterfaces (
 743                               &DriverBindingHandle,
 744                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 745                               &gEfiComponentNameProtocolGuid, ComponentName,
 746                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 747                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 748                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 749                               NULL
 750                               );
 751             }
 752           }
 753         }
 754       } else {
 755         if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
 756           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 757             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 758               Status = gBS->InstallMultipleProtocolInterfaces (
 759                               &DriverBindingHandle,
 760                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 761                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 762                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 763                               NULL
 764                               );
 765             } else {
 766               Status = gBS->InstallMultipleProtocolInterfaces (
 767                               &DriverBindingHandle,
 768                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 769                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 770                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 771                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 772                               NULL
 773                               );
 774             }
 775           } else {
 776             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 777               Status = gBS->InstallMultipleProtocolInterfaces (
 778                               &DriverBindingHandle,
 779                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 780                               &gEfiComponentNameProtocolGuid, ComponentName,
 781                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 782                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 783                               NULL
 784                               );
 785             } else {
 786               Status = gBS->InstallMultipleProtocolInterfaces (
 787                               &DriverBindingHandle,
 788                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 789                               &gEfiComponentNameProtocolGuid, ComponentName,
 790                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 791                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 792                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 793                               NULL
 794                               );
 795             }
 796           }
 797         } else {
 798           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 799             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 800               Status = gBS->InstallMultipleProtocolInterfaces (
 801                               &DriverBindingHandle,
 802                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 803                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 804                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 805                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 806                               NULL
 807                               );
 808             } else {
 809               Status = gBS->InstallMultipleProtocolInterfaces (
 810                               &DriverBindingHandle,
 811                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 812                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 813                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 814                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 815                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 816                               NULL
 817                               );
 818             }
 819           } else {
 820             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 821               Status = gBS->InstallMultipleProtocolInterfaces (
 822                               &DriverBindingHandle,
 823                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 824                               &gEfiComponentNameProtocolGuid, ComponentName,
 825                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 826                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 827                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 828                               NULL
 829                               );
 830             } else {
 831               Status = gBS->InstallMultipleProtocolInterfaces (
 832                               &DriverBindingHandle,
 833                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 834                               &gEfiComponentNameProtocolGuid, ComponentName,
 835                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 836                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 837                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 838                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 839                               NULL
 840                               );
 841             }
 842           }
 843         }
 844       }
 845     } else {
 846       if (DriverDiagnostics == NULL || FeaturePcdGet(PcdDriverDiagnosticsDisable)) {
 847         if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
 848           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 849             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 850               Status = gBS->InstallMultipleProtocolInterfaces (
 851                               &DriverBindingHandle,
 852                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 853                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 854                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 855                               NULL
 856                               );
 857             } else {
 858               Status = gBS->InstallMultipleProtocolInterfaces (
 859                               &DriverBindingHandle,
 860                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 861                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 862                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 863                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 864                               NULL
 865                               );
 866             }
 867           } else {
 868             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 869               Status = gBS->InstallMultipleProtocolInterfaces (
 870                               &DriverBindingHandle,
 871                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 872                               &gEfiComponentNameProtocolGuid, ComponentName,
 873                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 874                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 875                               NULL
 876                               );
 877             } else {
 878               Status = gBS->InstallMultipleProtocolInterfaces (
 879                               &DriverBindingHandle,
 880                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 881                               &gEfiComponentNameProtocolGuid, ComponentName,
 882                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 883                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 884                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 885                               NULL
 886                               );
 887             }
 888           }
 889         } else {
 890           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 891             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 892               Status = gBS->InstallMultipleProtocolInterfaces (
 893                               &DriverBindingHandle,
 894                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 895                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 896                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 897                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 898                               NULL
 899                               );
 900             } else {
 901               Status = gBS->InstallMultipleProtocolInterfaces (
 902                               &DriverBindingHandle,
 903                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 904                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 905                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 906                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 907                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 908                               NULL
 909                               );
 910             }
 911           } else {
 912             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 913               Status = gBS->InstallMultipleProtocolInterfaces (
 914                               &DriverBindingHandle,
 915                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 916                               &gEfiComponentNameProtocolGuid, ComponentName,
 917                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 918                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 919                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 920                               NULL
 921                               );
 922             } else {
 923               Status = gBS->InstallMultipleProtocolInterfaces (
 924                               &DriverBindingHandle,
 925                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 926                               &gEfiComponentNameProtocolGuid, ComponentName,
 927                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 928                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 929                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 930                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 931                               NULL
 932                               );
 933             }
 934           }
 935         }
 936       } else {
 937         if (DriverDiagnostics2 == NULL || FeaturePcdGet(PcdDriverDiagnostics2Disable)) {
 938           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 939             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 940               Status = gBS->InstallMultipleProtocolInterfaces (
 941                               &DriverBindingHandle,
 942                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 943                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 944                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 945                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 946                               NULL
 947                               );
 948             } else {
 949               Status = gBS->InstallMultipleProtocolInterfaces (
 950                               &DriverBindingHandle,
 951                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 952                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 953                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 954                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 955                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 956                               NULL
 957                               );
 958             }
 959           } else {
 960             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 961               Status = gBS->InstallMultipleProtocolInterfaces (
 962                               &DriverBindingHandle,
 963                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 964                               &gEfiComponentNameProtocolGuid, ComponentName,
 965                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 966                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 967                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 968                               NULL
 969                               );
 970             } else {
 971               Status = gBS->InstallMultipleProtocolInterfaces (
 972                               &DriverBindingHandle,
 973                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 974                               &gEfiComponentNameProtocolGuid, ComponentName,
 975                               &gEfiComponentName2ProtocolGuid, ComponentName2,
 976                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 977                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 978                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 979                               NULL
 980                               );
 981             }
 982           }
 983         } else {
 984           if (ComponentName == NULL || FeaturePcdGet(PcdComponentNameDisable)) {
 985             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
 986               Status = gBS->InstallMultipleProtocolInterfaces (
 987                               &DriverBindingHandle,
 988                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 989                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
 990                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
 991                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
 992                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
 993                               NULL
 994                               );
 995             } else {
 996               Status = gBS->InstallMultipleProtocolInterfaces (
 997                               &DriverBindingHandle,
 998                               &gEfiDriverBindingProtocolGuid, DriverBinding,
 999                               &gEfiComponentName2ProtocolGuid, ComponentName2,
1000                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
1001                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
1002                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
1003                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
1004                               NULL
1005                               );
1006             }
1007           } else {
1008             if (ComponentName2 == NULL || FeaturePcdGet(PcdComponentName2Disable)) {
1009               Status = gBS->InstallMultipleProtocolInterfaces (
1010                               &DriverBindingHandle,
1011                               &gEfiDriverBindingProtocolGuid, DriverBinding,
1012                               &gEfiComponentNameProtocolGuid, ComponentName,
1013                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
1014                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
1015                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
1016                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
1017                               NULL
1018                               );
1019             } else {
1020               Status = gBS->InstallMultipleProtocolInterfaces (
1021                               &DriverBindingHandle,
1022                               &gEfiDriverBindingProtocolGuid, DriverBinding,
1023                               &gEfiComponentNameProtocolGuid, ComponentName,
1024                               &gEfiComponentName2ProtocolGuid, ComponentName2,
1025                               &gEfiDriverConfigurationProtocolGuid, DriverConfiguration,
1026                               &gEfiDriverConfiguration2ProtocolGuid, DriverConfiguration2,
1027                               &gEfiDriverDiagnosticsProtocolGuid, DriverDiagnostics,
1028                               &gEfiDriverDiagnostics2ProtocolGuid, DriverDiagnostics2,
1029                               NULL
1030                               );
1031             }
1032           }
1033         }
1034       }
1035     }
1036   }
1037
1038
1039   //
1040   // ASSERT if the call to InstallMultipleProtocolInterfaces() failed
1041   //
1042   ASSERT_EFI_ERROR (Status);
1043
1044   //
1045   // Update the ImageHandle and DriverBindingHandle fields of the Driver Binding Protocol
1046   //
1047   DriverBinding->ImageHandle         = ImageHandle;
1048   DriverBinding->DriverBindingHandle = DriverBindingHandle;
1049
1050   return Status;
1051 }
1052
1053