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 // Locate Ip4->Ip4Config2 and store it for set IPv4 Policy. 747 // 748 Status = gBS->HandleProtocol ( 749 ControllerHandle, 750 &gEfiIp4Config2ProtocolGuid, 751 (VOID **) &Private->Ip4Config2 752 ); 753 if (EFI_ERROR (Status)) { 754 goto ON_ERROR; 755 } 756 757 // 758 // Create a device path node for Ipv4 virtual nic, and append it. 759 // 760 ZeroMem (&Ip4Node, sizeof (IPv4_DEVICE_PATH)); 761 Ip4Node.Header.Type = MESSAGING_DEVICE_PATH; 762 Ip4Node.Header.SubType = MSG_IPv4_DP; 763 Ip4Node.StaticIpAddress = FALSE; 764 765 SetDevicePathNodeLength (&Ip4Node.Header, sizeof (Ip4Node)); 766 767 Private->Ip4Nic->DevicePath = AppendDevicePathNode (Private->DevicePath, &Ip4Node.Header); 768 769 if (Private->Ip4Nic->DevicePath == NULL) { 770 Status = EFI_OUT_OF_RESOURCES; 771 goto ON_ERROR; 772 } 773 774 CopyMem ( 775 &Private->Ip4Nic->LoadFile, 776 &gLoadFileProtocolTemplate, 777 sizeof (EFI_LOAD_FILE_PROTOCOL) 778 ); 779 780 // 781 // Create a new handle for IPv4 virtual nic, 782 // and install PxeBaseCode, LoadFile and DevicePath protocols. 783 // 784 Status = gBS->InstallMultipleProtocolInterfaces ( 785 &Private->Ip4Nic->Controller, 786 &gEfiDevicePathProtocolGuid, 787 Private->Ip4Nic->DevicePath, 788 &gEfiLoadFileProtocolGuid, 789 &Private->Ip4Nic->LoadFile, 790 &gEfiPxeBaseCodeProtocolGuid, 791 &Private->PxeBc, 792 NULL 793 ); 794 if (EFI_ERROR (Status)) { 795 goto ON_ERROR; 796 } 797 798 if (Private->Snp != NULL) { 799 // 800 // Install SNP protocol on purpose is for some OS loader backward 801 // compatibility consideration. 802 // 803 Status = gBS->InstallProtocolInterface ( 804 &Private->Ip4Nic->Controller, 805 &gEfiSimpleNetworkProtocolGuid, 806 EFI_NATIVE_INTERFACE, 807 Private->Snp 808 ); 809 if (EFI_ERROR (Status)) { 810 goto ON_ERROR; 811 } 812 813 // 814 // Open SNP on the child handle BY_DRIVER. It will prevent any additionally 815 // layering to perform the experiment. 816 // 817 Status = gBS->OpenProtocol ( 818 Private->Ip4Nic->Controller, 819 &gEfiSimpleNetworkProtocolGuid, 820 (VOID **) &Snp, 821 This->DriverBindingHandle, 822 Private->Ip4Nic->Controller, 823 EFI_OPEN_PROTOCOL_BY_DRIVER 824 ); 825 if (EFI_ERROR (Status)) { 826 goto ON_ERROR; 827 } 828 } 829 830 // 831 // Open PxeBaseCodePrivate protocol by child to setup a parent-child relationship between 832 // real NIC handle and the virtual IPv4 NIC handle. 833 // 834 Status = gBS->OpenProtocol ( 835 ControllerHandle, 836 &gEfiCallerIdGuid, 837 (VOID **) &Id, 838 This->DriverBindingHandle, 839 Private->Ip4Nic->Controller, 840 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 841 ); 842 if (EFI_ERROR (Status)) { 843 goto ON_ERROR; 844 } 845 846 // 847 // Set default configure data for Udp4Read and Ip4 instance. 848 // 849 Mode = Private->PxeBc.Mode; 850 Udp4CfgData = &Private->Udp4CfgData; 851 Ip4CfgData = &Private->Ip4CfgData; 852 853 Udp4CfgData->AcceptBroadcast = FALSE; 854 Udp4CfgData->AcceptAnyPort = TRUE; 855 Udp4CfgData->AllowDuplicatePort = TRUE; 856 Udp4CfgData->TypeOfService = Mode->ToS; 857 Udp4CfgData->TimeToLive = Mode->TTL; 858 Udp4CfgData->ReceiveTimeout = PXEBC_DEFAULT_LIFETIME; 859 Udp4CfgData->TransmitTimeout = PXEBC_DEFAULT_LIFETIME; 860 861 Ip4CfgData->AcceptIcmpErrors = TRUE; 862 Ip4CfgData->DefaultProtocol = EFI_IP_PROTO_ICMP; 863 Ip4CfgData->TypeOfService = Mode->ToS; 864 Ip4CfgData->TimeToLive = Mode->TTL; 865 Ip4CfgData->ReceiveTimeout = PXEBC_DEFAULT_LIFETIME; 866 Ip4CfgData->TransmitTimeout = PXEBC_DEFAULT_LIFETIME; 867 868 return EFI_SUCCESS; 869 870 ON_ERROR: 871 PxeBcDestroyIp4Children (This, Private); 872 return Status; 873 } 874 875 876 /** 877 Create the opened instances based on IPv6. 878 879 @param[in] This Pointer to EFI_DRIVER_BINDING_PROTOCOL. 880 @param[in] ControllerHandle Handle of the child to destroy. 881 @param[in] Private Handle Pointer to PXEBC_PRIVATE_DATA. 882 883 @retval EFI_SUCCESS The instances based on IPv6 were all created successfully. 884 @retval Others An unexpected error occurred. 885 886 **/ 887 EFI_STATUS 888 PxeBcCreateIp6Children ( 889 IN EFI_DRIVER_BINDING_PROTOCOL *This, 890 IN EFI_HANDLE ControllerHandle, 891 IN PXEBC_PRIVATE_DATA *Private 892 ) 893 { 894 EFI_STATUS Status; 895 IPv6_DEVICE_PATH Ip6Node; 896 EFI_UDP6_CONFIG_DATA *Udp6CfgData; 897 EFI_IP6_CONFIG_DATA *Ip6CfgData; 898 EFI_IP6_MODE_DATA Ip6ModeData; 899 PXEBC_PRIVATE_PROTOCOL *Id; 900 EFI_SIMPLE_NETWORK_PROTOCOL *Snp; 901 UINTN Index; 902 903 if (Private->Ip6Nic != NULL) { 904 // 905 // Already created before. 906 // 907 return EFI_SUCCESS; 908 } 909 910 Private->Ip6Nic = AllocateZeroPool (sizeof (PXEBC_VIRTUAL_NIC)); 911 912 if (Private->Ip6Nic == NULL) { 913 return EFI_OUT_OF_RESOURCES; 914 } 915 916 Private->Ip6Nic->Private = Private; 917 Private->Ip6Nic->Signature = PXEBC_VIRTUAL_NIC_SIGNATURE; 918 919 // 920 // Create Dhcp6 child and open Dhcp6 protocol for PxeBc->Dhcp. 921 // 922 Status = NetLibCreateServiceChild ( 923 ControllerHandle, 924 This->DriverBindingHandle, 925 &gEfiDhcp6ServiceBindingProtocolGuid, 926 &Private->Dhcp6Child 927 ); 928 if (EFI_ERROR (Status)) { 929 goto ON_ERROR; 930 } 931 932 Status = gBS->OpenProtocol ( 933 Private->Dhcp6Child, 934 &gEfiDhcp6ProtocolGuid, 935 (VOID **) &Private->Dhcp6, 936 This->DriverBindingHandle, 937 ControllerHandle, 938 EFI_OPEN_PROTOCOL_BY_DRIVER 939 ); 940 if (EFI_ERROR (Status)) { 941 goto ON_ERROR; 942 } 943 944 // 945 // Generate a random IAID for the Dhcp6 assigned address. 946 // 947 Private->IaId = NET_RANDOM (NetRandomInitSeed ()); 948 if (Private->Snp != NULL) { 949 for (Index = 0; Index < Private->Snp->Mode->HwAddressSize; Index++) { 950 Private->IaId |= (Private->Snp->Mode->CurrentAddress.Addr[Index] << ((Index << 3) & 31)); 951 } 952 } 953 954 // 955 // Create Mtftp6 child and open Mtftp6 protocol for PxeBc->Mtftp. 956 // 957 Status = NetLibCreateServiceChild ( 958 ControllerHandle, 959 This->DriverBindingHandle, 960 &gEfiMtftp6ServiceBindingProtocolGuid, 961 &Private->Mtftp6Child 962 ); 963 if (EFI_ERROR (Status)) { 964 goto ON_ERROR; 965 } 966 967 Status = gBS->OpenProtocol ( 968 Private->Mtftp6Child, 969 &gEfiMtftp6ProtocolGuid, 970 (VOID **) &Private->Mtftp6, 971 This->DriverBindingHandle, 972 ControllerHandle, 973 EFI_OPEN_PROTOCOL_BY_DRIVER 974 ); 975 if (EFI_ERROR (Status)) { 976 goto ON_ERROR; 977 } 978 979 // 980 // Create Udp6 child and open Udp6 protocol for PxeBc->UdpRead. 981 // 982 Status = NetLibCreateServiceChild ( 983 ControllerHandle, 984 This->DriverBindingHandle, 985 &gEfiUdp6ServiceBindingProtocolGuid, 986 &Private->Udp6ReadChild 987 ); 988 if (EFI_ERROR (Status)) { 989 goto ON_ERROR; 990 } 991 992 Status = gBS->OpenProtocol ( 993 Private->Udp6ReadChild, 994 &gEfiUdp6ProtocolGuid, 995 (VOID **) &Private->Udp6Read, 996 This->DriverBindingHandle, 997 ControllerHandle, 998 EFI_OPEN_PROTOCOL_BY_DRIVER 999 ); 1000 if (EFI_ERROR (Status)) { 1001 goto ON_ERROR; 1002 } 1003 1004 // 1005 // Create Udp6 child and open Udp6 protocol for PxeBc->UdpWrite. 1006 // 1007 Status = NetLibCreateServiceChild ( 1008 ControllerHandle, 1009 This->DriverBindingHandle, 1010 &gEfiUdp6ServiceBindingProtocolGuid, 1011 &Private->Udp6WriteChild 1012 ); 1013 if (EFI_ERROR (Status)) { 1014 goto ON_ERROR; 1015 } 1016 1017 Status = gBS->OpenProtocol ( 1018 Private->Udp6WriteChild, 1019 &gEfiUdp6ProtocolGuid, 1020 (VOID **) &Private->Udp6Write, 1021 This->DriverBindingHandle, 1022 ControllerHandle, 1023 EFI_OPEN_PROTOCOL_BY_DRIVER 1024 ); 1025 if (EFI_ERROR (Status)) { 1026 goto ON_ERROR; 1027 } 1028 1029 // 1030 // Create Ip6 child and open Ip6 protocol for background ICMP6 packets. 1031 // 1032 Status = NetLibCreateServiceChild ( 1033 ControllerHandle, 1034 This->DriverBindingHandle, 1035 &gEfiIp6ServiceBindingProtocolGuid, 1036 &Private->Ip6Child 1037 ); 1038 if (EFI_ERROR (Status)) { 1039 goto ON_ERROR; 1040 } 1041 1042 Status = gBS->OpenProtocol ( 1043 Private->Ip6Child, 1044 &gEfiIp6ProtocolGuid, 1045 (VOID **) &Private->Ip6, 1046 This->DriverBindingHandle, 1047 ControllerHandle, 1048 EFI_OPEN_PROTOCOL_BY_DRIVER 1049 ); 1050 if (EFI_ERROR (Status)) { 1051 goto ON_ERROR; 1052 } 1053 1054 // 1055 // Get max packet size from Ip6 to calculate block size for Tftp later. 1056 // 1057 Status = Private->Ip6->GetModeData (Private->Ip6, &Ip6ModeData, NULL, NULL); 1058 if (EFI_ERROR (Status)) { 1059 goto ON_ERROR; 1060 } 1061 1062 Private->Ip6MaxPacketSize = Ip6ModeData.MaxPacketSize; 1063 1064 // 1065 // Locate Ip6->Ip6Config and store it for set IPv6 address. 1066 // 1067 Status = gBS->HandleProtocol ( 1068 ControllerHandle, 1069 &gEfiIp6ConfigProtocolGuid, 1070 (VOID **) &Private->Ip6Cfg 1071 ); 1072 if (EFI_ERROR (Status)) { 1073 goto ON_ERROR; 1074 } 1075 1076 // 1077 // Create a device path node for Ipv6 virtual nic, and append it. 1078 // 1079 ZeroMem (&Ip6Node, sizeof (IPv6_DEVICE_PATH)); 1080 Ip6Node.Header.Type = MESSAGING_DEVICE_PATH; 1081 Ip6Node.Header.SubType = MSG_IPv6_DP; 1082 Ip6Node.PrefixLength = IP6_PREFIX_LENGTH; 1083 1084 SetDevicePathNodeLength (&Ip6Node.Header, sizeof (Ip6Node)); 1085 1086 Private->Ip6Nic->DevicePath = AppendDevicePathNode (Private->DevicePath, &Ip6Node.Header); 1087 1088 if (Private->Ip6Nic->DevicePath == NULL) { 1089 Status = EFI_OUT_OF_RESOURCES; 1090 goto ON_ERROR; 1091 } 1092 1093 CopyMem ( 1094 &Private->Ip6Nic->LoadFile, 1095 &gLoadFileProtocolTemplate, 1096 sizeof (EFI_LOAD_FILE_PROTOCOL) 1097 ); 1098 1099 // 1100 // Create a new handle for IPv6 virtual nic, 1101 // and install PxeBaseCode, LoadFile and DevicePath protocols. 1102 // 1103 Status = gBS->InstallMultipleProtocolInterfaces ( 1104 &Private->Ip6Nic->Controller, 1105 &gEfiDevicePathProtocolGuid, 1106 Private->Ip6Nic->DevicePath, 1107 &gEfiLoadFileProtocolGuid, 1108 &Private->Ip6Nic->LoadFile, 1109 &gEfiPxeBaseCodeProtocolGuid, 1110 &Private->PxeBc, 1111 NULL 1112 ); 1113 if (EFI_ERROR (Status)) { 1114 goto ON_ERROR; 1115 } 1116 1117 if (Private->Snp != NULL) { 1118 // 1119 // Install SNP protocol on purpose is for some OS loader backward 1120 // compatibility consideration. 1121 // 1122 Status = gBS->InstallProtocolInterface ( 1123 &Private->Ip6Nic->Controller, 1124 &gEfiSimpleNetworkProtocolGuid, 1125 EFI_NATIVE_INTERFACE, 1126 Private->Snp 1127 ); 1128 if (EFI_ERROR (Status)) { 1129 goto ON_ERROR; 1130 } 1131 1132 // 1133 // Open SNP on the child handle BY_DRIVER. It will prevent any additionally 1134 // layering to perform the experiment. 1135 // 1136 Status = gBS->OpenProtocol ( 1137 Private->Ip6Nic->Controller, 1138 &gEfiSimpleNetworkProtocolGuid, 1139 (VOID **) &Snp, 1140 This->DriverBindingHandle, 1141 Private->Ip6Nic->Controller, 1142 EFI_OPEN_PROTOCOL_BY_DRIVER 1143 ); 1144 if (EFI_ERROR (Status)) { 1145 goto ON_ERROR; 1146 } 1147 } 1148 1149 // 1150 // Open PxeBaseCodePrivate protocol by child to setup a parent-child relationship between 1151 // real NIC handle and the virtual IPv6 NIC handle. 1152 // 1153 Status = gBS->OpenProtocol ( 1154 ControllerHandle, 1155 &gEfiCallerIdGuid, 1156 (VOID **) &Id, 1157 This->DriverBindingHandle, 1158 Private->Ip6Nic->Controller, 1159 EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 1160 ); 1161 if (EFI_ERROR (Status)) { 1162 goto ON_ERROR; 1163 } 1164 1165 // 1166 // Set IPv6 avaiable flag and set default configure data for 1167 // Udp6Read and Ip6 instance. 1168 // 1169 Status = PxeBcCheckIpv6Support (ControllerHandle, Private, &Private->Mode.Ipv6Available); 1170 if (EFI_ERROR (Status)) { 1171 // 1172 // Fail to get the data whether UNDI supports IPv6. Set default value. 1173 // 1174 Private->Mode.Ipv6Available = TRUE; 1175 } 1176 1177 if (!Private->Mode.Ipv6Available) { 1178 goto ON_ERROR; 1179 } 1180 1181 Udp6CfgData = &Private->Udp6CfgData; 1182 Ip6CfgData = &Private->Ip6CfgData; 1183 1184 Udp6CfgData->AcceptAnyPort = TRUE; 1185 Udp6CfgData->AllowDuplicatePort = TRUE; 1186 Udp6CfgData->HopLimit = PXEBC_DEFAULT_HOPLIMIT; 1187 Udp6CfgData->ReceiveTimeout = PXEBC_DEFAULT_LIFETIME; 1188 Udp6CfgData->TransmitTimeout = PXEBC_DEFAULT_LIFETIME; 1189 1190 Ip6CfgData->AcceptIcmpErrors = TRUE; 1191 Ip6CfgData->DefaultProtocol = IP6_ICMP; 1192 Ip6CfgData->HopLimit = PXEBC_DEFAULT_HOPLIMIT; 1193 Ip6CfgData->ReceiveTimeout = PXEBC_DEFAULT_LIFETIME; 1194 Ip6CfgData->TransmitTimeout = PXEBC_DEFAULT_LIFETIME; 1195 1196 return EFI_SUCCESS; 1197 1198 ON_ERROR: 1199 PxeBcDestroyIp6Children (This, Private); 1200 return Status; 1201 } 1202 1203 1204 /** 1205 The entry point for UefiPxeBc driver that installs the driver 1206 binding and component name protocol on its image. 1207 1208 @param[in] ImageHandle The Image handle of the driver. 1209 @param[in] SystemTable The system table. 1210 1211 @return EFI_SUCCESS 1212 @return Others 1213 1214 **/ 1215 EFI_STATUS 1216 EFIAPI 1217 PxeBcDriverEntryPoint ( 1218 IN EFI_HANDLE ImageHandle, 1219 IN EFI_SYSTEM_TABLE *SystemTable 1220 ) 1221 { 1222 EFI_STATUS Status; 1223 1224 Status = EfiLibInstallDriverBindingComponentName2 ( 1225 ImageHandle, 1226 SystemTable, 1227 &gPxeBcIp4DriverBinding, 1228 ImageHandle, 1229 &gPxeBcComponentName, 1230 &gPxeBcComponentName2 1231 ); 1232 if (EFI_ERROR (Status)) { 1233 return Status; 1234 } 1235 1236 Status = EfiLibInstallDriverBindingComponentName2 ( 1237 ImageHandle, 1238 SystemTable, 1239 &gPxeBcIp6DriverBinding, 1240 NULL, 1241 &gPxeBcComponentName, 1242 &gPxeBcComponentName2 1243 ); 1244 if (EFI_ERROR (Status)) { 1245 gBS->UninstallMultipleProtocolInterfaces ( 1246 ImageHandle, 1247 &gEfiDriverBindingProtocolGuid, 1248 &gPxeBcIp4DriverBinding, 1249 &gEfiComponentName2ProtocolGuid, 1250 &gPxeBcComponentName2, 1251 &gEfiComponentNameProtocolGuid, 1252 &gPxeBcComponentName, 1253 NULL 1254 ); 1255 } 1256 1257 return Status; 1258 } 1259 1260 /** 1261 Test to see if this driver supports ControllerHandle. This is the worker function for 1262 PxeBcIp4(6)DriverBindingSupported. 1263 1264 @param[in] This The pointer to the driver binding protocol. 1265 @param[in] ControllerHandle The handle of device to be tested. 1266 @param[in] RemainingDevicePath Optional parameter used to pick a specific child 1267 device to be started. 1268 @param[in] IpVersion IP_VERSION_4 or IP_VERSION_6. 1269 1270 @retval EFI_SUCCESS This driver supports this device. 1271 @retval EFI_UNSUPPORTED This driver does not support this device. 1272 1273 **/ 1274 EFI_STATUS 1275 EFIAPI 1276 PxeBcSupported ( 1277 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1278 IN EFI_HANDLE ControllerHandle, 1279 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL, 1280 IN UINT8 IpVersion 1281 ) 1282 { 1283 EFI_STATUS Status; 1284 EFI_GUID *DhcpServiceBindingGuid; 1285 EFI_GUID *MtftpServiceBindingGuid; 1286 1287 if (IpVersion == IP_VERSION_4) { 1288 DhcpServiceBindingGuid = &gEfiDhcp4ServiceBindingProtocolGuid; 1289 MtftpServiceBindingGuid = &gEfiMtftp4ServiceBindingProtocolGuid; 1290 } else { 1291 DhcpServiceBindingGuid = &gEfiDhcp6ServiceBindingProtocolGuid; 1292 MtftpServiceBindingGuid = &gEfiMtftp6ServiceBindingProtocolGuid; 1293 } 1294 1295 // 1296 // Try to open the Mtftp and Dhcp protocol to test whether IP stack is ready. 1297 // 1298 Status = gBS->OpenProtocol ( 1299 ControllerHandle, 1300 DhcpServiceBindingGuid, 1301 NULL, 1302 This->DriverBindingHandle, 1303 ControllerHandle, 1304 EFI_OPEN_PROTOCOL_TEST_PROTOCOL 1305 ); 1306 if (!EFI_ERROR (Status)) { 1307 Status = gBS->OpenProtocol ( 1308 ControllerHandle, 1309 MtftpServiceBindingGuid, 1310 NULL, 1311 This->DriverBindingHandle, 1312 ControllerHandle, 1313 EFI_OPEN_PROTOCOL_TEST_PROTOCOL 1314 ); 1315 } 1316 1317 // 1318 // It's unsupported case if IP stack are not ready. 1319 // 1320 if (EFI_ERROR (Status)) { 1321 return EFI_UNSUPPORTED; 1322 } 1323 1324 return EFI_SUCCESS; 1325 } 1326 1327 /** 1328 Start this driver on ControllerHandle. This is the worker function for 1329 PxeBcIp4(6)DriverBindingStart. 1330 1331 @param[in] This The pointer to the driver binding protocol. 1332 @param[in] ControllerHandle The handle of device to be started. 1333 @param[in] RemainingDevicePath Optional parameter used to pick a specific child 1334 device to be started. 1335 @param[in] IpVersion IP_VERSION_4 or IP_VERSION_6. 1336 1337 1338 @retval EFI_SUCCESS This driver is installed to ControllerHandle. 1339 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle. 1340 @retval other This driver does not support this device. 1341 1342 **/ 1343 EFI_STATUS 1344 EFIAPI 1345 PxeBcStart ( 1346 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1347 IN EFI_HANDLE ControllerHandle, 1348 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL, 1349 IN UINT8 IpVersion 1350 ) 1351 { 1352 PXEBC_PRIVATE_DATA *Private; 1353 EFI_STATUS Status; 1354 PXEBC_PRIVATE_PROTOCOL *Id; 1355 BOOLEAN FirstStart; 1356 1357 FirstStart = FALSE; 1358 Status = gBS->OpenProtocol ( 1359 ControllerHandle, 1360 &gEfiCallerIdGuid, 1361 (VOID **) &Id, 1362 This->DriverBindingHandle, 1363 ControllerHandle, 1364 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1365 ); 1366 if (!EFI_ERROR (Status)) { 1367 // 1368 // Skip the initialization if the driver has been started already. 1369 // 1370 Private = PXEBC_PRIVATE_DATA_FROM_ID (Id); 1371 } else { 1372 FirstStart = TRUE; 1373 // 1374 // If the driver has not been started yet, it should do initialization. 1375 // 1376 Private = AllocateZeroPool (sizeof (PXEBC_PRIVATE_DATA)); 1377 if (Private == NULL) { 1378 return EFI_OUT_OF_RESOURCES; 1379 } 1380 1381 CopyMem ( 1382 &Private->PxeBc, 1383 &gPxeBcProtocolTemplate, 1384 sizeof (EFI_PXE_BASE_CODE_PROTOCOL) 1385 ); 1386 1387 Private->Signature = PXEBC_PRIVATE_DATA_SIGNATURE; 1388 Private->Controller = ControllerHandle; 1389 Private->Image = This->ImageHandle; 1390 Private->PxeBc.Mode = &Private->Mode; 1391 Private->Mode.Ipv6Supported = TRUE; 1392 Private->Mode.AutoArp = TRUE; 1393 Private->Mode.TTL = DEFAULT_TTL; 1394 Private->Mode.ToS = DEFAULT_ToS; 1395 1396 // 1397 // Open device path to prepare for appending virtual NIC node. 1398 // 1399 Status = gBS->OpenProtocol ( 1400 ControllerHandle, 1401 &gEfiDevicePathProtocolGuid, 1402 (VOID **) &Private->DevicePath, 1403 This->DriverBindingHandle, 1404 ControllerHandle, 1405 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1406 ); 1407 1408 if (EFI_ERROR (Status)) { 1409 goto ON_ERROR; 1410 } 1411 1412 // 1413 // Get the NII interface if it exists, it's not required. 1414 // 1415 Status = gBS->OpenProtocol ( 1416 ControllerHandle, 1417 &gEfiNetworkInterfaceIdentifierProtocolGuid_31, 1418 (VOID **) &Private->Nii, 1419 This->DriverBindingHandle, 1420 ControllerHandle, 1421 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1422 ); 1423 if (EFI_ERROR (Status)) { 1424 Private->Nii = NULL; 1425 } 1426 1427 // 1428 // Install PxeBaseCodePrivate protocol onto the real NIC handler. 1429 // PxeBaseCodePrivate protocol is only used to keep the relationship between 1430 // NIC handle and virtual child handles. 1431 // gEfiCallerIdGuid will be used as its protocol guid. 1432 // 1433 Status = gBS->InstallProtocolInterface ( 1434 &ControllerHandle, 1435 &gEfiCallerIdGuid, 1436 EFI_NATIVE_INTERFACE, 1437 &Private->Id 1438 ); 1439 if (EFI_ERROR (Status)) { 1440 goto ON_ERROR; 1441 } 1442 1443 // 1444 // Try to locate SNP protocol. 1445 // 1446 NetLibGetSnpHandle(ControllerHandle, &Private->Snp); 1447 } 1448 1449 if (IpVersion == IP_VERSION_4) { 1450 // 1451 // Try to create virtual NIC handle for IPv4. 1452 // 1453 Status = PxeBcCreateIp4Children (This, ControllerHandle, Private); 1454 } else { 1455 // 1456 // Try to create virtual NIC handle for IPv6. 1457 // 1458 Status = PxeBcCreateIp6Children (This, ControllerHandle, Private); 1459 } 1460 if (EFI_ERROR (Status)) { 1461 // 1462 // Failed to start PXE driver if IPv4 and IPv6 stack are both not available. 1463 // 1464 Status = EFI_DEVICE_ERROR; 1465 goto ON_ERROR; 1466 } 1467 1468 return EFI_SUCCESS; 1469 1470 ON_ERROR: 1471 if (FirstStart) { 1472 gBS->UninstallProtocolInterface ( 1473 ControllerHandle, 1474 &gEfiCallerIdGuid, 1475 &Private->Id 1476 ); 1477 } 1478 1479 if (IpVersion == IP_VERSION_4) { 1480 PxeBcDestroyIp4Children (This, Private); 1481 } else { 1482 PxeBcDestroyIp6Children (This, Private); 1483 } 1484 1485 if (FirstStart && Private != NULL) { 1486 FreePool (Private); 1487 } 1488 1489 return Status; 1490 } 1491 1492 1493 /** 1494 Stop this driver on ControllerHandle. This is the worker function for 1495 PxeBcIp4(6)DriverBindingStop. 1496 1497 @param[in] This Protocol instance pointer. 1498 @param[in] ControllerHandle Handle of device to stop driver on. 1499 @param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of 1500 children is zero stop the entire bus driver. 1501 @param[in] ChildHandleBuffer List of Child Handles to Stop. 1502 @param[in] IpVersion IP_VERSION_4 or IP_VERSION_6. 1503 1504 @retval EFI_SUCCESS This driver was removed ControllerHandle. 1505 @retval EFI_DEVICE_ERROR An unexpected system or network error occurred. 1506 @retval Others This driver was not removed from this device 1507 1508 **/ 1509 EFI_STATUS 1510 EFIAPI 1511 PxeBcStop ( 1512 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1513 IN EFI_HANDLE ControllerHandle, 1514 IN UINTN NumberOfChildren, 1515 IN EFI_HANDLE *ChildHandleBuffer, 1516 IN UINT8 IpVersion 1517 ) 1518 { 1519 PXEBC_PRIVATE_DATA *Private; 1520 PXEBC_VIRTUAL_NIC *VirtualNic; 1521 EFI_LOAD_FILE_PROTOCOL *LoadFile; 1522 EFI_STATUS Status; 1523 EFI_HANDLE NicHandle; 1524 PXEBC_PRIVATE_PROTOCOL *Id; 1525 1526 Private = NULL; 1527 NicHandle = NULL; 1528 VirtualNic = NULL; 1529 LoadFile = NULL; 1530 Id = NULL; 1531 1532 Status = gBS->OpenProtocol ( 1533 ControllerHandle, 1534 &gEfiLoadFileProtocolGuid, 1535 (VOID **) &LoadFile, 1536 This->DriverBindingHandle, 1537 ControllerHandle, 1538 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1539 ); 1540 if (EFI_ERROR (Status)) { 1541 // 1542 // Get the Nic handle by any pass-over service child handle. 1543 // 1544 if (IpVersion == IP_VERSION_4) { 1545 NicHandle = PxeBcGetNicByIp4Children (ControllerHandle); 1546 } else { 1547 NicHandle = PxeBcGetNicByIp6Children (ControllerHandle); 1548 } 1549 if (NicHandle == NULL) { 1550 return EFI_SUCCESS; 1551 } 1552 1553 // 1554 // Try to retrieve the private data by PxeBcPrivate protocol. 1555 // 1556 Status = gBS->OpenProtocol ( 1557 NicHandle, 1558 &gEfiCallerIdGuid, 1559 (VOID **) &Id, 1560 This->DriverBindingHandle, 1561 ControllerHandle, 1562 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1563 ); 1564 if (EFI_ERROR (Status)) { 1565 return Status; 1566 } 1567 Private = PXEBC_PRIVATE_DATA_FROM_ID (Id); 1568 1569 } else { 1570 // 1571 // It's a virtual handle with LoadFileProtocol. 1572 // 1573 Status = gBS->OpenProtocol ( 1574 ControllerHandle, 1575 &gEfiLoadFileProtocolGuid, 1576 (VOID **) &LoadFile, 1577 This->DriverBindingHandle, 1578 ControllerHandle, 1579 EFI_OPEN_PROTOCOL_GET_PROTOCOL 1580 ); 1581 if (EFI_ERROR (Status)) { 1582 return Status; 1583 } 1584 1585 VirtualNic = PXEBC_VIRTUAL_NIC_FROM_LOADFILE (LoadFile); 1586 Private = VirtualNic->Private; 1587 NicHandle = Private->Controller; 1588 } 1589 1590 // 1591 // Stop functionality of PXE Base Code protocol 1592 // 1593 Status = Private->PxeBc.Stop (&Private->PxeBc); 1594 if (Status != EFI_SUCCESS && Status != EFI_NOT_STARTED) { 1595 return Status; 1596 } 1597 1598 1599 if (Private->Ip4Nic != NULL && IpVersion == IP_VERSION_4) { 1600 PxeBcDestroyIp4Children (This, Private); 1601 } 1602 1603 if (Private->Ip6Nic != NULL && IpVersion == IP_VERSION_6) { 1604 PxeBcDestroyIp6Children (This, Private); 1605 } 1606 1607 if (Private->Ip4Nic == NULL && Private->Ip6Nic == NULL) { 1608 gBS->UninstallProtocolInterface ( 1609 NicHandle, 1610 &gEfiCallerIdGuid, 1611 &Private->Id 1612 ); 1613 FreePool (Private); 1614 } 1615 1616 return EFI_SUCCESS; 1617 } 1618 1619 /** 1620 Test to see if this driver supports ControllerHandle. This service 1621 is called by the EFI boot service ConnectController(). In 1622 order to make drivers as small as possible, there are a few calling 1623 restrictions for this service. ConnectController() must 1624 follow these calling restrictions. If any other agent wishes to call 1625 Supported() it must also follow these calling restrictions. 1626 1627 @param[in] This The pointer to the driver binding protocol. 1628 @param[in] ControllerHandle The handle of device to be tested. 1629 @param[in] RemainingDevicePath Optional parameter used to pick a specific child 1630 device to be started. 1631 1632 @retval EFI_SUCCESS This driver supports this device. 1633 @retval EFI_UNSUPPORTED This driver does not support this device. 1634 1635 **/ 1636 EFI_STATUS 1637 EFIAPI 1638 PxeBcIp4DriverBindingSupported ( 1639 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1640 IN EFI_HANDLE ControllerHandle, 1641 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 1642 ) 1643 { 1644 return PxeBcSupported ( 1645 This, 1646 ControllerHandle, 1647 RemainingDevicePath, 1648 IP_VERSION_4 1649 ); 1650 } 1651 1652 /** 1653 Start this driver on ControllerHandle. This service is called by the 1654 EFI boot service ConnectController(). In order to make 1655 drivers as small as possible, there are a few calling restrictions for 1656 this service. ConnectController() must follow these 1657 calling restrictions. If any other agent wishes to call Start() it 1658 must also follow these calling restrictions. 1659 1660 @param[in] This The pointer to the driver binding protocol. 1661 @param[in] ControllerHandle The handle of device to be started. 1662 @param[in] RemainingDevicePath Optional parameter used to pick a specific child 1663 device to be started. 1664 1665 @retval EFI_SUCCESS This driver is installed to ControllerHandle. 1666 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle. 1667 @retval other This driver does not support this device. 1668 1669 **/ 1670 EFI_STATUS 1671 EFIAPI 1672 PxeBcIp4DriverBindingStart ( 1673 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1674 IN EFI_HANDLE ControllerHandle, 1675 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 1676 ) 1677 { 1678 return PxeBcStart ( 1679 This, 1680 ControllerHandle, 1681 RemainingDevicePath, 1682 IP_VERSION_4 1683 ); 1684 } 1685 1686 /** 1687 Stop this driver on ControllerHandle. This service is called by the 1688 EFI boot service DisconnectController(). In order to 1689 make drivers as small as possible, there are a few calling 1690 restrictions for this service. DisconnectController() 1691 must follow these calling restrictions. If any other agent wishes 1692 to call Stop() it must also follow these calling restrictions. 1693 1694 @param[in] This Protocol instance pointer. 1695 @param[in] ControllerHandle Handle of device to stop driver on 1696 @param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of 1697 children is zero stop the entire bus driver. 1698 @param[in] ChildHandleBuffer List of Child Handles to Stop. 1699 1700 @retval EFI_SUCCESS This driver is removed ControllerHandle 1701 @retval EFI_DEVICE_ERROR An unexpected system or network error occurred. 1702 @retval Others This driver was not removed from this device. 1703 1704 **/ 1705 EFI_STATUS 1706 EFIAPI 1707 PxeBcIp4DriverBindingStop ( 1708 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1709 IN EFI_HANDLE ControllerHandle, 1710 IN UINTN NumberOfChildren, 1711 IN EFI_HANDLE *ChildHandleBuffer 1712 ) 1713 { 1714 return PxeBcStop ( 1715 This, 1716 ControllerHandle, 1717 NumberOfChildren, 1718 ChildHandleBuffer, 1719 IP_VERSION_4 1720 ); 1721 } 1722 1723 /** 1724 Test to see if this driver supports ControllerHandle. This service 1725 is called by the EFI boot service ConnectController(). In 1726 order to make drivers as small as possible, there are a few calling 1727 restrictions for this service. ConnectController() must 1728 follow these calling restrictions. If any other agent wishes to call 1729 Supported() it must also follow these calling restrictions. 1730 1731 @param[in] This The pointer to the driver binding protocol. 1732 @param[in] ControllerHandle The handle of device to be tested. 1733 @param[in] RemainingDevicePath Optional parameter use to pick a specific child 1734 device to be started. 1735 1736 @retval EFI_SUCCESS This driver supports this device. 1737 @retval EFI_UNSUPPORTED This driver does not support this device. 1738 1739 **/ 1740 EFI_STATUS 1741 EFIAPI 1742 PxeBcIp6DriverBindingSupported ( 1743 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1744 IN EFI_HANDLE ControllerHandle, 1745 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 1746 ) 1747 { 1748 return PxeBcSupported ( 1749 This, 1750 ControllerHandle, 1751 RemainingDevicePath, 1752 IP_VERSION_6 1753 ); 1754 } 1755 1756 /** 1757 Start this driver on ControllerHandle. This service is called by the 1758 EFI boot service ConnectController(). In order to make 1759 drivers as small as possible, there are a few calling restrictions for 1760 this service. ConnectController() must follow these 1761 calling restrictions. If any other agent wishes to call Start() it 1762 must also follow these calling restrictions. 1763 1764 @param[in] This The pointer to the driver binding protocol. 1765 @param[in] ControllerHandle The handle of device to be started. 1766 @param[in] RemainingDevicePath Optional parameter used to pick a specific child 1767 device to be started. 1768 1769 @retval EFI_SUCCESS This driver is installed to ControllerHandle. 1770 @retval EFI_ALREADY_STARTED This driver is already running on ControllerHandle. 1771 @retval other This driver does not support this device. 1772 1773 **/ 1774 EFI_STATUS 1775 EFIAPI 1776 PxeBcIp6DriverBindingStart ( 1777 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1778 IN EFI_HANDLE ControllerHandle, 1779 IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath OPTIONAL 1780 ) 1781 { 1782 return PxeBcStart ( 1783 This, 1784 ControllerHandle, 1785 RemainingDevicePath, 1786 IP_VERSION_6 1787 ); 1788 } 1789 1790 /** 1791 Stop this driver on ControllerHandle. This service is called by the 1792 EFI boot service DisconnectController(). In order to 1793 make drivers as small as possible, there are a few calling 1794 restrictions for this service. DisconnectController() 1795 must follow these calling restrictions. If any other agent wishes 1796 to call Stop() it must also follow these calling restrictions. 1797 1798 @param[in] This Protocol instance pointer. 1799 @param[in] ControllerHandle Handle of device to stop driver on 1800 @param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of 1801 children is zero stop the entire bus driver. 1802 @param[in] ChildHandleBuffer List of Child Handles to Stop. 1803 1804 @retval EFI_SUCCESS This driver is removed ControllerHandle 1805 @retval EFI_DEVICE_ERROR An unexpected system or network error occurred. 1806 @retval Others This driver was not removed from this device. 1807 1808 **/ 1809 EFI_STATUS 1810 EFIAPI 1811 PxeBcIp6DriverBindingStop ( 1812 IN EFI_DRIVER_BINDING_PROTOCOL *This, 1813 IN EFI_HANDLE ControllerHandle, 1814 IN UINTN NumberOfChildren, 1815 IN EFI_HANDLE *ChildHandleBuffer 1816 ) 1817 { 1818 return PxeBcStop ( 1819 This, 1820 ControllerHandle, 1821 NumberOfChildren, 1822 ChildHandleBuffer, 1823 IP_VERSION_6 1824 ); 1825 } 1826
