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