MdeModulePkg/Universal/Network/Ip4Dxe/Ip4Driver.c

   1 /** @file
   2   The driver binding and service binding protocol for IP4 driver.
   3
   4 Copyright (c) 2005 - 2009, Intel Corporation.<BR>
   5 All rights reserved. This program and the accompanying materials
   6 are licensed and made available under the terms and conditions of the BSD License
   7 which accompanies this distribution.  The full text of the license may be found at
   8 http://opensource.org/licenses/bsd-license.php
   9
  10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  12
  13 **/
  14
  15 #include "Ip4Impl.h"
  16
  17 EFI_DRIVER_BINDING_PROTOCOL gIp4DriverBinding = {
  18   Ip4DriverBindingSupported,
  19   Ip4DriverBindingStart,
  20   Ip4DriverBindingStop,
  21   0xa,
  22   NULL,
  23   NULL
  24 };
  25
  26 /**
  27   This is the declaration of an EFI image entry point. This entry point is
  28   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers including
  29   both device drivers and bus drivers.
  30
  31   The entry point for IP4 driver which install the driver
  32   binding and component name protocol on its image.
  33
  34   @param[in]  ImageHandle           The firmware allocated handle for the UEFI image.
  35   @param[in]  SystemTable           A pointer to the EFI System Table.
  36
  37   @retval EFI_SUCCESS           The operation completed successfully.
  38   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
  39
  40 **/
  41 EFI_STATUS
  42 EFIAPI
  43 Ip4DriverEntryPoint (
  44   IN EFI_HANDLE             ImageHandle,
  45   IN EFI_SYSTEM_TABLE       *SystemTable
  46   )
  47 {
  48   return EfiLibInstallDriverBindingComponentName2 (
  49            ImageHandle,
  50            SystemTable,
  51            &gIp4DriverBinding,
  52            ImageHandle,
  53            &gIp4ComponentName,
  54            &gIp4ComponentName2
  55            );
  56 }
  57
  58 /**
  59   Test to see if this driver supports ControllerHandle. This service
  60   is called by the EFI boot service ConnectController(). In
  61   order to make drivers as small as possible, there are a few calling
  62   restrictions for this service. ConnectController() must
  63   follow these calling restrictions. If any other agent wishes to call
  64   Supported() it must also follow these calling restrictions.
  65
  66   @param[in]  This                Protocol instance pointer.
  67   @param[in]  ControllerHandle    Handle of device to test
  68   @param[in]  RemainingDevicePath Optional parameter use to pick a specific child
  69                                   device to start.
  70
  71   @retval EFI_SUCCESS         This driver supports this device
  72   @retval EFI_ALREADY_STARTED This driver is already running on this device
  73   @retval other               This driver does not support this device
  74
  75 **/
  76 EFI_STATUS
  77 EFIAPI
  78 Ip4DriverBindingSupported (
  79   IN EFI_DRIVER_BINDING_PROTOCOL  * This,
  80   IN EFI_HANDLE                   ControllerHandle,
  81   IN EFI_DEVICE_PATH_PROTOCOL     * RemainingDevicePath OPTIONAL
  82   )
  83 {
  84   EFI_STATUS                Status;
  85
  86   //
  87   // Test for the MNP service binding Protocol
  88   //
  89   Status = gBS->OpenProtocol (
  90                   ControllerHandle,
  91                   &gEfiManagedNetworkServiceBindingProtocolGuid,
  92                   NULL,
  93                   This->DriverBindingHandle,
  94                   ControllerHandle,
  95                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
  96                   );
  97
  98   if (EFI_ERROR (Status)) {
  99     return Status;
 100   }
 101
 102   //
 103   // Test for the Arp service binding Protocol
 104   //
 105   Status = gBS->OpenProtocol (
 106                   ControllerHandle,
 107                   &gEfiArpServiceBindingProtocolGuid,
 108                   NULL,
 109                   This->DriverBindingHandle,
 110                   ControllerHandle,
 111                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 112                   );
 113
 114   return Status;
 115 }
 116
 117 /**
 118   Clean up a IP4 service binding instance. It will release all
 119   the resource allocated by the instance. The instance may be
 120   partly initialized, or partly destroyed. If a resource is
 121   destroyed, it is marked as that in case the destory failed and
 122   being called again later.
 123
 124   @param[in]  IpSb               The IP4 serviceing binding instance to clean up
 125
 126   @retval EFI_SUCCESS            The resource used by the instance are cleaned up
 127   @retval other                  Failed to clean up some of the resources.
 128
 129 **/
 130 EFI_STATUS
 131 Ip4CleanService (
 132   IN IP4_SERVICE            *IpSb
 133   );
 134
 135
 136 /**
 137   Create a new IP4 driver service binding private instance.
 138
 139   @param  Controller         The controller that has MNP service binding
 140                              installed
 141   @param  ImageHandle        The IP4 driver's image handle
 142   @param  Service            The variable to receive the newly created IP4
 143                              service.
 144
 145   @retval EFI_OUT_OF_RESOURCES   Failed to allocate some resource
 146   @retval EFI_SUCCESS            A new IP4 service binding private is created.
 147   @retval other                  Other error occurs.
 148
 149 **/
 150 EFI_STATUS
 151 Ip4CreateService (
 152   IN  EFI_HANDLE            Controller,
 153   IN  EFI_HANDLE            ImageHandle,
 154   OUT IP4_SERVICE           **Service
 155   )
 156 {
 157   IP4_SERVICE               *IpSb;
 158   EFI_STATUS                Status;
 159
 160   ASSERT (Service != NULL);
 161
 162   *Service = NULL;
 163
 164   //
 165   // allocate a service private data then initialize all the filed to
 166   // empty resources, so if any thing goes wrong when allocating
 167   // resources, Ip4CleanService can be called to clean it up.
 168   //
 169   IpSb = AllocatePool (sizeof (IP4_SERVICE));
 170
 171   if (IpSb == NULL) {
 172     return EFI_OUT_OF_RESOURCES;
 173   }
 174
 175   IpSb->Signature                   = IP4_SERVICE_SIGNATURE;
 176   IpSb->ServiceBinding.CreateChild  = Ip4ServiceBindingCreateChild;
 177   IpSb->ServiceBinding.DestroyChild = Ip4ServiceBindingDestroyChild;
 178   IpSb->State                       = IP4_SERVICE_UNSTARTED;
 179   IpSb->InDestory                   = FALSE;
 180
 181   IpSb->NumChildren                 = 0;
 182   InitializeListHead (&IpSb->Children);
 183
 184   InitializeListHead (&IpSb->Interfaces);
 185   IpSb->DefaultInterface            = NULL;
 186   IpSb->DefaultRouteTable           = NULL;
 187
 188   Ip4InitAssembleTable (&IpSb->Assemble);
 189
 190   IpSb->IgmpCtrl.Igmpv1QuerySeen    = 0;
 191   InitializeListHead (&IpSb->IgmpCtrl.Groups);
 192
 193   IpSb->Image                       = ImageHandle;
 194   IpSb->Controller                  = Controller;
 195
 196   IpSb->MnpChildHandle              = NULL;
 197   IpSb->Mnp                         = NULL;
 198
 199   IpSb->MnpConfigData.ReceivedQueueTimeoutValue = 0;
 200   IpSb->MnpConfigData.TransmitQueueTimeoutValue = 0;
 201   IpSb->MnpConfigData.ProtocolTypeFilter        = IP4_ETHER_PROTO;
 202   IpSb->MnpConfigData.EnableUnicastReceive      = TRUE;
 203   IpSb->MnpConfigData.EnableMulticastReceive    = TRUE;
 204   IpSb->MnpConfigData.EnableBroadcastReceive    = TRUE;
 205   IpSb->MnpConfigData.EnablePromiscuousReceive  = FALSE;
 206   IpSb->MnpConfigData.FlushQueuesOnReset        = TRUE;
 207   IpSb->MnpConfigData.EnableReceiveTimestamps   = FALSE;
 208   IpSb->MnpConfigData.DisableBackgroundPolling  = FALSE;
 209
 210   ZeroMem (&IpSb->SnpMode, sizeof (EFI_SIMPLE_NETWORK_MODE));
 211
 212   IpSb->Timer                       = NULL;
 213   IpSb->Ip4Config                   = NULL;
 214   IpSb->DoneEvent                   = NULL;
 215   IpSb->ReconfigEvent               = NULL;
 216   IpSb->ActiveEvent                 = NULL;
 217
 218   //
 219   // Create various resources. First create the route table, timer
 220   // event and MNP child. IGMP, interface's initialization depend
 221   // on the MNP child.
 222   //
 223   IpSb->DefaultRouteTable = Ip4CreateRouteTable ();
 224
 225   if (IpSb->DefaultRouteTable == NULL) {
 226     Status = EFI_OUT_OF_RESOURCES;
 227     goto ON_ERROR;
 228   }
 229
 230   Status = gBS->CreateEvent (
 231                   EVT_NOTIFY_SIGNAL | EVT_TIMER,
 232                   TPL_CALLBACK,
 233                   Ip4TimerTicking,
 234                   IpSb,
 235                   &IpSb->Timer
 236                   );
 237
 238   if (EFI_ERROR (Status)) {
 239     goto ON_ERROR;
 240   }
 241
 242   Status = NetLibCreateServiceChild (
 243              Controller,
 244              ImageHandle,
 245              &gEfiManagedNetworkServiceBindingProtocolGuid,
 246              &IpSb->MnpChildHandle
 247              );
 248
 249   if (EFI_ERROR (Status)) {
 250     goto ON_ERROR;
 251   }
 252
 253   Status = gBS->OpenProtocol (
 254                   IpSb->MnpChildHandle,
 255                   &gEfiManagedNetworkProtocolGuid,
 256                   (VOID **) &IpSb->Mnp,
 257                   ImageHandle,
 258                   Controller,
 259                   EFI_OPEN_PROTOCOL_BY_DRIVER
 260                   );
 261
 262   if (EFI_ERROR (Status)) {
 263     goto ON_ERROR;
 264   }
 265
 266   Status = Ip4ServiceConfigMnp (IpSb, TRUE);
 267
 268   if (EFI_ERROR (Status)) {
 269     goto ON_ERROR;
 270   }
 271
 272   Status = IpSb->Mnp->GetModeData (IpSb->Mnp, NULL, &IpSb->SnpMode);
 273
 274   if (EFI_ERROR (Status)) {
 275     goto ON_ERROR;
 276   }
 277
 278   Status = Ip4InitIgmp (IpSb);
 279
 280   if (EFI_ERROR (Status)) {
 281     goto ON_ERROR;
 282   }
 283
 284   IpSb->DefaultInterface = Ip4CreateInterface (IpSb->Mnp, Controller, ImageHandle);
 285
 286   if (IpSb->DefaultInterface == NULL) {
 287     Status = EFI_OUT_OF_RESOURCES;
 288     goto ON_ERROR;
 289   }
 290
 291   InsertHeadList (&IpSb->Interfaces, &IpSb->DefaultInterface->Link);
 292
 293   IpSb->MaxPacketSize = IpSb->SnpMode.MaxPacketSize - sizeof (IP4_HEAD);
 294   if (NetLibGetVlanId (IpSb->Controller) != 0) {
 295     //
 296     // This is a VLAN device, reduce MTU by VLAN tag length
 297     //
 298     IpSb->MaxPacketSize -= NET_VLAN_TAG_LEN;
 299   }
 300   IpSb->MacString = NULL;
 301
 302   *Service = IpSb;
 303   return EFI_SUCCESS;
 304
 305 ON_ERROR:
 306   Ip4CleanService (IpSb);
 307   FreePool (IpSb);
 308
 309   return Status;
 310 }
 311
 312
 313 /**
 314   Clean up a IP4 service binding instance. It will release all
 315   the resource allocated by the instance. The instance may be
 316   partly initialized, or partly destroyed. If a resource is
 317   destroyed, it is marked as that in case the destory failed and
 318   being called again later.
 319
 320   @param[in]  IpSb               The IP4 serviceing binding instance to clean up
 321
 322   @retval EFI_SUCCESS            The resource used by the instance are cleaned up
 323   @retval other                  Failed to clean up some of the resources.
 324
 325 **/
 326 EFI_STATUS
 327 Ip4CleanService (
 328   IN IP4_SERVICE            *IpSb
 329   )
 330 {
 331   EFI_STATUS                Status;
 332
 333   if (IpSb->DefaultInterface != NULL) {
 334     Status = Ip4FreeInterface (IpSb->DefaultInterface, NULL);
 335
 336     if (EFI_ERROR (Status)) {
 337       return Status;
 338     }
 339
 340     IpSb->DefaultInterface = NULL;
 341   }
 342
 343   if (IpSb->DefaultRouteTable != NULL) {
 344     Ip4FreeRouteTable (IpSb->DefaultRouteTable);
 345     IpSb->DefaultRouteTable = NULL;
 346   }
 347
 348   Ip4CleanAssembleTable (&IpSb->Assemble);
 349
 350   if (IpSb->MnpChildHandle != NULL) {
 351     if (IpSb->Mnp != NULL) {
 352       gBS->CloseProtocol (
 353              IpSb->MnpChildHandle,
 354              &gEfiManagedNetworkProtocolGuid,
 355              IpSb->Image,
 356              IpSb->Controller
 357              );
 358
 359       IpSb->Mnp = NULL;
 360     }
 361
 362     NetLibDestroyServiceChild (
 363       IpSb->Controller,
 364       IpSb->Image,
 365       &gEfiManagedNetworkServiceBindingProtocolGuid,
 366       IpSb->MnpChildHandle
 367       );
 368
 369     IpSb->MnpChildHandle = NULL;
 370   }
 371
 372   if (IpSb->Timer != NULL) {
 373     gBS->SetTimer (IpSb->Timer, TimerCancel, 0);
 374     gBS->CloseEvent (IpSb->Timer);
 375
 376     IpSb->Timer = NULL;
 377   }
 378
 379   if (IpSb->Ip4Config != NULL) {
 380     IpSb->Ip4Config->Stop (IpSb->Ip4Config);
 381
 382     gBS->CloseProtocol (
 383           IpSb->Controller,
 384           &gEfiIp4ConfigProtocolGuid,
 385           IpSb->Image,
 386           IpSb->Controller
 387           );
 388
 389     gBS->CloseEvent (IpSb->DoneEvent);
 390     gBS->CloseEvent (IpSb->ReconfigEvent);
 391     IpSb->ActiveEvent = NULL;
 392     IpSb->Ip4Config = NULL;
 393   }
 394
 395   return EFI_SUCCESS;
 396 }
 397
 398
 399 /**
 400   Start this driver on ControllerHandle. This service is called by the
 401   EFI boot service ConnectController(). In order to make
 402   drivers as small as possible, there are a few calling restrictions for
 403   this service. ConnectController() must follow these
 404   calling restrictions. If any other agent wishes to call Start() it
 405   must also follow these calling restrictions.
 406
 407   @param[in]  This                 Protocol instance pointer.
 408   @param[in]  ControllerHandle     Handle of device to bind driver to
 409   @param[in]  RemainingDevicePath  Optional parameter use to pick a specific child
 410                                    device to start.
 411
 412   @retval EFI_SUCCESS          This driver is added to ControllerHandle
 413   @retval EFI_ALREADY_STARTED  This driver is already running on ControllerHandle
 414   @retval other                This driver does not support this device
 415
 416 **/
 417 EFI_STATUS
 418 EFIAPI
 419 Ip4DriverBindingStart (
 420   IN EFI_DRIVER_BINDING_PROTOCOL  * This,
 421   IN EFI_HANDLE                   ControllerHandle,
 422   IN EFI_DEVICE_PATH_PROTOCOL     * RemainingDevicePath OPTIONAL
 423   )
 424 {
 425   IP4_SERVICE               *IpSb;
 426   EFI_STATUS                Status;
 427
 428   //
 429   // Test for the Ip4 service binding protocol
 430   //
 431   Status = gBS->OpenProtocol (
 432                   ControllerHandle,
 433                   &gEfiIp4ServiceBindingProtocolGuid,
 434                   NULL,
 435                   This->DriverBindingHandle,
 436                   ControllerHandle,
 437                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 438                   );
 439
 440   if (Status == EFI_SUCCESS) {
 441     return EFI_ALREADY_STARTED;
 442   }
 443
 444   Status = Ip4CreateService (ControllerHandle, This->DriverBindingHandle, &IpSb);
 445
 446   if (EFI_ERROR (Status)) {
 447     return Status;
 448   }
 449
 450   //
 451   // Install the Ip4ServiceBinding Protocol onto ControlerHandle
 452   //
 453   Status = gBS->InstallMultipleProtocolInterfaces (
 454                   &ControllerHandle,
 455                   &gEfiIp4ServiceBindingProtocolGuid,
 456                   &IpSb->ServiceBinding,
 457                   NULL
 458                   );
 459
 460   if (EFI_ERROR (Status)) {
 461     goto FREE_SERVICE;
 462   }
 463
 464   //
 465   // ready to go: start the receiving and timer
 466   //
 467   Status = Ip4ReceiveFrame (IpSb->DefaultInterface, NULL, Ip4AccpetFrame, IpSb);
 468
 469   if (EFI_ERROR (Status)) {
 470     goto UNINSTALL_PROTOCOL;
 471   }
 472
 473   Status = gBS->SetTimer (IpSb->Timer, TimerPeriodic, TICKS_PER_SECOND);
 474
 475   if (EFI_ERROR (Status)) {
 476     goto UNINSTALL_PROTOCOL;
 477   }
 478
 479   //
 480   // Initialize the IP4 ID
 481   //
 482   mIp4Id = (UINT16)NET_RANDOM (NetRandomInitSeed ());
 483
 484   Ip4SetVariableData (IpSb);
 485
 486   return Status;
 487
 488 UNINSTALL_PROTOCOL:
 489   gBS->UninstallProtocolInterface (
 490          ControllerHandle,
 491          &gEfiIp4ServiceBindingProtocolGuid,
 492          &IpSb->ServiceBinding
 493          );
 494
 495 FREE_SERVICE:
 496   Ip4CleanService (IpSb);
 497   FreePool (IpSb);
 498
 499   return Status;
 500 }
 501
 502
 503 /**
 504   Stop this driver on ControllerHandle. This service is called by the
 505   EFI boot service DisconnectController(). In order to
 506   make drivers as small as possible, there are a few calling
 507   restrictions for this service. DisconnectController()
 508   must follow these calling restrictions. If any other agent wishes
 509   to call Stop() it must also follow these calling restrictions.
 510
 511   @param[in]  This              Protocol instance pointer.
 512   @param[in]  ControllerHandle  Handle of device to stop driver on
 513   @param[in]  NumberOfChildren  Number of Handles in ChildHandleBuffer. If number
 514                                 of children is zero stop the entire bus driver.
 515   @param[in]  ChildHandleBuffer List of Child Handles to Stop.
 516
 517   @retval EFI_SUCCESS           This driver is removed ControllerHandle
 518   @retval other                 This driver was not removed from this device
 519
 520 **/
 521 EFI_STATUS
 522 EFIAPI
 523 Ip4DriverBindingStop (
 524   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 525   IN  EFI_HANDLE                   ControllerHandle,
 526   IN  UINTN                        NumberOfChildren,
 527   IN  EFI_HANDLE                   *ChildHandleBuffer
 528   )
 529 {
 530   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
 531   IP4_SERVICE                   *IpSb;
 532   IP4_PROTOCOL                  *IpInstance;
 533   EFI_HANDLE                    NicHandle;
 534   EFI_STATUS                    Status;
 535   EFI_TPL                       OldTpl;
 536   INTN                          State;
 537   BOOLEAN                       IsArp;
 538
 539   //
 540   // IP4 driver opens the MNP child, ARP children or the IP4_CONFIG protocol
 541   // by driver. So the ControllerHandle may be the MNP child handle, ARP child
 542   // handle, or the NIC (UNDI) handle because IP4_CONFIG protocol is installed
 543   // in the NIC handle.
 544   //
 545   //
 546   // First, check whether it is the IP4_CONFIG protocol being uninstalled.
 547   // IP4_CONFIG protocol is installed on the NIC handle. It isn't necessary
 548   // to clean up the default configuration if IP4_CONFIG is being stopped.
 549   //
 550   Status = gBS->OpenProtocol (
 551                   ControllerHandle,
 552                   &gEfiIp4ConfigProtocolGuid,
 553                   NULL,
 554                   This->DriverBindingHandle,
 555                   ControllerHandle,
 556                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 557                   );
 558
 559   if (Status == EFI_SUCCESS) {
 560     //
 561     // Retrieve the IP4 service binding protocol. If failed, it is
 562     // likely that Ip4 ServiceBinding is uninstalled already. In this
 563     // case, return immediately.
 564     //
 565     Status = gBS->OpenProtocol (
 566                     ControllerHandle,
 567                     &gEfiIp4ServiceBindingProtocolGuid,
 568                     (VOID **) &ServiceBinding,
 569                     This->DriverBindingHandle,
 570                     ControllerHandle,
 571                     EFI_OPEN_PROTOCOL_GET_PROTOCOL
 572                     );
 573
 574     if (EFI_ERROR (Status)) {
 575       return EFI_DEVICE_ERROR;
 576     }
 577
 578     IpSb = IP4_SERVICE_FROM_PROTOCOL (ServiceBinding);
 579
 580     OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 581
 582     if (IpSb->Ip4Config != NULL && (IpSb->State != IP4_SERVICE_DESTORY)) {
 583
 584       IpSb->Ip4Config->Stop (IpSb->Ip4Config);
 585
 586       Status = gBS->CloseProtocol (
 587                       ControllerHandle,
 588                       &gEfiIp4ConfigProtocolGuid,
 589                       IpSb->Image,
 590                       ControllerHandle
 591                       );
 592
 593       if (EFI_ERROR (Status)) {
 594         gBS->RestoreTPL (OldTpl);
 595         return Status;
 596       }
 597
 598       //
 599       // If the auto configure hasn't complete, mark it as not started.
 600       //
 601       if (IpSb->State == IP4_SERVICE_STARTED) {
 602         IpSb->State = IP4_SERVICE_UNSTARTED;
 603       }
 604
 605       IpSb->Ip4Config = NULL;
 606       gBS->CloseEvent (IpSb->DoneEvent);
 607       gBS->CloseEvent (IpSb->ReconfigEvent);
 608     }
 609
 610     gBS->RestoreTPL (OldTpl);
 611     return EFI_SUCCESS;
 612   }
 613
 614   //
 615   // Either MNP or ARP protocol is being uninstalled. The controller
 616   // handle is either the MNP child or ARP child. But, the IP4's
 617   // service binding is installed on the NIC handle. So, need to open
 618   // the protocol info to find the NIC handle.
 619   //
 620   IsArp     = FALSE;
 621   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiManagedNetworkProtocolGuid);
 622
 623   if (NicHandle == NULL) {
 624     NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiArpProtocolGuid);
 625     IsArp     = TRUE;
 626   }
 627
 628   if (NicHandle == NULL) {
 629     return EFI_DEVICE_ERROR;
 630   }
 631
 632   //
 633   // Retrieve the IP4 service binding protocol
 634   //
 635   Status = gBS->OpenProtocol (
 636                   NicHandle,
 637                   &gEfiIp4ServiceBindingProtocolGuid,
 638                   (VOID **) &ServiceBinding,
 639                   This->DriverBindingHandle,
 640                   NicHandle,
 641                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 642                   );
 643
 644   if (EFI_ERROR (Status)) {
 645     return EFI_DEVICE_ERROR;
 646   }
 647
 648   IpSb   = IP4_SERVICE_FROM_PROTOCOL (ServiceBinding);
 649
 650   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 651
 652   if (IpSb->InDestory) {
 653     gBS->RestoreTPL (OldTpl);
 654     return EFI_SUCCESS;
 655   }
 656
 657   if (IsArp) {
 658     while (!IsListEmpty (&IpSb->Children)) {
 659       IpInstance = NET_LIST_HEAD (&IpSb->Children, IP4_PROTOCOL, Link);
 660
 661       ServiceBinding->DestroyChild (ServiceBinding, IpInstance->Handle);
 662     }
 663
 664     if (IpSb->NumChildren != 0) {
 665       Status = EFI_DEVICE_ERROR;
 666       goto ON_ERROR;
 667     }
 668
 669     IpSb->InDestory = TRUE;
 670
 671     State           = IpSb->State;
 672     IpSb->State     = IP4_SERVICE_DESTORY;
 673
 674     //
 675     // Clear the variable data.
 676     //
 677     Ip4ClearVariableData (IpSb);
 678
 679     //
 680     // OK, clean other resources then uninstall the service binding protocol.
 681     //
 682     Status = Ip4CleanService (IpSb);
 683
 684     if (EFI_ERROR (Status)) {
 685       IpSb->State = State;
 686       goto ON_ERROR;
 687     }
 688
 689     gBS->UninstallProtocolInterface (
 690            NicHandle,
 691            &gEfiIp4ServiceBindingProtocolGuid,
 692            ServiceBinding
 693            );
 694
 695     FreePool (IpSb);
 696   } else if (NumberOfChildren == 0) {
 697     IpSb->InDestory = TRUE;
 698
 699     State           = IpSb->State;
 700     IpSb->State     = IP4_SERVICE_DESTORY;
 701
 702     //
 703     // Clear the variable data.
 704     //
 705     Ip4ClearVariableData (IpSb);
 706
 707     //
 708     // OK, clean other resources then uninstall the service binding protocol.
 709     //
 710     Status = Ip4CleanService (IpSb);
 711
 712     if (EFI_ERROR (Status)) {
 713       IpSb->State = State;
 714       goto ON_ERROR;
 715     }
 716
 717     gBS->UninstallProtocolInterface (
 718            NicHandle,
 719            &gEfiIp4ServiceBindingProtocolGuid,
 720            ServiceBinding
 721            );
 722
 723     FreePool (IpSb);
 724   } else {
 725
 726     while (!IsListEmpty (&IpSb->Children)) {
 727       IpInstance = NET_LIST_HEAD (&IpSb->Children, IP4_PROTOCOL, Link);
 728
 729       ServiceBinding->DestroyChild (ServiceBinding, IpInstance->Handle);
 730     }
 731
 732     if (IpSb->NumChildren != 0) {
 733       Status = EFI_DEVICE_ERROR;
 734     }
 735   }
 736
 737 ON_ERROR:
 738
 739   gBS->RestoreTPL (OldTpl);
 740   return Status;
 741 }
 742
 743
 744 /**
 745   Creates a child handle and installs a protocol.
 746
 747   The CreateChild() function installs a protocol on ChildHandle.
 748   If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
 749   If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
 750
 751   @param  This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 752   @param  ChildHandle Pointer to the handle of the child to create. If it is NULL,
 753                       then a new handle is created. If it is a pointer to an existing UEFI handle,
 754                       then the protocol is added to the existing UEFI handle.
 755
 756   @retval EFI_SUCCES            The protocol was added to ChildHandle.
 757   @retval EFI_INVALID_PARAMETER ChildHandle is NULL.
 758   @retval EFI_OUT_OF_RESOURCES  There are not enough resources availabe to create
 759                                 the child
 760   @retval other                 The child handle was not created
 761
 762 **/
 763 EFI_STATUS
 764 EFIAPI
 765 Ip4ServiceBindingCreateChild (
 766   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 767   IN OUT EFI_HANDLE                *ChildHandle
 768   )
 769 {
 770   IP4_SERVICE               *IpSb;
 771   IP4_PROTOCOL              *IpInstance;
 772   EFI_TPL                   OldTpl;
 773   EFI_STATUS                Status;
 774   VOID                      *Mnp;
 775
 776   if ((This == NULL) || (ChildHandle == NULL)) {
 777     return EFI_INVALID_PARAMETER;
 778   }
 779
 780   IpSb       = IP4_SERVICE_FROM_PROTOCOL (This);
 781   IpInstance = AllocatePool (sizeof (IP4_PROTOCOL));
 782
 783   if (IpInstance == NULL) {
 784     return EFI_OUT_OF_RESOURCES;
 785   }
 786
 787   Ip4InitProtocol (IpSb, IpInstance);
 788
 789   //
 790   // Install Ip4 onto ChildHandle
 791   //
 792   Status = gBS->InstallMultipleProtocolInterfaces (
 793                   ChildHandle,
 794                   &gEfiIp4ProtocolGuid,
 795                   &IpInstance->Ip4Proto,
 796                   NULL
 797                   );
 798
 799   if (EFI_ERROR (Status)) {
 800     goto ON_ERROR;
 801   }
 802
 803   IpInstance->Handle = *ChildHandle;
 804
 805   //
 806   // Open the Managed Network protocol BY_CHILD.
 807   //
 808   Status = gBS->OpenProtocol (
 809                   IpSb->MnpChildHandle,
 810                   &gEfiManagedNetworkProtocolGuid,
 811                   (VOID **) &Mnp,
 812                   gIp4DriverBinding.DriverBindingHandle,
 813                   IpInstance->Handle,
 814                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 815                   );
 816   if (EFI_ERROR (Status)) {
 817     gBS->UninstallMultipleProtocolInterfaces (
 818            ChildHandle,
 819            &gEfiIp4ProtocolGuid,
 820            &IpInstance->Ip4Proto,
 821            NULL
 822            );
 823
 824     goto ON_ERROR;
 825   }
 826
 827   //
 828   // Insert it into the service binding instance.
 829   //
 830   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 831
 832   InsertTailList (&IpSb->Children, &IpInstance->Link);
 833   IpSb->NumChildren++;
 834
 835   gBS->RestoreTPL (OldTpl);
 836
 837 ON_ERROR:
 838
 839   if (EFI_ERROR (Status)) {
 840
 841     Ip4CleanProtocol (IpInstance);
 842
 843     FreePool (IpInstance);
 844   }
 845
 846   return Status;
 847 }
 848
 849
 850 /**
 851   Destroys a child handle with a protocol installed on it.
 852
 853   The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
 854   that was installed by CreateChild() from ChildHandle. If the removed protocol is the
 855   last protocol on ChildHandle, then ChildHandle is destroyed.
 856
 857   @param  This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 858   @param  ChildHandle Handle of the child to destroy
 859
 860   @retval EFI_SUCCES            The protocol was removed from ChildHandle.
 861   @retval EFI_UNSUPPORTED       ChildHandle does not support the protocol that is being removed.
 862   @retval EFI_INVALID_PARAMETER Child handle is not a valid UEFI Handle.
 863   @retval EFI_ACCESS_DENIED     The protocol could not be removed from the ChildHandle
 864                                 because its services are being used.
 865   @retval other                 The child handle was not destroyed
 866
 867 **/
 868 EFI_STATUS
 869 EFIAPI
 870 Ip4ServiceBindingDestroyChild (
 871   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 872   IN EFI_HANDLE                    ChildHandle
 873   )
 874 {
 875   EFI_STATUS                Status;
 876   IP4_SERVICE               *IpSb;
 877   IP4_PROTOCOL              *IpInstance;
 878   EFI_IP4_PROTOCOL          *Ip4;
 879   EFI_TPL                   OldTpl;
 880   INTN                      State;
 881
 882   if ((This == NULL) || (ChildHandle == NULL)) {
 883     return EFI_INVALID_PARAMETER;
 884   }
 885
 886   //
 887   // Retrieve the private context data structures
 888   //
 889   IpSb   = IP4_SERVICE_FROM_PROTOCOL (This);
 890
 891   Status = gBS->OpenProtocol (
 892                   ChildHandle,
 893                   &gEfiIp4ProtocolGuid,
 894                   (VOID **) &Ip4,
 895                   gIp4DriverBinding.DriverBindingHandle,
 896                   ChildHandle,
 897                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 898                   );
 899
 900   if (EFI_ERROR (Status)) {
 901     return EFI_UNSUPPORTED;
 902   }
 903
 904   IpInstance = IP4_INSTANCE_FROM_PROTOCOL (Ip4);
 905
 906   if (IpInstance->Service != IpSb) {
 907     return EFI_INVALID_PARAMETER;
 908   }
 909
 910   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 911
 912   //
 913   // A child can be destoried more than once. For example,
 914   // Ip4DriverBindingStop will destory all of its children.
 915   // when UDP driver is being stopped, it will destory all
 916   // the IP child it opens.
 917   //
 918   if (IpInstance->State == IP4_STATE_DESTORY) {
 919     gBS->RestoreTPL (OldTpl);
 920     return EFI_SUCCESS;
 921   }
 922
 923   State             = IpInstance->State;
 924   IpInstance->State = IP4_STATE_DESTORY;
 925
 926   //
 927   // Close the Managed Network protocol.
 928   //
 929   gBS->CloseProtocol (
 930          IpSb->MnpChildHandle,
 931          &gEfiManagedNetworkProtocolGuid,
 932          gIp4DriverBinding.DriverBindingHandle,
 933          ChildHandle
 934          );
 935
 936   //
 937   // Uninstall the IP4 protocol first. Many thing happens during
 938   // this:
 939   // 1. The consumer of the IP4 protocol will be stopped if it
 940   // opens the protocol BY_DRIVER. For eaxmple, if MNP driver is
 941   // stopped, IP driver's stop function will be called, and uninstall
 942   // EFI_IP4_PROTOCOL will trigger the UDP's stop function. This
 943   // makes it possible to create the network stack bottom up, and
 944   // stop it top down.
 945   // 2. the upper layer will recycle the received packet. The recycle
 946   // event's TPL is higher than this function. The recycle events
 947   // will be called back before preceeding. If any packets not recycled,
 948   // that means there is a resource leak.
 949   //
 950   Status = gBS->UninstallProtocolInterface (
 951                   ChildHandle,
 952                   &gEfiIp4ProtocolGuid,
 953                   &IpInstance->Ip4Proto
 954                   );
 955
 956   if (EFI_ERROR (Status)) {
 957     goto ON_ERROR;
 958   }
 959
 960   Status = Ip4CleanProtocol (IpInstance);
 961
 962   Ip4SetVariableData (IpSb);
 963
 964   if (EFI_ERROR (Status)) {
 965     gBS->InstallMultipleProtocolInterfaces (
 966            &ChildHandle,
 967            &gEfiIp4ProtocolGuid,
 968            Ip4,
 969            NULL
 970            );
 971
 972     goto ON_ERROR;
 973   }
 974
 975   RemoveEntryList (&IpInstance->Link);
 976   IpSb->NumChildren--;
 977
 978   gBS->RestoreTPL (OldTpl);
 979
 980   FreePool (IpInstance);
 981   return EFI_SUCCESS;
 982
 983 ON_ERROR:
 984   IpInstance->State = State;
 985   gBS->RestoreTPL (OldTpl);
 986
 987   return Status;
 988 }