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