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