NetworkPkg/Udp6Dxe/Udp6Driver.c

   1 /** @file
   2   Driver Binding functions and Service Binding functions for the Network driver module.
   3
   4   Copyright (c) 2009 - 2011, Intel Corporation. All rights reserved.<BR>
   5
   6   This program and the accompanying materials
   7   are licensed and made available under the terms and conditions of the BSD License
   8   which accompanies this distribution.  The full text of the license may be found at
   9   http://opensource.org/licenses/bsd-license.php.
  10
  11   THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  12   WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  13
  14 **/
  15
  16 #include "Udp6Impl.h"
  17
  18 EFI_DRIVER_BINDING_PROTOCOL gUdp6DriverBinding = {
  19   Udp6DriverBindingSupported,
  20   Udp6DriverBindingStart,
  21   Udp6DriverBindingStop,
  22   0xa,
  23   NULL,
  24   NULL
  25 };
  26
  27 EFI_SERVICE_BINDING_PROTOCOL mUdp6ServiceBinding = {
  28   Udp6ServiceBindingCreateChild,
  29   Udp6ServiceBindingDestroyChild
  30 };
  31
  32 /**
  33   Tests to see if this driver supports a given controller. If a child device is provided,
  34   it further tests to see if this driver supports creating a handle for the specified child device.
  35
  36   This function checks to see if the driver specified by This supports the device specified by
  37   ControllerHandle. Drivers will typically use the device path attached to
  38   ControllerHandle and/or the services from the bus I/O abstraction attached to
  39   ControllerHandle to determine if the driver supports ControllerHandle. This function
  40   may be called many times during platform initialization. In order to reduce boot times, the tests
  41   performed by this function must be very small, and take as little time as possible to execute. This
  42   function must not change the state of any hardware devices, and this function must be aware that the
  43   device specified by ControllerHandle may already be managed by the same driver or a
  44   different driver. This function must match its calls to AllocatePages() with FreePages(),
  45   AllocatePool() with FreePool(), and OpenProtocol() with CloseProtocol().
  46   Because ControllerHandle may have been previously started by the same driver, if a protocol is
  47   already in the opened state, then it must not be closed with CloseProtocol(). This is required
  48   to guarantee the state of ControllerHandle is not modified by this function.
  49
  50   @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL instance.
  51   @param[in]  ControllerHandle     The handle of the controller to test. This handle
  52                                    must support a protocol interface that supplies
  53                                    an I/O abstraction to the driver.
  54   @param[in]  RemainingDevicePath  A pointer to the remaining portion of a device path.  This
  55                                    parameter is ignored by device drivers, and is optional for bus
  56                                    drivers. For bus drivers, if this parameter is not NULL, then
  57                                    the bus driver must determine if the bus controller specified
  58                                    by ControllerHandle and the child controller specified
  59                                    by RemainingDevicePath are both supported by this
  60                                    bus driver.
  61
  62   @retval EFI_SUCCESS              The device specified by ControllerHandle and
  63                                    RemainingDevicePath is supported by the driver specified by This.
  64   @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle and
  65                                    RemainingDevicePath is already being managed by the driver
  66                                    specified by This.
  67   @retval EFI_ACCESS_DENIED        The device specified by ControllerHandle and
  68                                    RemainingDevicePath is already being managed by a different
  69                                    driver or an application that requires exclusive access.
  70                                    Currently not implemented.
  71   @retval EFI_UNSUPPORTED          The device specified by ControllerHandle and
  72                                    RemainingDevicePath is not supported by the driver specified by This.
  73 **/
  74 EFI_STATUS
  75 EFIAPI
  76 Udp6DriverBindingSupported (
  77   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  78   IN EFI_HANDLE                   ControllerHandle,
  79   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath  OPTIONAL
  80   )
  81 {
  82   EFI_STATUS  Status;
  83   //
  84   // Test for the Udp6ServiceBinding Protocol
  85   //
  86   Status = gBS->OpenProtocol (
  87                   ControllerHandle,
  88                   &gEfiUdp6ServiceBindingProtocolGuid,
  89                   NULL,
  90                   This->DriverBindingHandle,
  91                   ControllerHandle,
  92                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
  93                   );
  94   if (!EFI_ERROR (Status)) {
  95     return EFI_ALREADY_STARTED;
  96   }
  97   //
  98   // Test for the Ip6ServiceBinding Protocol
  99   //
 100   Status = gBS->OpenProtocol (
 101                   ControllerHandle,
 102                   &gEfiIp6ServiceBindingProtocolGuid,
 103                   NULL,
 104                   This->DriverBindingHandle,
 105                   ControllerHandle,
 106                   EFI_OPEN_PROTOCOL_TEST_PROTOCOL
 107                   );
 108
 109   return Status;
 110 }
 111
 112 /**
 113   Start this driver on ControllerHandle.
 114
 115   This service is called by the EFI boot service ConnectController(). In order to make
 116   drivers as small as possible, there are a few calling restrictions for
 117   this service. ConnectController() must follow these
 118   calling restrictions. If any other agent wishes to call Start() it
 119   must also follow these calling restrictions.
 120
 121   @param[in]  This                   Protocol instance pointer.
 122   @param[in]  ControllerHandle       Handle of device to bind the driver to.
 123   @param[in]  RemainingDevicePath    Optional parameter use to pick a specific child
 124                                      device to start.
 125
 126   @retval EFI_SUCCES             This driver is added to ControllerHandle.
 127   @retval EFI_OUT_OF_RESOURCES   The required system resource can't be allocated.
 128   @retval other                  This driver does not support this device.
 129
 130 **/
 131 EFI_STATUS
 132 EFIAPI
 133 Udp6DriverBindingStart (
 134   IN EFI_DRIVER_BINDING_PROTOCOL  *This,
 135   IN EFI_HANDLE                   ControllerHandle,
 136   IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath  OPTIONAL
 137   )
 138 {
 139   EFI_STATUS         Status;
 140   UDP6_SERVICE_DATA  *Udp6Service;
 141
 142   //
 143   // Allocate Private Context Data Structure.
 144   //
 145   Udp6Service = AllocateZeroPool (sizeof (UDP6_SERVICE_DATA));
 146   if (Udp6Service == NULL) {
 147     Status = EFI_OUT_OF_RESOURCES;
 148     goto EXIT;
 149   }
 150
 151   Status = Udp6CreateService (Udp6Service, This->DriverBindingHandle, ControllerHandle);
 152   if (EFI_ERROR (Status)) {
 153     goto EXIT;
 154   }
 155
 156   //
 157   // Install the Udp6ServiceBindingProtocol on the ControllerHandle.
 158   //
 159   Status = gBS->InstallMultipleProtocolInterfaces (
 160                   &ControllerHandle,
 161                   &gEfiUdp6ServiceBindingProtocolGuid,
 162                   &Udp6Service->ServiceBinding,
 163                   NULL
 164                   );
 165   if (EFI_ERROR (Status)) {
 166     Udp6CleanService (Udp6Service);
 167     goto EXIT;
 168   } else {
 169     Status = Udp6SetVariableData (Udp6Service);
 170   }
 171
 172 EXIT:
 173   if (EFI_ERROR (Status)) {
 174     if (Udp6Service != NULL) {
 175       FreePool (Udp6Service);
 176     }
 177   }
 178   return Status;
 179 }
 180
 181 /**
 182   Stop this driver on ControllerHandle.
 183
 184   This service is called by the  EFI boot service DisconnectController(). In order to
 185   make drivers as small as possible, there are a few calling
 186   restrictions for this service. DisconnectController()
 187   must follow these calling restrictions. If any other agent wishes
 188   to call Stop(), it must also follow these calling restrictions.
 189
 190   @param[in]  This                   Protocol instance pointer.
 191   @param[in]  ControllerHandle       Handle of device to stop the driver on.
 192   @param[in]  NumberOfChildren       Number of Handles in ChildHandleBuffer. If the number
 193                                      of children is zero stop the entire bus driver.
 194   @param[in]  ChildHandleBuffer      List of Child Handles to Stop. It is optional.
 195
 196   @retval EFI_SUCCES             This driver is removed ControllerHandle.
 197   @retval EFI_DEVICE_ERROR       Can't find the NicHandle from the ControllerHandle and specified GUID.
 198   @retval other                  This driver was not removed from this device.
 199
 200 **/
 201 EFI_STATUS
 202 EFIAPI
 203 Udp6DriverBindingStop (
 204   IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
 205   IN  EFI_HANDLE                   ControllerHandle,
 206   IN  UINTN                        NumberOfChildren,
 207   IN  EFI_HANDLE                   *ChildHandleBuffer OPTIONAL
 208   )
 209 {
 210   EFI_STATUS                    Status;
 211   EFI_HANDLE                    NicHandle;
 212   EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
 213   UDP6_SERVICE_DATA             *Udp6Service;
 214   UDP6_INSTANCE_DATA            *Instance;
 215
 216   //
 217   // Find the NicHandle where UDP6 ServiceBinding Protocol is installed.
 218   //
 219   NicHandle = NetLibGetNicHandle (ControllerHandle, &gEfiIp6ProtocolGuid);
 220   if (NicHandle == NULL) {
 221     return EFI_DEVICE_ERROR;
 222   }
 223
 224   //
 225   // Retrieve the UDP6 ServiceBinding Protocol.
 226   //
 227   Status = gBS->OpenProtocol (
 228                   NicHandle,
 229                   &gEfiUdp6ServiceBindingProtocolGuid,
 230                   (VOID **) &ServiceBinding,
 231                   This->DriverBindingHandle,
 232                   NicHandle,
 233                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 234                   );
 235   if (EFI_ERROR (Status)) {
 236     return EFI_DEVICE_ERROR;
 237   }
 238
 239   Udp6Service = UDP6_SERVICE_DATA_FROM_THIS (ServiceBinding);
 240
 241   if (NumberOfChildren == 0) {
 242
 243     gBS->UninstallMultipleProtocolInterfaces (
 244            NicHandle,
 245            &gEfiUdp6ServiceBindingProtocolGuid,
 246            &Udp6Service->ServiceBinding,
 247            NULL
 248            );
 249
 250     Udp6ClearVariableData (Udp6Service);
 251
 252     Udp6CleanService (Udp6Service);
 253
 254     FreePool (Udp6Service);
 255   } else {
 256
 257     while (!IsListEmpty (&Udp6Service->ChildrenList)) {
 258       Instance = NET_LIST_HEAD (&Udp6Service->ChildrenList, UDP6_INSTANCE_DATA, Link);
 259
 260       Status = ServiceBinding->DestroyChild (ServiceBinding, Instance->ChildHandle);
 261     }
 262   }
 263
 264   return Status;
 265 }
 266
 267 /**
 268   Creates a child handle and installs a protocol.
 269
 270   The CreateChild() function installs a protocol on ChildHandle.
 271   If ChildHandle is a pointer to NULL, then a new handle is created and returned in ChildHandle.
 272   If ChildHandle is not a pointer to NULL, then the protocol installs on the existing ChildHandle.
 273
 274   @param[in]       This        Pointer to the EFI_SERVICE_BINDING_PROTOCOL instance.
 275   @param[in, out]  ChildHandle Pointer to the handle of the child to create. If it is NULL,
 276                                then a new handle is created. If it is a pointer to an existing UEFI handle,
 277                                then the protocol is added to the existing UEFI handle.
 278
 279   @retval EFI_SUCCES            The protocol was added to ChildHandle.
 280   @retval EFI_INVALID_PARAMETER This is NULL or ChildHandle is NULL.
 281   @retval EFI_OUT_OF_RESOURCES  There are not enough resources availabe to create
 282                                 the child.
 283   @retval other                 The child handle was not created.
 284
 285 **/
 286 EFI_STATUS
 287 EFIAPI
 288 Udp6ServiceBindingCreateChild (
 289   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 290   IN OUT EFI_HANDLE                *ChildHandle
 291   )
 292 {
 293   EFI_STATUS          Status;
 294   UDP6_SERVICE_DATA   *Udp6Service;
 295   UDP6_INSTANCE_DATA  *Instance;
 296   EFI_TPL             OldTpl;
 297   VOID                *Ip6;
 298
 299   if ((This == NULL) || (ChildHandle == NULL)) {
 300     return EFI_INVALID_PARAMETER;
 301   }
 302
 303   Udp6Service = UDP6_SERVICE_DATA_FROM_THIS (This);
 304
 305   //
 306   // Allocate the instance private data structure.
 307   //
 308   Instance = AllocateZeroPool (sizeof (UDP6_INSTANCE_DATA));
 309   if (Instance == NULL) {
 310     return EFI_OUT_OF_RESOURCES;
 311   }
 312
 313   Udp6InitInstance (Udp6Service, Instance);
 314
 315   //
 316   // Add an IpInfo for this instance.
 317   //
 318   Instance->IpInfo = IpIoAddIp (Udp6Service->IpIo);
 319   if (Instance->IpInfo == NULL) {
 320     Status = EFI_OUT_OF_RESOURCES;
 321     goto ON_ERROR;
 322   }
 323
 324   //
 325   // Install the Udp6Protocol for this instance.
 326   //
 327   Status = gBS->InstallMultipleProtocolInterfaces (
 328                   ChildHandle,
 329                   &gEfiUdp6ProtocolGuid,
 330                   &Instance->Udp6Proto,
 331                   NULL
 332                   );
 333   if (EFI_ERROR (Status)) {
 334     goto ON_ERROR;
 335   }
 336
 337   Instance->ChildHandle = *ChildHandle;
 338
 339   //
 340   // Open the default Ip6 protocol in the IP_IO BY_CHILD.
 341   //
 342   Status = gBS->OpenProtocol (
 343                   Udp6Service->IpIo->ChildHandle,
 344                   &gEfiIp6ProtocolGuid,
 345                   (VOID **) &Ip6,
 346                   gUdp6DriverBinding.DriverBindingHandle,
 347                   Instance->ChildHandle,
 348                   EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
 349                   );
 350   if (EFI_ERROR (Status)) {
 351     goto ON_ERROR;
 352   }
 353
 354   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 355
 356   //
 357   // Link this instance into the service context data and increase the ChildrenNumber.
 358   //
 359   InsertTailList (&Udp6Service->ChildrenList, &Instance->Link);
 360   Udp6Service->ChildrenNumber++;
 361
 362   gBS->RestoreTPL (OldTpl);
 363
 364   return EFI_SUCCESS;
 365
 366 ON_ERROR:
 367
 368   if (Instance->ChildHandle != NULL) {
 369     gBS->UninstallMultipleProtocolInterfaces (
 370            Instance->ChildHandle,
 371            &gEfiUdp6ProtocolGuid,
 372            &Instance->Udp6Proto,
 373            NULL
 374            );
 375   }
 376
 377   if (Instance->IpInfo != NULL) {
 378     IpIoRemoveIp (Udp6Service->IpIo, Instance->IpInfo);
 379   }
 380
 381   Udp6CleanInstance (Instance);
 382
 383   FreePool (Instance);
 384
 385   return Status;
 386 }
 387
 388 /**
 389   Destroys a child handle with a set of I/O services.
 390   The DestroyChild() function does the opposite of CreateChild(). It removes a protocol
 391   that was installed by CreateChild() from ChildHandle. If the removed protocol is the
 392   last protocol on ChildHandle, then ChildHandle is destroyed.
 393
 394   @param[in]  This               Protocol instance pointer.
 395   @param[in]  ChildHandle        Handle of the child to destroy.
 396
 397   @retval EFI_SUCCES             The I/O services were removed from the child
 398                                  handle.
 399   @retval EFI_UNSUPPORTED        The child handle does not support the I/O services
 400                                  that are being removed.
 401   @retval EFI_INVALID_PARAMETER  Child handle is NULL.
 402   @retval EFI_ACCESS_DENIED      The child handle could not be destroyed because
 403                                  its  I/O services are being used.
 404   @retval other                  The child handle was not destroyed.
 405
 406 **/
 407 EFI_STATUS
 408 EFIAPI
 409 Udp6ServiceBindingDestroyChild (
 410   IN EFI_SERVICE_BINDING_PROTOCOL  *This,
 411   IN EFI_HANDLE                    ChildHandle
 412   )
 413 {
 414   EFI_STATUS          Status;
 415   UDP6_SERVICE_DATA   *Udp6Service;
 416   EFI_UDP6_PROTOCOL   *Udp6Proto;
 417   UDP6_INSTANCE_DATA  *Instance;
 418   EFI_TPL             OldTpl;
 419
 420   if ((This == NULL) || (ChildHandle == NULL)) {
 421     return EFI_INVALID_PARAMETER;
 422   }
 423
 424   Udp6Service = UDP6_SERVICE_DATA_FROM_THIS (This);
 425
 426   //
 427   // Try to get the Udp6 protocol from the ChildHandle.
 428   //
 429   Status = gBS->OpenProtocol (
 430                   ChildHandle,
 431                   &gEfiUdp6ProtocolGuid,
 432                   (VOID **) &Udp6Proto,
 433                   gUdp6DriverBinding.DriverBindingHandle,
 434                   ChildHandle,
 435                   EFI_OPEN_PROTOCOL_GET_PROTOCOL
 436                   );
 437   if (EFI_ERROR (Status)) {
 438     return EFI_UNSUPPORTED;
 439   }
 440
 441   Instance = UDP6_INSTANCE_DATA_FROM_THIS (Udp6Proto);
 442
 443   if (Instance->Destroyed) {
 444     return EFI_SUCCESS;
 445   }
 446
 447   //
 448   // Use the Destroyed flag to avoid the re-entering of the following code.
 449   //
 450   Instance->Destroyed = TRUE;
 451
 452   //
 453   // Close the Ip6 protocol.
 454   //
 455   gBS->CloseProtocol (
 456          Udp6Service->IpIo->ChildHandle,
 457          &gEfiIp6ProtocolGuid,
 458          gUdp6DriverBinding.DriverBindingHandle,
 459          Instance->ChildHandle
 460          );
 461
 462   //
 463   // Uninstall the Udp6Protocol previously installed on the ChildHandle.
 464   //
 465   Status = gBS->UninstallMultipleProtocolInterfaces (
 466                   ChildHandle,
 467                   &gEfiUdp6ProtocolGuid,
 468                   (VOID *) &Instance->Udp6Proto,
 469                   NULL
 470                   );
 471   if (EFI_ERROR (Status)) {
 472     Instance->Destroyed = FALSE;
 473     return Status;
 474   }
 475
 476   //
 477   // Reset the configuration in case the instance's consumer forgets to do this.
 478   //
 479   Udp6Proto->Configure (Udp6Proto, NULL);
 480
 481   //
 482   // Remove the IpInfo this instance consumes.
 483   //
 484   IpIoRemoveIp (Udp6Service->IpIo, Instance->IpInfo);
 485
 486   OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 487
 488   //
 489   // Remove this instance from the service context data's ChildrenList.
 490   //
 491   RemoveEntryList (&Instance->Link);
 492   Udp6Service->ChildrenNumber--;
 493
 494   //
 495   // Clean the instance.
 496   //
 497   Udp6CleanInstance (Instance);
 498
 499   gBS->RestoreTPL (OldTpl);
 500
 501   FreePool (Instance);
 502
 503   return EFI_SUCCESS;
 504 }
 505
 506 /**
 507   This is the declaration of an EFI image entry point. This entry point is
 508   the same for UEFI Applications, UEFI OS Loaders, and UEFI Drivers, including
 509   both device drivers and bus drivers.
 510
 511   The entry point for Udp6 driver that installs the driver binding
 512   and component name protocol on its ImageHandle.
 513
 514   @param[in] ImageHandle        The firmware allocated handle for the UEFI image.
 515   @param[in] SystemTable        A pointer to the EFI System Table.
 516
 517   @retval EFI_SUCCESS           The operation completed successfully.
 518   @retval EFI_OUT_OF_RESOURCES  The request could not be completed due to a lack of resources.
 519
 520 **/
 521 EFI_STATUS
 522 EFIAPI
 523 Udp6DriverEntryPoint (
 524   IN EFI_HANDLE        ImageHandle,
 525   IN EFI_SYSTEM_TABLE  *SystemTable
 526   )
 527 {
 528   EFI_STATUS  Status;
 529
 530   //
 531   // Install the Udp6DriverBinding and Udp6ComponentName protocols.
 532   //
 533
 534   Status = EfiLibInstallDriverBindingComponentName2 (
 535              ImageHandle,
 536              SystemTable,
 537              &gUdp6DriverBinding,
 538              ImageHandle,
 539              &gUdp6ComponentName,
 540              &gUdp6ComponentName2
 541              );
 542   if (!EFI_ERROR (Status)) {
 543     //
 544     // Initialize the UDP random port.
 545     //
 546     mUdp6RandomPort = (UINT16)(
 547                         ((UINT16) NetRandomInitSeed ()) %
 548                          UDP6_PORT_KNOWN +
 549                          UDP6_PORT_KNOWN
 550                          );
 551   }
 552
 553   return Status;
 554 }
 555
 556