VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/NetworkPkg/UefiPxeBcDxe/PxeBcDriver.c@ 77662

Last change on this file since 77662 was 77662, checked in by vboxsync, 6 years ago

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

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