VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareOld/NetworkPkg/UefiPxeBcDxe/PxeBcDriver.c@ 59844

Last change on this file since 59844 was 48674, checked in by vboxsync, 11 years ago

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

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette