Mtftp6Driver.c@ 69222

Last change on this file since 69222 was 58466, checked in by vboxsync, 9 years ago
EFI/Firmware: Merged in the svn:eol-style, svn:mime-type and trailing whitespace cleanup that was done after the initial UDK2014.SP1 import: svn merge ^{/vendor/edk2/UDK2014.SP1}/vendor/edk2/current .
Property svn:eol-style set to `native`
File size: 20.7 KB

Line
1	/** @file
2	Driver Binding functions and Service Binding functions
3	implementation for Mtftp6 Driver.
4
5	Copyright (c) 2009 - 2012, 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 "Mtftp6Impl.h"
18
19
20	EFI_DRIVER_BINDING_PROTOCOL gMtftp6DriverBinding = {
21	Mtftp6DriverBindingSupported,
22	Mtftp6DriverBindingStart,
23	Mtftp6DriverBindingStop,
24	0xa,
25	NULL,
26	NULL
27	};
28
29	EFI_SERVICE_BINDING_PROTOCOL gMtftp6ServiceBindingTemplate = {
30	Mtftp6ServiceBindingCreateChild,
31	Mtftp6ServiceBindingDestroyChild
32	};
33
34
35	/**
36	Destroy the MTFTP6 service. The MTFTP6 service may be partly initialized,
37	or partly destroyed. If a resource is destroyed, it is marked as such in
38	case the destroy failed and is called again later.
39
40	@param[in] Service The MTFTP6 service to be destroyed.
41
42	**/
43	VOID
44	Mtftp6DestroyService (
45	IN MTFTP6_SERVICE *Service
46	)
47	{
48	//
49	// Make sure all children instances have been already destroyed.
50	//
51	ASSERT (Service->ChildrenNum == 0);
52
53	if (Service->DummyUdpIo != NULL) {
54	UdpIoFreeIo (Service->DummyUdpIo);
55	}
56
57	if (Service->Timer != NULL) {
58	gBS->CloseEvent (Service->Timer);
59	}
60
61	FreePool (Service);
62	}
63
64
65	/**
66	Create then initialize a MTFTP6 service binding instance.
67
68	@param[in] Controller The controller to install the MTFTP6 service
69	binding on.
70	@param[in] Image The driver binding image of the MTFTP6 driver.
71	@param[out] Service The variable to receive the created service
72	binding instance.
73
74	@retval EFI_OUT_OF_RESOURCES Failed to allocate resources to create the instance
75	@retval EFI_DEVICE_ERROR Failed to create a NULL UDP port to keep connection with UDP.
76	@retval EFI_SUCCESS The service instance is created for the controller.
77
78	**/
79	EFI_STATUS
80	Mtftp6CreateService (
81	IN EFI_HANDLE Controller,
82	IN EFI_HANDLE Image,
83	OUT MTFTP6_SERVICE **Service
84	)
85	{
86	MTFTP6_SERVICE *Mtftp6Srv;
87	EFI_STATUS Status;
88
89	ASSERT (Service != NULL);
90
91	*Service = NULL;
92	Mtftp6Srv = AllocateZeroPool (sizeof (MTFTP6_SERVICE));
93
94	if (Mtftp6Srv == NULL) {
95	return EFI_OUT_OF_RESOURCES;
96	}
97
98	Mtftp6Srv->Signature = MTFTP6_SERVICE_SIGNATURE;
99	Mtftp6Srv->Controller = Controller;
100	Mtftp6Srv->Image = Image;
101	Mtftp6Srv->ChildrenNum = 0;
102
103	CopyMem (
104	&Mtftp6Srv->ServiceBinding,
105	&gMtftp6ServiceBindingTemplate,
106	sizeof (EFI_SERVICE_BINDING_PROTOCOL)
107	);
108
109	InitializeListHead (&Mtftp6Srv->Children);
110
111	//
112	// Create a internal timer for all instances.
113	//
114	Status = gBS->CreateEvent (
115	EVT_NOTIFY_SIGNAL \| EVT_TIMER,
116	TPL_CALLBACK,
117	Mtftp6OnTimerTick,
118	Mtftp6Srv,
119	&Mtftp6Srv->Timer
120	);
121
122	if (EFI_ERROR (Status)) {
123	FreePool (Mtftp6Srv);
124	return Status;
125	}
126
127	//
128	// Create a dummy Udp6Io to build parent-child relationship between Udp6 driver
129	// and Mtftp6 driver.
130	//
131	Mtftp6Srv->DummyUdpIo = UdpIoCreateIo (
132	Controller,
133	Image,
134	Mtftp6ConfigDummyUdpIo,
135	UDP_IO_UDP6_VERSION,
136	NULL
137	);
138
139	if (Mtftp6Srv->DummyUdpIo == NULL) {
140	gBS->CloseEvent (Mtftp6Srv->Timer);
141	FreePool (Mtftp6Srv);
142	return EFI_DEVICE_ERROR;
143	}
144
145	*Service = Mtftp6Srv;
146	return EFI_SUCCESS;
147	}
148
149
150	/**
151	Destroy the MTFTP6 instance and recycle the resources.
152
153	@param[in] Instance The pointer to the MTFTP6 instance.
154
155	**/
156	VOID
157	Mtftp6DestroyInstance (
158	IN MTFTP6_INSTANCE *Instance
159	)
160	{
161	LIST_ENTRY *Entry;
162	LIST_ENTRY *Next;
163	MTFTP6_BLOCK_RANGE *Block;
164
165	if (Instance->Config != NULL) {
166	FreePool (Instance->Config);
167	}
168
169	if (Instance->Token != NULL && Instance->Token->Event != NULL) {
170	gBS->SignalEvent (Instance->Token->Event);
171	}
172
173	if (Instance->LastPacket != NULL) {
174	NetbufFree (Instance->LastPacket);
175	}
176
177	if (Instance->UdpIo!= NULL) {
178	UdpIoFreeIo (Instance->UdpIo);
179	}
180
181	if (Instance->McastUdpIo != NULL) {
182	UdpIoFreeIo (Instance->McastUdpIo);
183	}
184
185	NET_LIST_FOR_EACH_SAFE (Entry, Next, &Instance->BlkList) {
186	Block = NET_LIST_USER_STRUCT (Entry, MTFTP6_BLOCK_RANGE, Link);
187	RemoveEntryList (Entry);
188	FreePool (Block);
189	}
190
191	FreePool (Instance);
192	}
193
194
195	/**
196	Create the MTFTP6 instance and initialize it.
197
198	@param[in] Service The pointer to the MTFTP6 service.
199	@param[out] Instance The pointer to the MTFTP6 instance.
200
201	@retval EFI_OUT_OF_RESOURCES Failed to allocate resources.
202	@retval EFI_SUCCESS The MTFTP6 instance is created.
203
204	**/
205	EFI_STATUS
206	Mtftp6CreateInstance (
207	IN MTFTP6_SERVICE *Service,
208	OUT MTFTP6_INSTANCE **Instance
209	)
210	{
211	MTFTP6_INSTANCE *Mtftp6Ins;
212
213	*Instance = NULL;
214	Mtftp6Ins = AllocateZeroPool (sizeof (MTFTP6_INSTANCE));
215
216	if (Mtftp6Ins == NULL) {
217	return EFI_OUT_OF_RESOURCES;
218	}
219
220	Mtftp6Ins->Signature = MTFTP6_INSTANCE_SIGNATURE;
221	Mtftp6Ins->InDestroy = FALSE;
222	Mtftp6Ins->Service = Service;
223
224	CopyMem (
225	&Mtftp6Ins->Mtftp6,
226	&gMtftp6ProtocolTemplate,
227	sizeof (EFI_MTFTP6_PROTOCOL)
228	);
229
230	InitializeListHead (&Mtftp6Ins->Link);
231	InitializeListHead (&Mtftp6Ins->BlkList);
232
233	*Instance = Mtftp6Ins;
234
235	return EFI_SUCCESS;
236	}
237
238
239	/**
240	Callback function which provided by user to remove one node in NetDestroyLinkList process.
241
242	@param[in] Entry The entry to be removed.
243	@param[in] Context Pointer to the callback context corresponds to the Context in NetDestroyLinkList.
244
245	@retval EFI_SUCCESS The entry has been removed successfully.
246	@retval Others Fail to remove the entry.
247
248	**/
249	EFI_STATUS
250	EFIAPI
251	Mtftp6DestroyChildEntryInHandleBuffer (
252	IN LIST_ENTRY *Entry,
253	IN VOID *Context
254	)
255	{
256	MTFTP6_INSTANCE *Instance;
257	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
258	UINTN NumberOfChildren;
259	EFI_HANDLE *ChildHandleBuffer;
260
261	if (Entry == NULL \|\| Context == NULL) {
262	return EFI_INVALID_PARAMETER;
263	}
264
265	Instance = NET_LIST_USER_STRUCT_S (Entry, MTFTP6_INSTANCE, Link, MTFTP6_INSTANCE_SIGNATURE);
266	ServiceBinding = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ServiceBinding;
267	NumberOfChildren = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->NumberOfChildren;
268	ChildHandleBuffer = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *) Context)->ChildHandleBuffer;
269
270	if (!NetIsInHandleBuffer (Instance->Handle, NumberOfChildren, ChildHandleBuffer)) {
271	return EFI_SUCCESS;
272	}
273
274	return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
275	}
276
277
278	/**
279	This is the declaration of an EFI image entry point. This entry point is
280	the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers, including
281	both device drivers and bus drivers.
282
283	Entry point of the MTFTP6 driver to install various protocols.
284
285	@param[in] ImageHandle The firmware allocated handle for the UEFI image.
286	@param[in] SystemTable The pointer to the EFI System Table.
287
288	@retval EFI_SUCCESS The operation completed successfully.
289	@retval EFI_OUT_OF_RESOURCES The request could not be completed due to a lack of resources.
290
291	**/
292	EFI_STATUS
293	EFIAPI
294	Mtftp6DriverEntryPoint (
295	IN EFI_HANDLE ImageHandle,
296	IN EFI_SYSTEM_TABLE *SystemTable
297	)
298	{
299	return EfiLibInstallDriverBindingComponentName2 (
300	ImageHandle,
301	SystemTable,
302	&gMtftp6DriverBinding,
303	ImageHandle,
304	&gMtftp6ComponentName,
305	&gMtftp6ComponentName2
306	);
307	}
308
309
310	/**
311	Test to see if this driver supports Controller. This service
312	is called by the EFI boot service ConnectController(). In
313	order to make drivers as small as possible, there are calling
314	restrictions for this service. ConnectController() must
315	follow these calling restrictions. If any other agent wishes to call
316	Supported(), it must also follow these calling restrictions.
317
318	@param[in] This Protocol instance pointer.
319	@param[in] Controller Handle of device to test
320	@param[in] RemainingDevicePath Optional parameter use to pick a specific child.
321	device to start.
322
323	@retval EFI_SUCCESS This driver supports this device.
324	@retval Others This driver does not support this device.
325
326	**/
327	EFI_STATUS
328	EFIAPI
329	Mtftp6DriverBindingSupported (
330	IN EFI_DRIVER_BINDING_PROTOCOL *This,
331	IN EFI_HANDLE Controller,
332	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
333	)
334	{
335	return gBS->OpenProtocol (
336	Controller,
337	&gEfiUdp6ServiceBindingProtocolGuid,
338	NULL,
339	This->DriverBindingHandle,
340	Controller,
341	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
342	);
343	}
344
345
346	/**
347	Start this driver on Controller. This service is called by the
348	EFI boot service ConnectController(). In order to make
349	drivers as small as possible, there are calling restrictions for
350	this service. ConnectController() must follow these
351	calling restrictions. If any other agent wishes to call Start() it
352	must also follow these calling restrictions.
353
354	@param[in] This Protocol instance pointer.
355	@param[in] Controller Handle of device to bind driver to.
356	@param[in] RemainingDevicePath Optional parameter use to pick a specific child
357	device to start.
358
359	@retval EFI_SUCCESS This driver is added to Controller.
360	@retval EFI_ALREADY_STARTED This driver is already running on Controller.
361	@retval Others This driver does not support this device.
362
363	**/
364	EFI_STATUS
365	EFIAPI
366	Mtftp6DriverBindingStart (
367	IN EFI_DRIVER_BINDING_PROTOCOL *This,
368	IN EFI_HANDLE Controller,
369	IN EFI_DEVICE_PATH_PROTOCOL *RemainingDevicePath
370	)
371	{
372	MTFTP6_SERVICE *Service;
373	EFI_STATUS Status;
374
375	//
376	// Directly return if driver is already running on this Nic handle.
377	//
378	Status = gBS->OpenProtocol (
379	Controller,
380	&gEfiMtftp6ServiceBindingProtocolGuid,
381	NULL,
382	This->DriverBindingHandle,
383	Controller,
384	EFI_OPEN_PROTOCOL_TEST_PROTOCOL
385	);
386
387	if (!EFI_ERROR (Status)) {
388	return EFI_ALREADY_STARTED;
389	}
390
391	//
392	// Create Mtftp6 service for this Nic handle
393	//
394	Status = Mtftp6CreateService (
395	Controller,
396	This->DriverBindingHandle,
397	&Service
398	);
399
400	if (EFI_ERROR (Status)) {
401	return Status;
402	}
403
404	ASSERT (Service != NULL);
405
406	//
407	// Start the internal timer to track the packet retransmission.
408	//
409	Status = gBS->SetTimer (
410	Service->Timer,
411	TimerPeriodic,
412	TICKS_PER_SECOND
413	);
414
415	if (EFI_ERROR (Status)) {
416	goto ON_ERROR;
417	}
418
419	//
420	// Install the Mtftp6 service on the Nic handle.
421	//
422	Status = gBS->InstallMultipleProtocolInterfaces (
423	&Controller,
424	&gEfiMtftp6ServiceBindingProtocolGuid,
425	&Service->ServiceBinding,
426	NULL
427	);
428
429	if (EFI_ERROR (Status)) {
430	goto ON_ERROR;
431	}
432
433	return EFI_SUCCESS;
434
435	ON_ERROR:
436
437	Mtftp6DestroyService (Service);
438	return Status;
439	}
440
441
442	/**
443	Stop this driver on Controller. This service is called by the
444	EFI boot service DisconnectController(). In order to
445	make drivers as small as possible, there are calling
446	restrictions for this service. DisconnectController()
447	must follow these calling restrictions. If any other agent wishes
448	to call Stop(), it must also follow these calling restrictions.
449
450	@param[in] This Protocol instance pointer.
451	@param[in] Controller Handle of device to stop driver on
452	@param[in] NumberOfChildren Number of Handles in ChildHandleBuffer. If number of
453	children is zero, stop the entire bus driver.
454	@param[in] ChildHandleBuffer List of Child Handles to Stop.
455
456	@retval EFI_SUCCESS This driver is removed Controller.
457	@retval EFI_DEVICE_ERROR An unexpected error.
458	@retval Others This driver was not removed from this device.
459
460	**/
461	EFI_STATUS
462	EFIAPI
463	Mtftp6DriverBindingStop (
464	IN EFI_DRIVER_BINDING_PROTOCOL *This,
465	IN EFI_HANDLE Controller,
466	IN UINTN NumberOfChildren,
467	IN EFI_HANDLE *ChildHandleBuffer
468	)
469	{
470	EFI_SERVICE_BINDING_PROTOCOL *ServiceBinding;
471	MTFTP6_SERVICE *Service;
472	EFI_HANDLE NicHandle;
473	EFI_STATUS Status;
474	LIST_ENTRY *List;
475	MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT Context;
476
477	//
478	// Locate the Nic handle to retrieve the Mtftp6 private data.
479	//
480	NicHandle = NetLibGetNicHandle (Controller, &gEfiUdp6ProtocolGuid);
481
482	if (NicHandle == NULL) {
483	return EFI_SUCCESS;
484	}
485
486	Status = gBS->OpenProtocol (
487	NicHandle,
488	&gEfiMtftp6ServiceBindingProtocolGuid,
489	(VOID **) &ServiceBinding,
490	This->DriverBindingHandle,
491	NicHandle,
492	EFI_OPEN_PROTOCOL_GET_PROTOCOL
493	);
494
495	if (EFI_ERROR (Status)) {
496	return EFI_DEVICE_ERROR;
497	}
498
499	Service = MTFTP6_SERVICE_FROM_THIS (ServiceBinding);
500
501	if (!IsListEmpty (&Service->Children)) {
502	//
503	// Destroy the Mtftp6 child instance in ChildHandleBuffer.
504	//
505	List = &Service->Children;
506	Context.ServiceBinding = ServiceBinding;
507	Context.NumberOfChildren = NumberOfChildren;
508	Context.ChildHandleBuffer = ChildHandleBuffer;
509	Status = NetDestroyLinkList (
510	List,
511	Mtftp6DestroyChildEntryInHandleBuffer,
512	&Context,
513	NULL
514	);
515	}
516
517	if (NumberOfChildren == 0 && IsListEmpty (&Service->Children)) {
518	//
519	// Destroy the Mtftp6 service if there is no Mtftp6 child instance left.
520	//
521	gBS->UninstallProtocolInterface (
522	NicHandle,
523	&gEfiMtftp6ServiceBindingProtocolGuid,
524	ServiceBinding
525	);
526
527	Mtftp6DestroyService (Service);
528	Status = EFI_SUCCESS;
529	}
530
531	return Status;
532	}
533
534
535	/**
536	Creates a child handle and installs a protocol.
537
538	The CreateChild() function installs a protocol on ChildHandle.
539	If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
540	If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
541
542	@param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
543	@param[in, out] ChildHandle Pointer to the handle of the child to create. If it is NULL,
544	then a new handle is created. If it is a pointer to an existing
545	UEFI handle, then the protocol is added to the existing UEFI handle.
546
547	@retval EFI_SUCCES The protocol was added to ChildHandle.
548	@retval EFI_INVALID_PARAMETER ChildHandle is NULL.
549	@retval Others The child handle was not created.
550
551	**/
552	EFI_STATUS
553	EFIAPI
554	Mtftp6ServiceBindingCreateChild (
555	IN EFI_SERVICE_BINDING_PROTOCOL *This,
556	IN OUT EFI_HANDLE *ChildHandle
557	)
558	{
559	MTFTP6_SERVICE *Service;
560	MTFTP6_INSTANCE *Instance;
561	EFI_STATUS Status;
562	EFI_TPL OldTpl;
563	VOID *Udp6;
564
565	if (This == NULL \|\| ChildHandle == NULL) {
566	return EFI_INVALID_PARAMETER;
567	}
568
569	Service = MTFTP6_SERVICE_FROM_THIS (This);
570
571	Status = Mtftp6CreateInstance (Service, &Instance);
572
573	if (EFI_ERROR (Status)) {
574	return Status;
575	}
576
577	ASSERT (Instance != NULL);
578
579	//
580	// Install the Mtftp6 protocol on the new child handle.
581	//
582	Status = gBS->InstallMultipleProtocolInterfaces (
583	ChildHandle,
584	&gEfiMtftp6ProtocolGuid,
585	&Instance->Mtftp6,
586	NULL
587	);
588
589	if (EFI_ERROR (Status)) {
590	goto ON_ERROR;
591	}
592
593	Instance->Handle = *ChildHandle;
594
595	//
596	// Open the Udp6 protocol by child.
597	//
598	Status = gBS->OpenProtocol (
599	Service->DummyUdpIo->UdpHandle,
600	&gEfiUdp6ProtocolGuid,
601	(VOID **) &Udp6,
602	gMtftp6DriverBinding.DriverBindingHandle,
603	Instance->Handle,
604	EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
605	);
606
607	if (EFI_ERROR (Status)) {
608	gBS->UninstallMultipleProtocolInterfaces (
609	Instance->Handle,
610	&gEfiMtftp6ProtocolGuid,
611	&Instance->Mtftp6,
612	NULL
613	);
614
615	goto ON_ERROR;
616	}
617
618	//
619	// Add the new Mtftp6 instance into the children list of Mtftp6 service.
620	//
621	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
622
623	InsertTailList (&Service->Children, &Instance->Link);
624	Service->ChildrenNum++;
625
626	gBS->RestoreTPL (OldTpl);
627	return EFI_SUCCESS;
628
629	ON_ERROR:
630
631	Mtftp6DestroyInstance (Instance);
632	return Status;
633	}
634
635
636	/**
637	Destroys a child handle with a protocol installed on it.
638
639	The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
640	that was installed by CreateChild() from ChildHandle. If the removed protocol is the
641	last protocol on ChildHandle, then ChildHandle is destroyed.
642
643	@param[in] This Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
644	@param[in] ChildHandle Handle of the child to destroy.
645
646	@retval EFI_SUCCES The protocol was removed from ChildHandle.
647	@retval EFI_UNSUPPORTED ChildHandle does not support the protocol that is being removed.
648	@retval EFI_INVALID_PARAMETER Child handle is NULL.
649	@retval Others The child handle was not destroyed
650
651	**/
652	EFI_STATUS
653	EFIAPI
654	Mtftp6ServiceBindingDestroyChild (
655	IN EFI_SERVICE_BINDING_PROTOCOL *This,
656	IN EFI_HANDLE ChildHandle
657	)
658	{
659	MTFTP6_SERVICE *Service;
660	MTFTP6_INSTANCE *Instance;
661	EFI_MTFTP6_PROTOCOL *Mtftp6;
662	EFI_STATUS Status;
663	EFI_TPL OldTpl;
664
665	if (This == NULL \|\| ChildHandle == NULL) {
666	return EFI_INVALID_PARAMETER;
667	}
668
669	//
670	// Locate the Nic handle to retrieve the Mtftp6 private data.
671	//
672	Status = gBS->OpenProtocol (
673	ChildHandle,
674	&gEfiMtftp6ProtocolGuid,
675	(VOID **) &Mtftp6,
676	gMtftp6DriverBinding.DriverBindingHandle,
677	ChildHandle,
678	EFI_OPEN_PROTOCOL_GET_PROTOCOL
679	);
680
681	if (EFI_ERROR (Status)) {
682	return EFI_UNSUPPORTED;
683	}
684
685	Instance = MTFTP6_INSTANCE_FROM_THIS (Mtftp6);
686	Service = MTFTP6_SERVICE_FROM_THIS (This);
687
688	if (Instance->Service != Service) {
689	return EFI_INVALID_PARAMETER;
690	}
691
692	//
693	// Check whether the instance already in Destroy state.
694	//
695	if (Instance->InDestroy) {
696	return EFI_SUCCESS;
697	}
698
699	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
700
701	Instance->InDestroy = TRUE;
702
703	gBS->CloseProtocol (
704	Service->DummyUdpIo->UdpHandle,
705	&gEfiUdp6ProtocolGuid,
706	gMtftp6DriverBinding.DriverBindingHandle,
707	ChildHandle
708	);
709
710	if (Instance->UdpIo != NULL) {
711	gBS->CloseProtocol (
712	Instance->UdpIo->UdpHandle,
713	&gEfiUdp6ProtocolGuid,
714	gMtftp6DriverBinding.DriverBindingHandle,
715	Instance->Handle
716	);
717	}
718
719	if (Instance->McastUdpIo != NULL) {
720	gBS->CloseProtocol (
721	Instance->McastUdpIo->UdpHandle,
722	&gEfiUdp6ProtocolGuid,
723	gMtftp6DriverBinding.DriverBindingHandle,
724	Instance->Handle
725	);
726	}
727
728	//
729	// Uninstall the MTFTP6 protocol first to enable a top down destruction.
730	//
731	gBS->RestoreTPL (OldTpl);
732	Status = gBS->UninstallProtocolInterface (
733	ChildHandle,
734	&gEfiMtftp6ProtocolGuid,
735	Mtftp6
736	);
737	OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
738	if (EFI_ERROR (Status)) {
739	Instance->InDestroy = FALSE;
740	gBS->RestoreTPL (OldTpl);
741	return Status;
742	}
743
744	//
745	// Remove the Mtftp6 instance from the children list of Mtftp6 service.
746	//
747	RemoveEntryList (&Instance->Link);
748	Service->ChildrenNum --;
749
750	gBS->RestoreTPL (OldTpl);
751
752	Mtftp6DestroyInstance (Instance);
753
754	return EFI_SUCCESS;
755	}

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/NetworkPkg/Mtftp6Dxe/Mtftp6Driver.c@ 69222

Download in other formats: