NetworkPkg/UefiPxeBcDxe/PxeBcDriver.c

   1 /** @file
   2   Driver Binding functions implementationfor for UefiPxeBc Driver.
   3
   4   (C) Copyright 2014 Hewlett-Packard Development Company, L.P.<BR>
   5   Copyright (c) 2007 - 2015, Intel Corporation. All rights reserved.<BR>
   6
   7   This program and the accompanying materials
   8   are licensed and made available under the terms and conditions of the BSD License
   9   which accompanies this distribution.  The full text of the license may be found at
  10   http://opensource.org/licenses/bsd-license.php.
  11
  12   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  13   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  14
  15 **/
  16
  17 #include "PxeBcImpl.h"
  18
  19
  20 EFI_DRIVER_BINDING_PROTOCOL gPxeBcIp4DriverBinding = {
  21   PxeBcIp4DriverBindingSupported,
  22   PxeBcIp4DriverBindingStart,
  23   PxeBcIp4DriverBindingStop,
  24   0xa,
  25   NULL,
  26   NULL
  27 };
  28
  29 EFI_DRIVER_BINDING_PROTOCOL gPxeBcIp6DriverBinding = {
  30   PxeBcIp6DriverBindingSupported,
  31   PxeBcIp6DriverBindingStart,
  32   PxeBcIp6DriverBindingStop,
  33   0xa,
  34   NULL,
  35   NULL
  36 };
  37
  38 /**
  39   Get the Nic handle using any child handle in the IPv4 stack.
  40
  41   @param[in]  ControllerHandle    Pointer to child handle over IPv4.
  42
  43   @return NicHandle               The pointer to the Nic handle.
  44
  45 **/
  46 EFI_HANDLE
  47 PxeBcGetNicByIp4Children (
  48   IN EFI_HANDLE                 ControllerHandle
  49   )
  50 {
  51   EFI_HANDLE                    NicHandle;
  52
  53   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiArpProtocolGuid);
  54   if (NicHandle == NULL) {
  55     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp4ProtocolGuid);
  56     if (NicHandle == NULL) {
  57       NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp4ProtocolGuid);
  58       if (NicHandle == NULL) {
  59         NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiDhcp4ProtocolGuid);
  60         if (NicHandle == NULL) {
  61           NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiMtftp4ProtocolGuid);
  62           if (NicHandle == NULL) {
  63             return NULL;
  64           }
  65         }
  66       }
  67     }
  68   }
  69
  70   return NicHandle;
  71 }
  72
  73
  74 /**
  75   Get the Nic handle using any child handle in the IPv6 stack.
  76
  77   @param[in]  ControllerHandle    Pointer to child handle over IPv6.
  78
  79   @return NicHandle               The pointer to the Nic handle.
  80
  81 **/
  82 EFI_HANDLE
  83 PxeBcGetNicByIp6Children (
  84   IN EFI_HANDLE                  ControllerHandle
  85   )
  86 {
  87   EFI_HANDLE                     NicHandle;
  88
  89   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp6ProtocolGuid);
  90   if (NicHandle == NULL) {
  91     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiUdp6ProtocolGuid);
  92     if (NicHandle == NULL) {
  93       NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiDhcp6ProtocolGuid);
  94       if (NicHandle == NULL) {
  95         NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiMtftp6ProtocolGuid);
  96         if (NicHandle == NULL) {
  97           return NULL;
  98         }
  99       }
 100     }
 101   }
 102
 103   return NicHandle;
 104 }
 105
 106
 107 /**
 108   Destroy the opened instances based on IPv4.
 109
 110   @param[in]  This              Pointer to the EFI_DRIVER_BINDING_PROTOCOL.
 111   @param[in]  Private           Pointer to PXEBC_PRIVATE_DATA.
 112
 113 **/
 114 VOID
 115 PxeBcDestroyIp4Children (
 116   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 117   IN PXEBC_PRIVATE_DATA           *Private
 118   )
 119 {
 120   ASSERT(Private != NULL);
 121
 122   if (Private->ArpChild != NULL) {
 123     //
 124     // Close Arp for PxeBc->Arp and destroy the instance.
 125     //
 126     gBS->CloseProtocol (
 127            Private->ArpChild,
 128            &gEfiArpProtocolGuid,
 129            This->DriverBindingHandle,
 130            Private->Controller
 131            );
 132
 133     NetLibDestroyServiceChild (
 134       Private->Controller,
 135       This->DriverBindingHandle,
 136       &gEfiArpServiceBindingProtocolGuid,
 137       Private->ArpChild
 138       );
 139   }
 140
 141   if (Private->Ip4Child != NULL) {
 142     //
 143     // Close Ip4 for background ICMP error message and destroy the instance.
 144     //
 145     gBS->CloseProtocol (
 146            Private->Ip4Child,
 147            &gEfiIp4ProtocolGuid,
 148            This->DriverBindingHandle,
 149            Private->Controller
 150            );
 151
 152     NetLibDestroyServiceChild (
 153       Private->Controller,
 154       This->DriverBindingHandle,
 155       &gEfiIp4ServiceBindingProtocolGuid,
 156       Private->Ip4Child
 157       );
 158   }
 159
 160   if (Private->Udp4WriteChild != NULL) {
 161     //
 162     // Close Udp4 for PxeBc->UdpWrite and destroy the instance.
 163     //
 164     gBS->CloseProtocol (
 165            Private->Udp4WriteChild,
 166            &gEfiUdp4ProtocolGuid,
 167            This->DriverBindingHandle,
 168            Private->Controller
 169            );
 170
 171     NetLibDestroyServiceChild (
 172       Private->Controller,
 173       This->DriverBindingHandle,
 174       &gEfiUdp4ServiceBindingProtocolGuid,
 175       Private->Udp4WriteChild
 176       );
 177   }
 178
 179   if (Private->Udp4ReadChild != NULL) {
 180     //
 181     // Close Udp4 for PxeBc->UdpRead and destroy the instance.
 182     //
 183     gBS->CloseProtocol (
 184           Private->Udp4ReadChild,
 185           &gEfiUdp4ProtocolGuid,
 186           This->DriverBindingHandle,
 187           Private->Controller
 188           );
 189
 190     NetLibDestroyServiceChild (
 191       Private->Controller,
 192       This->DriverBindingHandle,
 193       &gEfiUdp4ServiceBindingProtocolGuid,
 194       Private->Udp4ReadChild
 195       );
 196   }
 197
 198   if (Private->Mtftp4Child != NULL) {
 199     //
 200     // Close Mtftp4 for PxeBc->Mtftp4 and destroy the instance.
 201     //
 202     gBS->CloseProtocol (
 203           Private->Mtftp4Child,
 204           &gEfiMtftp4ProtocolGuid,
 205           This->DriverBindingHandle,
 206           Private->Controller
 207           );
 208
 209     NetLibDestroyServiceChild (
 210       Private->Controller,
 211       This->DriverBindingHandle,
 212       &gEfiMtftp4ServiceBindingProtocolGuid,
 213       Private->Mtftp4Child
 214       );
 215   }
 216
 217   if (Private->Dhcp4Child != NULL) {
 218     //
 219     // Close Dhcp4 for PxeBc->Dhcp4 and destroy the instance.
 220     //
 221     gBS->CloseProtocol (
 222           Private->Dhcp4Child,
 223           &gEfiDhcp4ProtocolGuid,
 224           This->DriverBindingHandle,
 225           Private->Controller
 226           );
 227
 228     NetLibDestroyServiceChild (
 229       Private->Controller,
 230       This->DriverBindingHandle,
 231       &gEfiDhcp4ServiceBindingProtocolGuid,
 232       Private->Dhcp4Child
 233       );
 234   }
 235
 236   if (Private->Ip4Nic != NULL) {
 237     //
 238     // Close PxeBcPrivate from the parent Nic handle and destroy the virtual handle.
 239     //
 240     gBS->CloseProtocol (
 241            Private->Controller,
 242            &gEfiCallerIdGuid,
 243            This->DriverBindingHandle,
 244            Private->Ip4Nic->Controller
 245            );
 246
 247     gBS->UninstallMultipleProtocolInterfaces (
 248            Private->Ip4Nic->Controller,
 249            &gEfiDevicePathProtocolGuid,
 250            Private->Ip4Nic->DevicePath,
 251            &gEfiLoadFileProtocolGuid,
 252            &Private->Ip4Nic->LoadFile,
 253            &gEfiPxeBaseCodeProtocolGuid,
 254            &Private->PxeBc,
 255            NULL
 256            );
 257
 258     if (Private->Snp != NULL) {
 259       //
 260       // Close SNP from the child virtual handle
 261       //
 262       gBS->CloseProtocol (
 263              Private->Ip4Nic->Controller,
 264              &gEfiSimpleNetworkProtocolGuid,
 265              This->DriverBindingHandle,
 266              Private->Ip4Nic->Controller
 267              );
 268
 269       gBS->UninstallProtocolInterface (
 270              Private->Ip4Nic->Controller,
 271              &gEfiSimpleNetworkProtocolGuid,
 272              Private->Snp
 273              );
 274     }
 275     FreePool (Private->Ip4Nic);
 276   }
 277
 278   Private->ArpChild         = NULL;
 279   Private->Ip4Child         = NULL;
 280   Private->Udp4WriteChild   = NULL;
 281   Private->Udp4ReadChild    = NULL;
 282   Private->Mtftp4Child      = NULL;
 283   Private->Dhcp4Child       = NULL;
 284   Private->Ip4Nic           = NULL;
 285 }
 286
 287
 288 /**
 289   Destroy the opened instances based on IPv6.
 290
 291   @param[in]  This              Pointer to the EFI_DRIVER_BINDING_PROTOCOL.
 292   @param[in]  Private           Pointer to PXEBC_PRIVATE_DATA.
 293
 294 **/
 295 VOID
 296 PxeBcDestroyIp6Children (
 297   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 298   IN PXEBC_PRIVATE_DATA           *Private
 299   )
 300 {
 301   ASSERT(Private != NULL);
 302
 303   if (Private->Ip6Child != NULL) {
 304     //
 305     // Close Ip6 for Ip6->Ip6Config and destroy the instance.
 306     //
 307     gBS->CloseProtocol (
 308           Private->Ip6Child,
 309           &gEfiIp6ProtocolGuid,
 310           This->DriverBindingHandle,
 311           Private->Controller
 312           );
 313
 314     NetLibDestroyServiceChild (
 315       Private->Controller,
 316       This->DriverBindingHandle,
 317       &gEfiIp6ServiceBindingProtocolGuid,
 318       Private->Ip6Child
 319       );
 320   }
 321
 322   if (Private->Udp6WriteChild != NULL) {
 323     //
 324     // Close Udp6 for PxeBc->UdpWrite and destroy the instance.
 325     //
 326     gBS->CloseProtocol (
 327            Private->Udp6WriteChild,
 328            &gEfiUdp6ProtocolGuid,
 329            This->DriverBindingHandle,
 330            Private->Controller
 331            );
 332     NetLibDestroyServiceChild (
 333       Private->Controller,
 334       This->DriverBindingHandle,
 335       &gEfiUdp6ServiceBindingProtocolGuid,
 336       Private->Udp6WriteChild
 337       );
 338   }
 339
 340   if (Private->Udp6ReadChild != NULL) {
 341     //
 342     // Close Udp6 for PxeBc->UdpRead and destroy the instance.
 343     //
 344     gBS->CloseProtocol (
 345           Private->Udp6ReadChild,
 346           &gEfiUdp6ProtocolGuid,
 347           This->DriverBindingHandle,
 348           Private->Controller
 349           );
 350     NetLibDestroyServiceChild (
 351       Private->Controller,
 352       This->DriverBindingHandle,
 353       &gEfiUdp6ServiceBindingProtocolGuid,
 354       Private->Udp6ReadChild
 355       );
 356   }
 357
 358   if (Private->Mtftp6Child != NULL) {
 359     //
 360     // Close Mtftp6 for PxeBc->Mtftp and destroy the instance.
 361     //
 362     gBS->CloseProtocol (
 363           Private->Mtftp6Child,
 364           &gEfiMtftp6ProtocolGuid,
 365           This->DriverBindingHandle,
 366           Private->Controller
 367           );
 368
 369     NetLibDestroyServiceChild (
 370       Private->Controller,
 371       This->DriverBindingHandle,
 372       &gEfiMtftp6ServiceBindingProtocolGuid,
 373       Private->Mtftp6Child
 374       );
 375   }
 376
 377   if (Private->Dhcp6Child != NULL) {
 378     //
 379     // Close Dhcp6 for PxeBc->Dhcp and destroy the instance.
 380     //
 381     gBS->CloseProtocol (
 382           Private->Dhcp6Child,
 383           &gEfiDhcp6ProtocolGuid,
 384           This->DriverBindingHandle,
 385           Private->Controller
 386           );
 387
 388     NetLibDestroyServiceChild (
 389       Private->Controller,
 390       This->DriverBindingHandle,
 391       &gEfiDhcp6ServiceBindingProtocolGuid,
 392       Private->Dhcp6Child
 393       );
 394   }
 395
 396   if (Private->Ip6Nic != NULL) {
 397     //
 398     // Close PxeBcPrivate from the parent Nic handle and destroy the virtual handle.
 399     //
 400     gBS->CloseProtocol (
 401            Private->Controller,
 402            &gEfiCallerIdGuid,
 403            This->DriverBindingHandle,
 404            Private->Ip6Nic->Controller
 405            );
 406
 407     gBS->UninstallMultipleProtocolInterfaces (
 408            Private->Ip6Nic->Controller,
 409            &gEfiDevicePathProtocolGuid,
 410            Private->Ip6Nic->DevicePath,
 411            &gEfiLoadFileProtocolGuid,
 412            &Private->Ip6Nic->LoadFile,
 413            &gEfiPxeBaseCodeProtocolGuid,
 414            &Private->PxeBc,
 415            NULL
 416            );
 417     if (Private->Snp != NULL) {
 418       //
 419       // Close SNP from the child virtual handle
 420       //
 421       gBS->CloseProtocol (
 422              Private->Ip6Nic->Controller,
 423              &gEfiSimpleNetworkProtocolGuid,
 424              This->DriverBindingHandle,
 425              Private->Ip6Nic->Controller
 426              );
 427       gBS->UninstallProtocolInterface (
 428              Private->Ip6Nic->Controller,
 429              &gEfiSimpleNetworkProtocolGuid,
 430              Private->Snp
 431              );
 432     }
 433     FreePool (Private->Ip6Nic);
 434   }
 435
 436   Private->Ip6Child           = NULL;
 437   Private->Udp6WriteChild     = NULL;
 438   Private->Udp6ReadChild      = NULL;
 439   Private->Mtftp6Child        = NULL;
 440   Private->Dhcp6Child         = NULL;
 441   Private->Ip6Nic             = NULL;
 442   Private->Mode.Ipv6Available = FALSE;
 443 }
 444
 445 /**
 446   Check whether UNDI protocol supports IPv6.
 447
 448   @param[in]   ControllerHandle  Controller handle.
 449   @param[in]   Private           Pointer to PXEBC_PRIVATE_DATA.
 450   @param[out]  Ipv6Support       TRUE if UNDI supports IPv6.
 451
 452   @retval EFI_SUCCESS            Get the result whether UNDI supports IPv6 by NII or AIP protocol successfully.
 453   @retval EFI_NOT_FOUND          Don't know whether UNDI supports IPv6 since NII or AIP is not available.
 454
 455 **/
 456 EFI_STATUS
 457 PxeBcCheckIpv6Support (
 458   IN  EFI_HANDLE                   ControllerHandle,
 459   IN  PXEBC_PRIVATE_DATA           *Private,
 460   OUT BOOLEAN                      *Ipv6Support
 461   )
 462 {
 463   EFI_HANDLE                       Handle;
 464   EFI_ADAPTER_INFORMATION_PROTOCOL *Aip;
 465   EFI_STATUS                       Status;
 466   EFI_GUID                         *InfoTypesBuffer;
 467   UINTN                            InfoTypeBufferCount;
 468   UINTN                            TypeIndex;
 469   BOOLEAN                          Supported;
 470   VOID                             *InfoBlock;
 471   UINTN                            InfoBlockSize;
 472
 473   ASSERT (Private != NULL && Ipv6Support != NULL);
 474
 475   //
 476   // Check whether the UNDI supports IPv6 by NII protocol.
 477   //
 478   if (Private->Nii != NULL) {
 479     *Ipv6Support = Private->Nii->Ipv6Supported;
 480     return EFI_SUCCESS;
 481   }
 482
 483   //
 484   // Check whether the UNDI supports IPv6 by AIP protocol.
 485   //
 486
 487   //
 488   // Get the NIC handle by SNP protocol.
 489   //
 490   Handle = NetLibGetSnpHandle (ControllerHandle, NULL);
 491   if (Handle == NULL) {
 492     return EFI_NOT_FOUND;
 493   }
 494
 495   Aip    = NULL;
 496   Status = gBS->HandleProtocol (
 497                   Handle,
 498                   &gEfiAdapterInformationProtocolGuid,
 499                   (VOID *) &Aip
 500                   );
 501   if (EFI_ERROR (Status) || Aip == NULL) {
 502     return EFI_NOT_FOUND;
 503   }
 504
 505   InfoTypesBuffer     = NULL;
 506   InfoTypeBufferCount = 0;
 507   Status = Aip->GetSupportedTypes (Aip, &InfoTypesBuffer, &InfoTypeBufferCount);
 508   if (EFI_ERROR (Status) || InfoTypesBuffer == NULL) {
 509     FreePool (InfoTypesBuffer);
 510     return EFI_NOT_FOUND;
 511   }
 512
 513   Supported = FALSE;
 514   for (TypeIndex = 0; TypeIndex < InfoTypeBufferCount; TypeIndex++) {
 515     if (CompareGuid (&InfoTypesBuffer[TypeIndex], &gEfiAdapterInfoUndiIpv6SupportGuid)) {
 516       Supported = TRUE;
 517       break;
 518     }
 519   }
 520
 521   FreePool (InfoTypesBuffer);
 522   if (!Supported) {
 523     return EFI_NOT_FOUND;
 524   }
 525
 526   //
 527   // We now have adapter information block.
 528   //
 529   InfoBlock     = NULL;
 530   InfoBlockSize = 0;
 531   Status = Aip->GetInformation (Aip, &gEfiAdapterInfoUndiIpv6SupportGuid, &InfoBlock, &InfoBlockSize);
 532   if (EFI_ERROR (Status) || InfoBlock == NULL) {
 533     FreePool (InfoBlock);
 534     return EFI_NOT_FOUND;
 535   }
 536
 537   *Ipv6Support = ((EFI_ADAPTER_INFO_UNDI_IPV6_SUPPORT *) InfoBlock)->Ipv6Support;
 538   FreePool (InfoBlock);
 539   return EFI_SUCCESS;
 540
 541 }
 542
 543 /**
 544   Create the opened instances based on IPv4.
 545
 546   @param[in]  This              Pointer to EFI_DRIVER_BINDING_PROTOCOL.
 547   @param[in]  ControllerHandle  Handle of the child to destroy.
 548   @param[in]  Private Handle    Pointer to PXEBC_PRIVATE_DATA.
 549
 550   @retval EFI_SUCCESS           The instances based on IPv4 were all created successfully.
 551   @retval Others                An unexpected error occurred.
 552
 553 **/
 554 EFI_STATUS
 555 PxeBcCreateIp4Children (
 556   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 557   IN EFI_HANDLE                   ControllerHandle,
 558   IN PXEBC_PRIVATE_DATA           *Private
 559   )
 560 {
 561   EFI_STATUS                      Status;
 562   IPv4_DEVICE_PATH                Ip4Node;
 563   EFI_PXE_BASE_CODE_MODE          *Mode;
 564   EFI_UDP4_CONFIG_DATA            *Udp4CfgData;
 565   EFI_IP4_CONFIG_DATA             *Ip4CfgData;
 566   EFI_IP4_MODE_DATA               Ip4ModeData;
 567   PXEBC_PRIVATE_PROTOCOL          *Id;
 568   EFI_SIMPLE_NETWORK_PROTOCOL     *Snp;
 569
 570   if (Private->Ip4Nic != NULL) {
 571     //
 572     // Already created before.
 573     //
 574     return EFI_SUCCESS;
 575   }
 576
 577   //
 578   // Create Dhcp4 child and open Dhcp4 protocol for PxeBc->Dhcp.
 579   //
 580   Status = NetLibCreateServiceChild (
 581              ControllerHandle,
 582              This->DriverBindingHandle,
 583              &gEfiDhcp4ServiceBindingProtocolGuid,
 584              &Private->Dhcp4Child
 585              );
 586   if (EFI_ERROR (Status)) {
 587     goto ON_ERROR;
 588   }
 589
 590   Status = gBS->OpenProtocol (
 591                   Private->Dhcp4Child,
 592                   &gEfiDhcp4ProtocolGuid,
 593                   (VOID **) &Private->Dhcp4,
 594                   This->DriverBindingHandle,
 595                   ControllerHandle,
 596                   EFI_OPEN_PROTOCOL_BY_DRIVER
 597                   );
 598   if (EFI_ERROR (Status)) {
 599     goto ON_ERROR;
 600   }
 601
 602   //
 603   // Create Mtftp4 child and open Mtftp4 protocol for PxeBc->Mtftp.
 604   //
 605   Status = NetLibCreateServiceChild (
 606              ControllerHandle,
 607              This->DriverBindingHandle,
 608              &gEfiMtftp4ServiceBindingProtocolGuid,
 609              &Private->Mtftp4Child
 610              );
 611   if (EFI_ERROR (Status)) {
 612     goto ON_ERROR;
 613   }
 614
 615   Status = gBS->OpenProtocol (
 616                   Private->Mtftp4Child,
 617                   &gEfiMtftp4ProtocolGuid,
 618                   (VOID **) &Private->Mtftp4,
 619                   This->DriverBindingHandle,
 620                   ControllerHandle,
 621                   EFI_OPEN_PROTOCOL_BY_DRIVER
 622                   );
 623   if (EFI_ERROR (Status)) {
 624     goto ON_ERROR;
 625   }
 626
 627   //
 628   // Create Udp4 child and open Udp4 protocol for PxeBc->UdpRead.
 629   //
 630   Status = NetLibCreateServiceChild (
 631              ControllerHandle,
 632              This->DriverBindingHandle,
 633              &gEfiUdp4ServiceBindingProtocolGuid,
 634              &Private->Udp4ReadChild
 635              );
 636   if (EFI_ERROR (Status)) {
 637     goto ON_ERROR;
 638   }
 639
 640   Status = gBS->OpenProtocol (
 641                   Private->Udp4ReadChild,
 642                   &gEfiUdp4ProtocolGuid,
 643                   (VOID **) &Private->Udp4Read,
 644                   This->DriverBindingHandle,
 645                   ControllerHandle,
 646                   EFI_OPEN_PROTOCOL_BY_DRIVER
 647                   );
 648   if (EFI_ERROR (Status)) {
 649     goto ON_ERROR;
 650   }
 651
 652   //
 653   // Create Udp4 child and open Udp4 protocol for PxeBc->UdpWrite.
 654   //
 655   Status = NetLibCreateServiceChild (
 656              ControllerHandle,
 657              This->DriverBindingHandle,
 658              &gEfiUdp4ServiceBindingProtocolGuid,
 659              &Private->Udp4WriteChild
 660              );
 661   if (EFI_ERROR (Status)) {
 662     goto ON_ERROR;
 663   }
 664
 665   Status = gBS->OpenProtocol (
 666                   Private->Udp4WriteChild,
 667                   &gEfiUdp4ProtocolGuid,
 668                   (VOID **) &Private->Udp4Write,
 669                   This->DriverBindingHandle,
 670                   ControllerHandle,
 671                   EFI_OPEN_PROTOCOL_BY_DRIVER
 672                   );
 673   if (EFI_ERROR (Status)) {
 674     goto ON_ERROR;
 675   }
 676
 677   //
 678   // Create Arp child and open Arp protocol for PxeBc->Arp.
 679   //
 680   Status = NetLibCreateServiceChild (
 681              ControllerHandle,
 682              This->DriverBindingHandle,
 683              &gEfiArpServiceBindingProtocolGuid,
 684              &Private->ArpChild
 685              );
 686   if (EFI_ERROR (Status)) {
 687     goto ON_ERROR;
 688   }
 689
 690   Status = gBS->OpenProtocol (
 691                   Private->ArpChild,
 692                   &gEfiArpProtocolGuid,
 693                   (VOID **) &Private->Arp,
 694                   This->DriverBindingHandle,
 695                   ControllerHandle,
 696                   EFI_OPEN_PROTOCOL_BY_DRIVER
 697                   );
 698   if (EFI_ERROR (Status)) {
 699     goto ON_ERROR;
 700   }
 701
 702   //
 703   // Create Ip4 child and open Ip4 protocol for background ICMP packets.
 704   //
 705   Status = NetLibCreateServiceChild (
 706              ControllerHandle,
 707              This->DriverBindingHandle,
 708              &gEfiIp4ServiceBindingProtocolGuid,
 709              &Private->Ip4Child
 710              );
 711   if (EFI_ERROR (Status)) {
 712     goto ON_ERROR;
 713   }
 714
 715   Status = gBS->OpenProtocol (
 716                   Private->Ip4Child,
 717                   &gEfiIp4ProtocolGuid,
 718                   (VOID **) &Private->Ip4,
 719                   This->DriverBindingHandle,
 720                   ControllerHandle,
 721                   EFI_OPEN_PROTOCOL_BY_DRIVER
 722                   );
 723   if (EFI_ERROR (Status)) {
 724     goto ON_ERROR;
 725   }
 726
 727   //
 728   // Get max packet size from Ip4 to calculate block size for Tftp later.
 729   //
 730   Status = Private->Ip4->GetModeData (Private->Ip4, &Ip4ModeData, NULL, NULL);
 731   if (EFI_ERROR (Status)) {
 732     goto ON_ERROR;
 733   }
 734
 735   Private->Ip4MaxPacketSize = Ip4ModeData.MaxPacketSize;
 736
 737   Private->Ip4Nic = AllocateZeroPool (sizeof (PXEBC_VIRTUAL_NIC));
 738   if (Private->Ip4Nic == NULL) {
 739     return EFI_OUT_OF_RESOURCES;
 740   }
 741
 742   Private->Ip4Nic->Private   = Private;
 743   Private->Ip4Nic->Signature = PXEBC_VIRTUAL_NIC_SIGNATURE;
 744
 745   //
 746   // Create a device path node for Ipv4 virtual nic, and append it.
 747   //
 748   ZeroMem (&Ip4Node, sizeof (IPv4_DEVICE_PATH));
 749   Ip4Node.Header.Type     = MESSAGING_DEVICE_PATH;
 750   Ip4Node.Header.SubType  = MSG_IPv4_DP;
 751   Ip4Node.StaticIpAddress = FALSE;
 752
 753   SetDevicePathNodeLength (&Ip4Node.Header, sizeof (Ip4Node));
 754
 755   Private->Ip4Nic->DevicePath = AppendDevicePathNode (Private->DevicePath, &Ip4Node.Header);
 756
 757   if (Private->Ip4Nic->DevicePath == NULL) {
 758     Status = EFI_OUT_OF_RESOURCES;
 759     goto ON_ERROR;
 760   }
 761
 762   CopyMem (
 763     &Private->Ip4Nic->LoadFile,
 764     &gLoadFileProtocolTemplate,
 765     sizeof (EFI_LOAD_FILE_PROTOCOL)
 766     );
 767
 768   //
 769   // Create a new handle for IPv4 virtual nic,
 770   // and install PxeBaseCode, LoadFile and DevicePath protocols.
 771   //
 772   Status = gBS->InstallMultipleProtocolInterfaces (
 773                   &Private->Ip4Nic->Controller,
 774                   &gEfiDevicePathProtocolGuid,
 775                   Private->Ip4Nic->DevicePath,
 776                   &gEfiLoadFileProtocolGuid,
 777                   &Private->Ip4Nic->LoadFile,
 778                   &gEfiPxeBaseCodeProtocolGuid,
 779                   &Private->PxeBc,
 780                   NULL
 781                   );
 782   if (EFI_ERROR (Status)) {
 783     goto ON_ERROR;
 784   }
 785
 786   if (Private->Snp != NULL) {
 787     //
 788     // Install SNP protocol on purpose is for some OS loader backward
 789     // compatibility consideration.
 790     //
 791     Status = gBS->InstallProtocolInterface (
 792                     &Private->Ip4Nic->Controller,
 793                     &gEfiSimpleNetworkProtocolGuid,
 794                     EFI_NATIVE_INTERFACE,
 795                     Private->Snp
 796                     );
 797     if (EFI_ERROR (Status)) {
 798       goto ON_ERROR;
 799     }
 800
 801     //
 802     // Open SNP on the child handle BY_DRIVER. It will prevent any additionally
 803     // layering to perform the experiment.
 804     //
 805     Status = gBS->OpenProtocol (
 806                     Private->Ip4Nic->Controller,
 807                     &gEfiSimpleNetworkProtocolGuid,
 808                     (VOID **) &Snp,
 809                     This->DriverBindingHandle,
 810                     Private->Ip4Nic->Controller,
 811                     EFI_OPEN_PROTOCOL_BY_DRIVER
 812                     );
 813     if (EFI_ERROR (Status)) {
 814       goto ON_ERROR;
 815     }
 816   }
 817
 818   //
 819   // Open PxeBaseCodePrivate protocol by child to setup a parent-child relationship between
 820   // real NIC handle and the virtual IPv4 NIC handle.
 821   //
 822   Status = gBS->OpenProtocol (
 823                   ControllerHandle,
 824                   &gEfiCallerIdGuid,
 825                   (VOID **) &Id,
 826                   This->DriverBindingHandle,
 827                   Private->Ip4Nic->Controller,
 828                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 829                   );
 830   if (EFI_ERROR (Status)) {
 831     goto ON_ERROR;
 832   }
 833
 834   //
 835   // Set default configure data for Udp4Read and Ip4 instance.
 836   //
 837   Mode                            = Private->PxeBc.Mode;
 838   Udp4CfgData                     = &Private->Udp4CfgData;
 839   Ip4CfgData                      = &Private->Ip4CfgData;
 840
 841   Udp4CfgData->AcceptBroadcast    = FALSE;
 842   Udp4CfgData->AcceptAnyPort      = TRUE;
 843   Udp4CfgData->AllowDuplicatePort = TRUE;
 844   Udp4CfgData->TypeOfService      = Mode->ToS;
 845   Udp4CfgData->TimeToLive         = Mode->TTL;
 846   Udp4CfgData->ReceiveTimeout     = PXEBC_DEFAULT_LIFETIME;
 847   Udp4CfgData->TransmitTimeout    = PXEBC_DEFAULT_LIFETIME;
 848
 849   Ip4CfgData->AcceptIcmpErrors    = TRUE;
 850   Ip4CfgData->DefaultProtocol     = EFI_IP_PROTO_ICMP;
 851   Ip4CfgData->TypeOfService       = Mode->ToS;
 852   Ip4CfgData->TimeToLive          = Mode->TTL;
 853   Ip4CfgData->ReceiveTimeout      = PXEBC_DEFAULT_LIFETIME;
 854   Ip4CfgData->TransmitTimeout     = PXEBC_DEFAULT_LIFETIME;
 855
 856   return EFI_SUCCESS;
 857
 858 ON_ERROR:
 859   PxeBcDestroyIp4Children (This, Private);
 860   return Status;
 861 }
 862
 863
 864 /**
 865   Create the opened instances based on IPv6.
 866
 867   @param[in]  This              Pointer to EFI_DRIVER_BINDING_PROTOCOL.
 868   @param[in]  ControllerHandle  Handle of the child to destroy.
 869   @param[in]  Private Handle    Pointer to PXEBC_PRIVATE_DATA.
 870
 871   @retval EFI_SUCCESS           The instances based on IPv6 were all created successfully.
 872   @retval Others                An unexpected error occurred.
 873
 874 **/
 875 EFI_STATUS
 876 PxeBcCreateIp6Children (
 877   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 878   IN EFI_HANDLE                   ControllerHandle,
 879   IN PXEBC_PRIVATE_DATA           *Private
 880   )
 881 {
 882   EFI_STATUS                      Status;
 883   IPv6_DEVICE_PATH                Ip6Node;
 884   EFI_UDP6_CONFIG_DATA            *Udp6CfgData;
 885   EFI_IP6_CONFIG_DATA             *Ip6CfgData;
 886   EFI_IP6_MODE_DATA               Ip6ModeData;
 887   PXEBC_PRIVATE_PROTOCOL          *Id;
 888   EFI_SIMPLE_NETWORK_PROTOCOL     *Snp;
 889   UINTN                           Index;
 890
 891   if (Private->Ip6Nic != NULL) {
 892     //
 893     // Already created before.
 894     //
 895     return EFI_SUCCESS;
 896   }
 897
 898   Private->Ip6Nic = AllocateZeroPool (sizeof (PXEBC_VIRTUAL_NIC));
 899
 900   if (Private->Ip6Nic == NULL) {
 901     return EFI_OUT_OF_RESOURCES;
 902   }
 903
 904   Private->Ip6Nic->Private   = Private;
 905   Private->Ip6Nic->Signature = PXEBC_VIRTUAL_NIC_SIGNATURE;
 906
 907   //
 908   // Create Dhcp6 child and open Dhcp6 protocol for PxeBc->Dhcp.
 909   //
 910   Status = NetLibCreateServiceChild (
 911              ControllerHandle,
 912              This->DriverBindingHandle,
 913              &gEfiDhcp6ServiceBindingProtocolGuid,
 914              &Private->Dhcp6Child
 915              );
 916   if (EFI_ERROR (Status)) {
 917     goto ON_ERROR;
 918   }
 919
 920   Status = gBS->OpenProtocol (
 921                   Private->Dhcp6Child,
 922                   &gEfiDhcp6ProtocolGuid,
 923                   (VOID **) &Private->Dhcp6,
 924                   This->DriverBindingHandle,
 925                   ControllerHandle,
 926                   EFI_OPEN_PROTOCOL_BY_DRIVER
 927                   );
 928   if (EFI_ERROR (Status)) {
 929     goto ON_ERROR;
 930   }
 931
 932   //
 933   // Generate a random IAID for the Dhcp6 assigned address.
 934   //
 935   Private->IaId = NET_RANDOM (NetRandomInitSeed ());
 936   if (Private->Snp != NULL) {
 937     for (Index = 0; Index < Private->Snp->Mode->HwAddressSize; Index++) {
 938       Private->IaId |= (Private->Snp->Mode->CurrentAddress.Addr[Index] << ((Index << 3) & 31));
 939     }
 940   }
 941
 942   //
 943   // Create Mtftp6 child and open Mtftp6 protocol for PxeBc->Mtftp.
 944   //
 945   Status = NetLibCreateServiceChild (
 946              ControllerHandle,
 947              This->DriverBindingHandle,
 948              &gEfiMtftp6ServiceBindingProtocolGuid,
 949              &Private->Mtftp6Child
 950              );
 951   if (EFI_ERROR (Status)) {
 952     goto ON_ERROR;
 953   }
 954
 955   Status = gBS->OpenProtocol (
 956                   Private->Mtftp6Child,
 957                   &gEfiMtftp6ProtocolGuid,
 958                   (VOID **) &Private->Mtftp6,
 959                   This->DriverBindingHandle,
 960                   ControllerHandle,
 961                   EFI_OPEN_PROTOCOL_BY_DRIVER
 962                   );
 963   if (EFI_ERROR (Status)) {
 964     goto ON_ERROR;
 965   }
 966
 967   //
 968   // Create Udp6 child and open Udp6 protocol for PxeBc->UdpRead.
 969   //
 970   Status = NetLibCreateServiceChild (
 971              ControllerHandle,
 972              This->DriverBindingHandle,
 973              &gEfiUdp6ServiceBindingProtocolGuid,
 974              &Private->Udp6ReadChild
 975              );
 976   if (EFI_ERROR (Status)) {
 977     goto ON_ERROR;
 978   }
 979
 980   Status = gBS->OpenProtocol (
 981                   Private->Udp6ReadChild,
 982                   &gEfiUdp6ProtocolGuid,
 983                   (VOID **) &Private->Udp6Read,
 984                   This->DriverBindingHandle,
 985                   ControllerHandle,
 986                   EFI_OPEN_PROTOCOL_BY_DRIVER
 987                   );
 988   if (EFI_ERROR (Status)) {
 989     goto ON_ERROR;
 990   }
 991
 992   //
 993   // Create Udp6 child and open Udp6 protocol for PxeBc->UdpWrite.
 994   //
 995   Status = NetLibCreateServiceChild (
 996              ControllerHandle,
 997              This->DriverBindingHandle,
 998              &gEfiUdp6ServiceBindingProtocolGuid,
 999              &Private->Udp6WriteChild
1000              );
1001   if (EFI_ERROR (Status)) {
1002     goto ON_ERROR;
1003   }
1004
1005   Status = gBS->OpenProtocol (
1006                   Private->Udp6WriteChild,
1007                   &gEfiUdp6ProtocolGuid,
1008                   (VOID **) &Private->Udp6Write,
1009                   This->DriverBindingHandle,
1010                   ControllerHandle,
1011                   EFI_OPEN_PROTOCOL_BY_DRIVER
1012                   );
1013   if (EFI_ERROR (Status)) {
1014     goto ON_ERROR;
1015   }
1016
1017   //
1018   // Create Ip6 child and open Ip6 protocol for background ICMP6 packets.
1019   //
1020   Status = NetLibCreateServiceChild (
1021              ControllerHandle,
1022              This->DriverBindingHandle,
1023              &gEfiIp6ServiceBindingProtocolGuid,
1024              &Private->Ip6Child
1025              );
1026   if (EFI_ERROR (Status)) {
1027     goto ON_ERROR;
1028   }
1029
1030   Status = gBS->OpenProtocol (
1031                   Private->Ip6Child,
1032                   &gEfiIp6ProtocolGuid,
1033                   (VOID **) &Private->Ip6,
1034                   This->DriverBindingHandle,
1035                   ControllerHandle,
1036                   EFI_OPEN_PROTOCOL_BY_DRIVER
1037                   );
1038   if (EFI_ERROR (Status)) {
1039     goto ON_ERROR;
1040   }
1041
1042   //
1043   // Get max packet size from Ip6 to calculate block size for Tftp later.
1044   //
1045   Status = Private->Ip6->GetModeData (Private->Ip6, &Ip6ModeData, NULL, NULL);
1046   if (EFI_ERROR (Status)) {
1047     goto ON_ERROR;
1048   }
1049
1050   Private->Ip6MaxPacketSize = Ip6ModeData.MaxPacketSize;
1051
1052   //
1053   // Locate Ip6->Ip6Config and store it for set IPv6 address.
1054   //
1055   Status = gBS->HandleProtocol (
1056                   ControllerHandle,
1057                   &gEfiIp6ConfigProtocolGuid,
1058                   (VOID **) &Private->Ip6Cfg
1059                   );
1060   if (EFI_ERROR (Status)) {
1061     goto ON_ERROR;
1062   }
1063
1064   //
1065   // Create a device path node for Ipv6 virtual nic, and append it.
1066   //
1067   ZeroMem (&Ip6Node, sizeof (IPv6_DEVICE_PATH));
1068   Ip6Node.Header.Type     = MESSAGING_DEVICE_PATH;
1069   Ip6Node.Header.SubType  = MSG_IPv6_DP;
1070   Ip6Node.PrefixLength    = IP6_PREFIX_LENGTH;
1071
1072   SetDevicePathNodeLength (&Ip6Node.Header, sizeof (Ip6Node));
1073
1074   Private->Ip6Nic->DevicePath = AppendDevicePathNode (Private->DevicePath, &Ip6Node.Header);
1075
1076   if (Private->Ip6Nic->DevicePath == NULL) {
1077     Status = EFI_OUT_OF_RESOURCES;
1078     goto ON_ERROR;
1079   }
1080
1081   CopyMem (
1082     &Private->Ip6Nic->LoadFile,
1083     &gLoadFileProtocolTemplate,
1084     sizeof (EFI_LOAD_FILE_PROTOCOL)
1085     );
1086
1087   //
1088   // Create a new handle for IPv6 virtual nic,
1089   // and install PxeBaseCode, LoadFile and DevicePath protocols.
1090   //
1091   Status = gBS->InstallMultipleProtocolInterfaces (
1092                   &Private->Ip6Nic->Controller,
1093                   &gEfiDevicePathProtocolGuid,
1094                   Private->Ip6Nic->DevicePath,
1095                   &gEfiLoadFileProtocolGuid,
1096                   &Private->Ip6Nic->LoadFile,
1097                   &gEfiPxeBaseCodeProtocolGuid,
1098                   &Private->PxeBc,
1099                   NULL
1100                   );
1101   if (EFI_ERROR (Status)) {
1102     goto ON_ERROR;
1103   }
1104
1105   if (Private->Snp != NULL) {
1106     //
1107     // Install SNP protocol on purpose is for some OS loader backward
1108     // compatibility consideration.
1109     //
1110     Status = gBS->InstallProtocolInterface (
1111                     &Private->Ip6Nic->Controller,
1112                     &gEfiSimpleNetworkProtocolGuid,
1113                     EFI_NATIVE_INTERFACE,
1114                     Private->Snp
1115                     );
1116     if (EFI_ERROR (Status)) {
1117       goto ON_ERROR;
1118     }
1119
1120     //
1121     // Open SNP on the child handle BY_DRIVER. It will prevent any additionally
1122     // layering to perform the experiment.
1123     //
1124     Status = gBS->OpenProtocol (
1125                     Private->Ip6Nic->Controller,
1126                     &gEfiSimpleNetworkProtocolGuid,
1127                     (VOID **) &Snp,
1128                     This->DriverBindingHandle,
1129                     Private->Ip6Nic->Controller,
1130                     EFI_OPEN_PROTOCOL_BY_DRIVER
1131                     );
1132     if (EFI_ERROR (Status)) {
1133       goto ON_ERROR;
1134     }
1135   }
1136
1137   //
1138   // Open PxeBaseCodePrivate protocol by child to setup a parent-child relationship between
1139   // real NIC handle and the virtual IPv6 NIC handle.
1140   //
1141   Status = gBS->OpenProtocol (
1142                   ControllerHandle,
1143                   &gEfiCallerIdGuid,
1144                   (VOID **) &Id,
1145                   This->DriverBindingHandle,
1146                   Private->Ip6Nic->Controller,
1147                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
1148                   );
1149   if (EFI_ERROR (Status)) {
1150     goto ON_ERROR;
1151   }
1152
1153   //
1154   // Set IPv6 avaiable flag and set default configure data for
1155   // Udp6Read and Ip6 instance.
1156   //
1157   Status = PxeBcCheckIpv6Support (ControllerHandle, Private, &Private->Mode.Ipv6Available);
1158   if (EFI_ERROR (Status)) {
1159     //
1160     // Fail to get the data whether UNDI supports IPv6. Set default value.
1161     //
1162     Private->Mode.Ipv6Available   = TRUE;
1163   }
1164
1165   if (!Private->Mode.Ipv6Available) {
1166     goto ON_ERROR;
1167   }
1168
1169   Udp6CfgData                     = &Private->Udp6CfgData;
1170   Ip6CfgData                      = &Private->Ip6CfgData;
1171
1172   Udp6CfgData->AcceptAnyPort      = TRUE;
1173   Udp6CfgData->AllowDuplicatePort = TRUE;
1174   Udp6CfgData->HopLimit           = PXEBC_DEFAULT_HOPLIMIT;
1175   Udp6CfgData->ReceiveTimeout     = PXEBC_DEFAULT_LIFETIME;
1176   Udp6CfgData->TransmitTimeout    = PXEBC_DEFAULT_LIFETIME;
1177
1178   Ip6CfgData->AcceptIcmpErrors    = TRUE;
1179   Ip6CfgData->DefaultProtocol     = IP6_ICMP;
1180   Ip6CfgData->HopLimit            = PXEBC_DEFAULT_HOPLIMIT;
1181   Ip6CfgData->ReceiveTimeout      = PXEBC_DEFAULT_LIFETIME;
1182   Ip6CfgData->TransmitTimeout     = PXEBC_DEFAULT_LIFETIME;
1183
1184   return EFI_SUCCESS;
1185
1186 ON_ERROR:
1187   PxeBcDestroyIp6Children (This, Private);
1188   return Status;
1189 }
1190
1191
1192 /**
1193   The entry point for UefiPxeBc driver that installs the driver
1194   binding and component name protocol on its image.
1195
1196   @param[in]  ImageHandle          The Image handle of the driver.
1197   @param[in]  SystemTable          The system table.
1198
1199   @return EFI_SUCCESS
1200   @return Others
1201
1202 **/
1203 EFI_STATUS
1204 EFIAPI
1205 PxeBcDriverEntryPoint (
1206   IN EFI_HANDLE             ImageHandle,
1207   IN EFI_SYSTEM_TABLE       *SystemTable
1208   )
1209 {
1210   EFI_STATUS  Status;
1211
1212   Status = EfiLibInstallDriverBindingComponentName2 (
1213              ImageHandle,
1214              SystemTable,
1215              &gPxeBcIp4DriverBinding,
1216              ImageHandle,
1217              &gPxeBcComponentName,
1218              &gPxeBcComponentName2
1219              );
1220   if (EFI_ERROR (Status)) {
1221     return Status;
1222   }
1223
1224   Status = EfiLibInstallDriverBindingComponentName2 (
1225              ImageHandle,
1226              SystemTable,
1227              &gPxeBcIp6DriverBinding,
1228              NULL,
1229              &gPxeBcComponentName,
1230              &gPxeBcComponentName2
1231              );
1232   if (EFI_ERROR (Status)) {
1233     gBS->UninstallMultipleProtocolInterfaces (
1234            ImageHandle,
1235            &gEfiDriverBindingProtocolGuid,
1236            &gPxeBcIp4DriverBinding,
1237            &gEfiComponentName2ProtocolGuid,
1238            &gPxeBcComponentName2,
1239            &gEfiComponentNameProtocolGuid,
1240            &gPxeBcComponentName,
1241            NULL
1242            );
1243   }
1244
1245   return Status;
1246 }
1247
1248 /**
1249   Test to see if this driver supports ControllerHandle. This is the worker function for
1250   PxeBcIp4(6)DriverBindingSupported.
1251
1252   @param[in]  This                The pointer to the driver binding protocol.
1253   @param[in]  ControllerHandle    The handle of device to be tested.
1254   @param[in]  RemainingDevicePath Optional parameter used to pick a specific child
1255                                   device to be started.
1256   @param[in]  IpVersion           IP_VERSION_4 or IP_VERSION_6.
1257
1258   @retval EFI_SUCCESS         This driver supports this device.
1259   @retval EFI_UNSUPPORTED     This driver does not support this device.
1260
1261 **/
1262 EFI_STATUS
1263 EFIAPI
1264 PxeBcSupported (
1265   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1266   IN EFI_HANDLE                   ControllerHandle,
1267   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL,
1268   IN UINT8                        IpVersion
1269   )
1270 {
1271   EFI_STATUS                      Status;
1272   EFI_GUID                        *DhcpServiceBindingGuid;
1273   EFI_GUID                        *MtftpServiceBindingGuid;
1274
1275   if (IpVersion == IP_VERSION_4) {
1276     DhcpServiceBindingGuid  = &gEfiDhcp4ServiceBindingProtocolGuid;
1277     MtftpServiceBindingGuid = &gEfiMtftp4ServiceBindingProtocolGuid;
1278   } else {
1279     DhcpServiceBindingGuid  = &gEfiDhcp6ServiceBindingProtocolGuid;
1280     MtftpServiceBindingGuid = &gEfiMtftp6ServiceBindingProtocolGuid;
1281   }
1282
1283   //
1284   // Try to open the Mtftp and Dhcp protocol to test whether IP stack is ready.
1285   //
1286   Status = gBS->OpenProtocol (
1287                      ControllerHandle,
1288                      DhcpServiceBindingGuid,
1289                      NULL,
1290                      This->DriverBindingHandle,
1291                      ControllerHandle,
1292                      EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1293                      );
1294   if (!EFI_ERROR (Status)) {
1295     Status = gBS->OpenProtocol (
1296                        ControllerHandle,
1297                        MtftpServiceBindingGuid,
1298                        NULL,
1299                        This->DriverBindingHandle,
1300                        ControllerHandle,
1301                        EFI_OPEN_PROTOCOL_TEST_PROTOCOL
1302                        );
1303   }
1304
1305   //
1306   // It's unsupported case if IP stack are not ready.
1307   //
1308   if (EFI_ERROR (Status)) {
1309     return EFI_UNSUPPORTED;
1310   }
1311
1312   return EFI_SUCCESS;
1313 }
1314
1315 /**
1316   Start this driver on ControllerHandle. This is the worker function for
1317   PxeBcIp4(6)DriverBindingStart.
1318
1319   @param[in]  This                 The pointer to the driver binding protocol.
1320   @param[in]  ControllerHandle     The handle of device to be started.
1321   @param[in]  RemainingDevicePath  Optional parameter used to pick a specific child
1322                                    device to be started.
1323   @param[in]  IpVersion            IP_VERSION_4 or IP_VERSION_6.
1324
1325
1326   @retval EFI_SUCCESS          This driver is installed to ControllerHandle.
1327   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle.
1328   @retval other                This driver does not support this device.
1329
1330 **/
1331 EFI_STATUS
1332 EFIAPI
1333 PxeBcStart (
1334   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1335   IN EFI_HANDLE                   ControllerHandle,
1336   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL,
1337   IN UINT8                        IpVersion
1338   )
1339 {
1340   PXEBC_PRIVATE_DATA              *Private;
1341   EFI_STATUS                      Status;
1342   PXEBC_PRIVATE_PROTOCOL          *Id;
1343   BOOLEAN                         FirstStart;
1344
1345   FirstStart = FALSE;
1346   Status = gBS->OpenProtocol (
1347                   ControllerHandle,
1348                   &gEfiCallerIdGuid,
1349                   (VOID **) &Id,
1350                   This->DriverBindingHandle,
1351                   ControllerHandle,
1352                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1353                   );
1354   if (!EFI_ERROR (Status)) {
1355     //
1356     // Skip the initialization if the driver has been started already.
1357     //
1358     Private = PXEBC_PRIVATE_DATA_FROM_ID (Id);
1359   } else {
1360     FirstStart = TRUE;
1361     //
1362     // If the driver has not been started yet, it should do initialization.
1363     //
1364     Private = AllocateZeroPool (sizeof (PXEBC_PRIVATE_DATA));
1365     if (Private == NULL) {
1366       return EFI_OUT_OF_RESOURCES;
1367     }
1368
1369     CopyMem (
1370       &Private->PxeBc,
1371       &gPxeBcProtocolTemplate,
1372       sizeof (EFI_PXE_BASE_CODE_PROTOCOL)
1373       );
1374
1375     Private->Signature          = PXEBC_PRIVATE_DATA_SIGNATURE;
1376     Private->Controller         = ControllerHandle;
1377     Private->Image              = This->ImageHandle;
1378     Private->PxeBc.Mode         = &Private->Mode;
1379     Private->Mode.Ipv6Supported = TRUE;
1380     Private->Mode.AutoArp       = TRUE;
1381     Private->Mode.TTL           = DEFAULT_TTL;
1382     Private->Mode.ToS           = DEFAULT_ToS;
1383
1384     //
1385     // Open device path to prepare for appending virtual NIC node.
1386     //
1387     Status = gBS->OpenProtocol (
1388                     ControllerHandle,
1389                     &gEfiDevicePathProtocolGuid,
1390                     (VOID **) &Private->DevicePath,
1391                     This->DriverBindingHandle,
1392                     ControllerHandle,
1393                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1394                     );
1395
1396     if (EFI_ERROR (Status)) {
1397       goto ON_ERROR;
1398     }
1399
1400     //
1401     // Get the NII interface if it exists, it's not required.
1402     //
1403     Status = gBS->OpenProtocol (
1404                     ControllerHandle,
1405                     &gEfiNetworkInterfaceIdentifierProtocolGuid_31,
1406                     (VOID **) &Private->Nii,
1407                     This->DriverBindingHandle,
1408                     ControllerHandle,
1409                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1410                     );
1411     if (EFI_ERROR (Status)) {
1412       Private->Nii = NULL;
1413     }
1414
1415     //
1416     // Install PxeBaseCodePrivate protocol onto the real NIC handler.
1417     // PxeBaseCodePrivate protocol is only used to keep the relationship between
1418     // NIC handle and virtual child handles.
1419     // gEfiCallerIdGuid will be used as its protocol guid.
1420     //
1421     Status = gBS->InstallProtocolInterface (
1422                     &ControllerHandle,
1423                     &gEfiCallerIdGuid,
1424                     EFI_NATIVE_INTERFACE,
1425                     &Private->Id
1426                     );
1427     if (EFI_ERROR (Status)) {
1428       goto ON_ERROR;
1429     }
1430
1431     //
1432     // Try to locate SNP protocol.
1433     //
1434     NetLibGetSnpHandle(ControllerHandle, &Private->Snp);
1435   }
1436
1437   if (IpVersion == IP_VERSION_4) {
1438     //
1439     // Try to create virtual NIC handle for IPv4.
1440     //
1441     Status = PxeBcCreateIp4Children (This, ControllerHandle, Private);
1442   } else {
1443     //
1444     // Try to create virtual NIC handle for IPv6.
1445     //
1446     Status = PxeBcCreateIp6Children (This, ControllerHandle, Private);
1447   }
1448   if (EFI_ERROR (Status)) {
1449     //
1450     // Failed to start PXE driver if IPv4 and IPv6 stack are both not available.
1451     //
1452     Status = EFI_DEVICE_ERROR;
1453     goto ON_ERROR;
1454   }
1455
1456   return EFI_SUCCESS;
1457
1458 ON_ERROR:
1459   if (FirstStart) {
1460     gBS->UninstallProtocolInterface (
1461            ControllerHandle,
1462            &gEfiCallerIdGuid,
1463            &Private->Id
1464            );
1465   }
1466
1467   if (IpVersion == IP_VERSION_4) {
1468     PxeBcDestroyIp4Children (This, Private);
1469   } else {
1470     PxeBcDestroyIp6Children (This, Private);
1471   }
1472
1473   if (FirstStart && Private != NULL) {
1474     FreePool (Private);
1475   }
1476
1477   return Status;
1478 }
1479
1480
1481 /**
1482   Stop this driver on ControllerHandle. This is the worker function for
1483   PxeBcIp4(6)DriverBindingStop.
1484
1485   @param[in]  This              Protocol instance pointer.
1486   @param[in]  ControllerHandle  Handle of device to stop driver on.
1487   @param[in]  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
1488                                 children is zero stop the entire bus driver.
1489   @param[in]  ChildHandleBuffer List of Child Handles to Stop.
1490   @param[in]  IpVersion         IP_VERSION_4 or IP_VERSION_6.
1491
1492   @retval EFI_SUCCESS           This driver was removed ControllerHandle.
1493   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
1494   @retval Others                This driver was not removed from this device
1495
1496 **/
1497 EFI_STATUS
1498 EFIAPI
1499 PxeBcStop (
1500   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1501   IN EFI_HANDLE                   ControllerHandle,
1502   IN UINTN                        NumberOfChildren,
1503   IN EFI_HANDLE                   *ChildHandleBuffer,
1504   IN UINT8                        IpVersion
1505   )
1506 {
1507   PXEBC_PRIVATE_DATA              *Private;
1508   PXEBC_VIRTUAL_NIC               *VirtualNic;
1509   EFI_LOAD_FILE_PROTOCOL          *LoadFile;
1510   EFI_STATUS                      Status;
1511   EFI_HANDLE                      NicHandle;
1512   PXEBC_PRIVATE_PROTOCOL          *Id;
1513
1514   Private    = NULL;
1515   NicHandle  = NULL;
1516   VirtualNic = NULL;
1517   LoadFile   = NULL;
1518   Id         = NULL;
1519
1520   Status = gBS->OpenProtocol (
1521                   ControllerHandle,
1522                   &gEfiLoadFileProtocolGuid,
1523                   (VOID **) &LoadFile,
1524                   This->DriverBindingHandle,
1525                   ControllerHandle,
1526                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
1527                   );
1528   if (EFI_ERROR (Status)) {
1529     //
1530     // Get the Nic handle by any pass-over service child handle.
1531     //
1532     if (IpVersion == IP_VERSION_4) {
1533       NicHandle = PxeBcGetNicByIp4Children (ControllerHandle);
1534     } else {
1535       NicHandle = PxeBcGetNicByIp6Children (ControllerHandle);
1536     }
1537     if (NicHandle == NULL) {
1538       return EFI_SUCCESS;
1539     }
1540
1541     //
1542     // Try to retrieve the private data by PxeBcPrivate protocol.
1543     //
1544     Status = gBS->OpenProtocol (
1545                     NicHandle,
1546                     &gEfiCallerIdGuid,
1547                     (VOID **) &Id,
1548                     This->DriverBindingHandle,
1549                     ControllerHandle,
1550                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1551                     );
1552     if (EFI_ERROR (Status)) {
1553       return Status;
1554     }
1555     Private = PXEBC_PRIVATE_DATA_FROM_ID (Id);
1556
1557   } else {
1558     //
1559     // It's a virtual handle with LoadFileProtocol.
1560     //
1561     Status = gBS->OpenProtocol (
1562                     ControllerHandle,
1563                     &gEfiLoadFileProtocolGuid,
1564                     (VOID **) &LoadFile,
1565                     This->DriverBindingHandle,
1566                     ControllerHandle,
1567                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
1568                     );
1569     if (EFI_ERROR (Status)) {
1570       return Status;
1571     }
1572
1573     VirtualNic = PXEBC_VIRTUAL_NIC_FROM_LOADFILE (LoadFile);
1574     Private    = VirtualNic->Private;
1575     NicHandle  = Private->Controller;
1576   }
1577
1578   //
1579   // Stop functionality of PXE Base Code protocol
1580   //
1581   Status = Private->PxeBc.Stop (&Private->PxeBc);
1582   if (Status != EFI_SUCCESS && Status != EFI_NOT_STARTED) {
1583     return Status;
1584   }
1585
1586
1587   if (Private->Ip4Nic != NULL && IpVersion == IP_VERSION_4) {
1588     PxeBcDestroyIp4Children (This, Private);
1589   }
1590
1591   if (Private->Ip6Nic != NULL && IpVersion == IP_VERSION_6) {
1592     PxeBcDestroyIp6Children (This, Private);
1593   }
1594
1595   if (Private->Ip4Nic == NULL && Private->Ip6Nic == NULL) {
1596     gBS->UninstallProtocolInterface (
1597            NicHandle,
1598            &gEfiCallerIdGuid,
1599            &Private->Id
1600            );
1601     FreePool (Private);
1602   }
1603
1604   return EFI_SUCCESS;
1605 }
1606
1607 /**
1608   Test to see if this driver supports ControllerHandle. This service
1609   is called by the EFI boot service ConnectController(). In
1610   order to make drivers as small as possible, there are a few calling
1611   restrictions for this service. ConnectController() must
1612   follow these calling restrictions. If any other agent wishes to call
1613   Supported() it must also follow these calling restrictions.
1614
1615   @param[in]  This                The pointer to the driver binding protocol.
1616   @param[in]  ControllerHandle    The handle of device to be tested.
1617   @param[in]  RemainingDevicePath Optional parameter used to pick a specific child
1618                                   device to be started.
1619
1620   @retval EFI_SUCCESS         This driver supports this device.
1621   @retval EFI_UNSUPPORTED     This driver does not support this device.
1622
1623 **/
1624 EFI_STATUS
1625 EFIAPI
1626 PxeBcIp4DriverBindingSupported (
1627   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1628   IN EFI_HANDLE                   ControllerHandle,
1629   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
1630   )
1631 {
1632   return PxeBcSupported (
1633            This,
1634            ControllerHandle,
1635            RemainingDevicePath,
1636            IP_VERSION_4
1637            );
1638 }
1639
1640 /**
1641   Start this driver on ControllerHandle. This service is called by the
1642   EFI boot service ConnectController(). In order to make
1643   drivers as small as possible, there are a few calling restrictions for
1644   this service. ConnectController() must follow these
1645   calling restrictions. If any other agent wishes to call Start() it
1646   must also follow these calling restrictions.
1647
1648   @param[in]  This                 The pointer to the driver binding protocol.
1649   @param[in]  ControllerHandle     The handle of device to be started.
1650   @param[in]  RemainingDevicePath  Optional parameter used to pick a specific child
1651                                    device to be started.
1652
1653   @retval EFI_SUCCESS          This driver is installed to ControllerHandle.
1654   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle.
1655   @retval other                This driver does not support this device.
1656
1657 **/
1658 EFI_STATUS
1659 EFIAPI
1660 PxeBcIp4DriverBindingStart (
1661   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1662   IN EFI_HANDLE                   ControllerHandle,
1663   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
1664   )
1665 {
1666   return PxeBcStart (
1667            This,
1668            ControllerHandle,
1669            RemainingDevicePath,
1670            IP_VERSION_4
1671            );
1672 }
1673
1674 /**
1675   Stop this driver on ControllerHandle. This service is called by the
1676   EFI boot service DisconnectController(). In order to
1677   make drivers as small as possible, there are a few calling
1678   restrictions for this service. DisconnectController()
1679   must follow these calling restrictions. If any other agent wishes
1680   to call Stop() it must also follow these calling restrictions.
1681
1682   @param[in]  This              Protocol instance pointer.
1683   @param[in]  ControllerHandle  Handle of device to stop driver on
1684   @param[in]  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
1685                                 children is zero stop the entire bus driver.
1686   @param[in]  ChildHandleBuffer List of Child Handles to Stop.
1687
1688   @retval EFI_SUCCESS           This driver is removed ControllerHandle
1689   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
1690   @retval Others                This driver was not removed from this device.
1691
1692 **/
1693 EFI_STATUS
1694 EFIAPI
1695 PxeBcIp4DriverBindingStop (
1696   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1697   IN EFI_HANDLE                   ControllerHandle,
1698   IN UINTN                        NumberOfChildren,
1699   IN EFI_HANDLE                   *ChildHandleBuffer
1700   )
1701 {
1702   return PxeBcStop (
1703            This,
1704            ControllerHandle,
1705            NumberOfChildren,
1706            ChildHandleBuffer,
1707            IP_VERSION_4
1708            );
1709 }
1710
1711 /**
1712   Test to see if this driver supports ControllerHandle. This service
1713   is called by the EFI boot service ConnectController(). In
1714   order to make drivers as small as possible, there are a few calling
1715   restrictions for this service. ConnectController() must
1716   follow these calling restrictions. If any other agent wishes to call
1717   Supported() it must also follow these calling restrictions.
1718
1719   @param[in]  This                The pointer to the driver binding protocol.
1720   @param[in]  ControllerHandle    The handle of device to be tested.
1721   @param[in]  RemainingDevicePath Optional parameter use to pick a specific child
1722                                   device to be started.
1723
1724   @retval EFI_SUCCESS         This driver supports this device.
1725   @retval EFI_UNSUPPORTED     This driver does not support this device.
1726
1727 **/
1728 EFI_STATUS
1729 EFIAPI
1730 PxeBcIp6DriverBindingSupported (
1731   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1732   IN EFI_HANDLE                   ControllerHandle,
1733   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
1734   )
1735 {
1736   return PxeBcSupported (
1737            This,
1738            ControllerHandle,
1739            RemainingDevicePath,
1740            IP_VERSION_6
1741            );
1742 }
1743
1744 /**
1745   Start this driver on ControllerHandle. This service is called by the
1746   EFI boot service ConnectController(). In order to make
1747   drivers as small as possible, there are a few calling restrictions for
1748   this service. ConnectController() must follow these
1749   calling restrictions. If any other agent wishes to call Start() it
1750   must also follow these calling restrictions.
1751
1752   @param[in]  This                 The pointer to the driver binding protocol.
1753   @param[in]  ControllerHandle     The handle of device to be started.
1754   @param[in]  RemainingDevicePath  Optional parameter used to pick a specific child
1755                                    device to be started.
1756
1757   @retval EFI_SUCCESS          This driver is installed to ControllerHandle.
1758   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle.
1759   @retval other                This driver does not support this device.
1760
1761 **/
1762 EFI_STATUS
1763 EFIAPI
1764 PxeBcIp6DriverBindingStart (
1765   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1766   IN EFI_HANDLE                   ControllerHandle,
1767   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
1768   )
1769 {
1770   return PxeBcStart (
1771            This,
1772            ControllerHandle,
1773            RemainingDevicePath,
1774            IP_VERSION_6
1775            );
1776 }
1777
1778 /**
1779   Stop this driver on ControllerHandle. This service is called by the
1780   EFI boot service DisconnectController(). In order to
1781   make drivers as small as possible, there are a few calling
1782   restrictions for this service. DisconnectController()
1783   must follow these calling restrictions. If any other agent wishes
1784   to call Stop() it must also follow these calling restrictions.
1785
1786   @param[in]  This              Protocol instance pointer.
1787   @param[in]  ControllerHandle  Handle of device to stop driver on
1788   @param[in]  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number of
1789                                 children is zero stop the entire bus driver.
1790   @param[in]  ChildHandleBuffer List of Child Handles to Stop.
1791
1792   @retval EFI_SUCCESS           This driver is removed ControllerHandle
1793   @retval EFI_DEVICE_ERROR      An unexpected system or network error occurred.
1794   @retval Others                This driver was not removed from this device.
1795
1796 **/
1797 EFI_STATUS
1798 EFIAPI
1799 PxeBcIp6DriverBindingStop (
1800   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
1801   IN EFI_HANDLE                   ControllerHandle,
1802   IN UINTN                        NumberOfChildren,
1803   IN EFI_HANDLE                   *ChildHandleBuffer
1804   )
1805 {
1806   return PxeBcStop (
1807            This,
1808            ControllerHandle,
1809            NumberOfChildren,
1810            ChildHandleBuffer,
1811            IP_VERSION_6
1812            );
1813 }