Mtftp6Driver.c

Go to the documentation of this file.

 
#include "Mtftp6Impl.h"
 
EFI_DRIVER_BINDING_PROTOCOL  gMtftp6DriverBinding = {
  Mtftp6DriverBindingSupported,
  Mtftp6DriverBindingStart,
  Mtftp6DriverBindingStop,
  0xa,
  NULL,
  NULL
};
 
EFI_SERVICE_BINDING_PROTOCOL  gMtftp6ServiceBindingTemplate = {
  Mtftp6ServiceBindingCreateChild,
  Mtftp6ServiceBindingDestroyChild
};
 
VOID
Mtftp6DestroyService (
  IN MTFTP6_SERVICE  *Service
  )
{
  //
  // Make sure all children instances have been already destroyed.
  //
  ASSERT (Service->ChildrenNum == 0);
 
  if (Service->DummyUdpIo != NULL) {
    UdpIoFreeIo (Service->DummyUdpIo);
  }
 
  if (Service->Timer != NULL) {
    gBS->CloseEvent (Service->Timer);
  }
 
  FreePool (Service);
}
 
EFI_STATUS
Mtftp6CreateService (
  IN  EFI_HANDLE      Controller,
  IN  EFI_HANDLE      Image,
  OUT MTFTP6_SERVICE  **Service
  )
{
  MTFTP6_SERVICE  *Mtftp6Srv;
  EFI_STATUS      Status;
 
  ASSERT (Service != NULL);
 
  *Service  = NULL;
  Mtftp6Srv = AllocateZeroPool (sizeof (MTFTP6_SERVICE));
 
  if (Mtftp6Srv == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Mtftp6Srv->Signature   = MTFTP6_SERVICE_SIGNATURE;
  Mtftp6Srv->Controller  = Controller;
  Mtftp6Srv->Image       = Image;
  Mtftp6Srv->ChildrenNum = 0;
 
  CopyMem (
    &Mtftp6Srv->ServiceBinding,
    &gMtftp6ServiceBindingTemplate,
    sizeof (EFI_SERVICE_BINDING_PROTOCOL)
    );
 
  InitializeListHead (&Mtftp6Srv->Children);
 
  //
  // Create a internal timer for all instances.
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL | EVT_TIMER,
                  TPL_CALLBACK,
                  Mtftp6OnTimerTick,
                  Mtftp6Srv,
                  &Mtftp6Srv->Timer
                  );
 
  if (EFI_ERROR (Status)) {
    FreePool (Mtftp6Srv);
    return Status;
  }
 
  //
  // Create a dummy Udp6Io to build parent-child relationship between Udp6 driver
  // and Mtftp6 driver.
  //
  Mtftp6Srv->DummyUdpIo = UdpIoCreateIo (
                            Controller,
                            Image,
                            Mtftp6ConfigDummyUdpIo,
                            UDP_IO_UDP6_VERSION,
                            NULL
                            );
 
  if (Mtftp6Srv->DummyUdpIo == NULL) {
    gBS->CloseEvent (Mtftp6Srv->Timer);
    FreePool (Mtftp6Srv);
    return EFI_DEVICE_ERROR;
  }
 
  *Service = Mtftp6Srv;
  return EFI_SUCCESS;
}
 
VOID
Mtftp6DestroyInstance (
  IN MTFTP6_INSTANCE  *Instance
  )
{
  LIST_ENTRY          *Entry;
  LIST_ENTRY          *Next;
  MTFTP6_BLOCK_RANGE  *Block;
 
  if (Instance->Config != NULL) {
    FreePool (Instance->Config);
  }
 
  if ((Instance->Token != NULL) && (Instance->Token->Event != NULL)) {
    gBS->SignalEvent (Instance->Token->Event);
  }
 
  if (Instance->LastPacket != NULL) {
    NetbufFree (Instance->LastPacket);
  }
 
  if (Instance->UdpIo != NULL) {
    UdpIoFreeIo (Instance->UdpIo);
  }
 
  if (Instance->McastUdpIo != NULL) {
    UdpIoFreeIo (Instance->McastUdpIo);
  }
 
  NET_LIST_FOR_EACH_SAFE (Entry, Next, &Instance->BlkList) {
    Block = NET_LIST_USER_STRUCT (Entry, MTFTP6_BLOCK_RANGE, Link);
    RemoveEntryList (Entry);
    FreePool (Block);
  }
 
  FreePool (Instance);
}
 
EFI_STATUS
Mtftp6CreateInstance (
  IN  MTFTP6_SERVICE   *Service,
  OUT MTFTP6_INSTANCE  **Instance
  )
{
  MTFTP6_INSTANCE  *Mtftp6Ins;
 
  *Instance = NULL;
  Mtftp6Ins = AllocateZeroPool (sizeof (MTFTP6_INSTANCE));
 
  if (Mtftp6Ins == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  Mtftp6Ins->Signature = MTFTP6_INSTANCE_SIGNATURE;
  Mtftp6Ins->InDestroy = FALSE;
  Mtftp6Ins->Service   = Service;
 
  CopyMem (
    &Mtftp6Ins->Mtftp6,
    &gMtftp6ProtocolTemplate,
    sizeof (EFI_MTFTP6_PROTOCOL)
    );
 
  InitializeListHead (&Mtftp6Ins->Link);
  InitializeListHead (&Mtftp6Ins->BlkList);
 
  *Instance = Mtftp6Ins;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Mtftp6DestroyChildEntryInHandleBuffer (
  IN LIST_ENTRY  *Entry,
  IN VOID        *Context
  )
{
  MTFTP6_INSTANCE               *Instance;
  EFI_SERVICE_BINDING_PROTOCOL  *ServiceBinding;
  UINTN                         NumberOfChildren;
  EFI_HANDLE                    *ChildHandleBuffer;
 
  if ((Entry == NULL) || (Context == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Instance          = NET_LIST_USER_STRUCT_S (Entry, MTFTP6_INSTANCE, Link, MTFTP6_INSTANCE_SIGNATURE);
  ServiceBinding    = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->ServiceBinding;
  NumberOfChildren  = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->NumberOfChildren;
  ChildHandleBuffer = ((MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT *)Context)->ChildHandleBuffer;
 
  if (!NetIsInHandleBuffer (Instance->Handle, NumberOfChildren, ChildHandleBuffer)) {
    return EFI_SUCCESS;
  }
 
  return ServiceBinding->DestroyChild (ServiceBinding, Instance->Handle);
}
 
EFI_STATUS
EFIAPI
Mtftp6DriverEntryPoint (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  return EfiLibInstallDriverBindingComponentName2 (
           ImageHandle,
           SystemTable,
           &gMtftp6DriverBinding,
           ImageHandle,
           &gMtftp6ComponentName,
           &gMtftp6ComponentName2
           );
}
 
EFI_STATUS
EFIAPI
Mtftp6DriverBindingSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  return gBS->OpenProtocol (
                Controller,
                &gEfiUdp6ServiceBindingProtocolGuid,
                NULL,
                This->DriverBindingHandle,
                Controller,
                EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                );
}
 
EFI_STATUS
EFIAPI
Mtftp6DriverBindingStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  MTFTP6_SERVICE  *Service;
  EFI_STATUS      Status;
 
  //
  // Directly return if driver is already running on this Nic handle.
  //
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiMtftp6ServiceBindingProtocolGuid,
                  NULL,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_TEST_PROTOCOL
                  );
 
  if (!EFI_ERROR (Status)) {
    return EFI_ALREADY_STARTED;
  }
 
  //
  // Create Mtftp6 service for this Nic handle
  //
  Status = Mtftp6CreateService (
             Controller,
             This->DriverBindingHandle,
             &Service
             );
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  ASSERT (Service != NULL);
 
  //
  // Start the internal timer to track the packet retransmission.
  //
  Status = gBS->SetTimer (
                  Service->Timer,
                  TimerPeriodic,
                  TICKS_PER_SECOND
                  );
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  //
  // Install the Mtftp6 service on the Nic handle.
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Controller,
                  &gEfiMtftp6ServiceBindingProtocolGuid,
                  &Service->ServiceBinding,
                  NULL
                  );
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  return EFI_SUCCESS;
 
ON_ERROR:
 
  Mtftp6DestroyService (Service);
  return Status;
}
 
EFI_STATUS
EFIAPI
Mtftp6DriverBindingStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   Controller,
  IN  UINTN                        NumberOfChildren,
  IN  EFI_HANDLE                   *ChildHandleBuffer
  )
{
  EFI_SERVICE_BINDING_PROTOCOL                *ServiceBinding;
  MTFTP6_SERVICE                              *Service;
  EFI_HANDLE                                  NicHandle;
  EFI_STATUS                                  Status;
  LIST_ENTRY                                  *List;
  MTFTP6_DESTROY_CHILD_IN_HANDLE_BUF_CONTEXT  Context;
 
  //
  // Locate the Nic handle to retrieve the Mtftp6 private data.
  //
  NicHandle = NetLibGetNicHandle (Controller, &gEfiUdp6ProtocolGuid);
 
  if (NicHandle == NULL) {
    return EFI_SUCCESS;
  }
 
  Status = gBS->OpenProtocol (
                  NicHandle,
                  &gEfiMtftp6ServiceBindingProtocolGuid,
                  (VOID **)&ServiceBinding,
                  This->DriverBindingHandle,
                  NicHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  Service = MTFTP6_SERVICE_FROM_THIS (ServiceBinding);
 
  if (!IsListEmpty (&Service->Children)) {
    //
    // Destroy the Mtftp6 child instance in ChildHandleBuffer.
    //
    List                      = &Service->Children;
    Context.ServiceBinding    = ServiceBinding;
    Context.NumberOfChildren  = NumberOfChildren;
    Context.ChildHandleBuffer = ChildHandleBuffer;
    Status                    = NetDestroyLinkList (
                                  List,
                                  Mtftp6DestroyChildEntryInHandleBuffer,
                                  &Context,
                                  NULL
                                  );
  }
 
  if ((NumberOfChildren == 0) && IsListEmpty (&Service->Children)) {
    //
    // Destroy the Mtftp6 service if there is no Mtftp6 child instance left.
    //
    gBS->UninstallProtocolInterface (
           NicHandle,
           &gEfiMtftp6ServiceBindingProtocolGuid,
           ServiceBinding
           );
 
    Mtftp6DestroyService (Service);
    Status = EFI_SUCCESS;
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
Mtftp6ServiceBindingCreateChild (
  IN     EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN OUT EFI_HANDLE                    *ChildHandle
  )
{
  MTFTP6_SERVICE   *Service;
  MTFTP6_INSTANCE  *Instance;
  EFI_STATUS       Status;
  EFI_TPL          OldTpl;
  VOID             *Udp6;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  Service = MTFTP6_SERVICE_FROM_THIS (This);
 
  Status = Mtftp6CreateInstance (Service, &Instance);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  ASSERT (Instance != NULL);
 
  //
  // Install the Mtftp6 protocol on the new child handle.
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  ChildHandle,
                  &gEfiMtftp6ProtocolGuid,
                  &Instance->Mtftp6,
                  NULL
                  );
 
  if (EFI_ERROR (Status)) {
    goto ON_ERROR;
  }
 
  Instance->Handle = *ChildHandle;
 
  //
  // Open the Udp6 protocol by child.
  //
  Status = gBS->OpenProtocol (
                  Service->DummyUdpIo->UdpHandle,
                  &gEfiUdp6ProtocolGuid,
                  (VOID **)&Udp6,
                  gMtftp6DriverBinding.DriverBindingHandle,
                  Instance->Handle,
                  EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER
                  );
 
  if (EFI_ERROR (Status)) {
    gBS->UninstallMultipleProtocolInterfaces (
           Instance->Handle,
           &gEfiMtftp6ProtocolGuid,
           &Instance->Mtftp6,
           NULL
           );
 
    goto ON_ERROR;
  }
 
  //
  // Add the new Mtftp6 instance into the children list of Mtftp6 service.
  //
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  InsertTailList (&Service->Children, &Instance->Link);
  Service->ChildrenNum++;
 
  gBS->RestoreTPL (OldTpl);
  return EFI_SUCCESS;
 
ON_ERROR:
 
  Mtftp6DestroyInstance (Instance);
  return Status;
}
 
EFI_STATUS
EFIAPI
Mtftp6ServiceBindingDestroyChild (
  IN EFI_SERVICE_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                    ChildHandle
  )
{
  MTFTP6_SERVICE       *Service;
  MTFTP6_INSTANCE      *Instance;
  EFI_MTFTP6_PROTOCOL  *Mtftp6;
  EFI_STATUS           Status;
  EFI_TPL              OldTpl;
 
  if ((This == NULL) || (ChildHandle == NULL)) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Locate the Nic handle to retrieve the Mtftp6 private data.
  //
  Status = gBS->OpenProtocol (
                  ChildHandle,
                  &gEfiMtftp6ProtocolGuid,
                  (VOID **)&Mtftp6,
                  gMtftp6DriverBinding.DriverBindingHandle,
                  ChildHandle,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  if (EFI_ERROR (Status)) {
    return EFI_UNSUPPORTED;
  }
 
  Instance = MTFTP6_INSTANCE_FROM_THIS (Mtftp6);
  Service  = MTFTP6_SERVICE_FROM_THIS (This);
 
  if (Instance->Service != Service) {
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Check whether the instance already in Destroy state.
  //
  if (Instance->InDestroy) {
    return EFI_SUCCESS;
  }
 
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
 
  Instance->InDestroy = TRUE;
 
  gBS->CloseProtocol (
         Service->DummyUdpIo->UdpHandle,
         &gEfiUdp6ProtocolGuid,
         gMtftp6DriverBinding.DriverBindingHandle,
         ChildHandle
         );
 
  if (Instance->UdpIo != NULL) {
    gBS->CloseProtocol (
           Instance->UdpIo->UdpHandle,
           &gEfiUdp6ProtocolGuid,
           gMtftp6DriverBinding.DriverBindingHandle,
           Instance->Handle
           );
  }
 
  if (Instance->McastUdpIo != NULL) {
    gBS->CloseProtocol (
           Instance->McastUdpIo->UdpHandle,
           &gEfiUdp6ProtocolGuid,
           gMtftp6DriverBinding.DriverBindingHandle,
           Instance->Handle
           );
  }
 
  //
  // Uninstall the MTFTP6 protocol first to enable a top down destruction.
  //
  gBS->RestoreTPL (OldTpl);
  Status = gBS->UninstallProtocolInterface (
                  ChildHandle,
                  &gEfiMtftp6ProtocolGuid,
                  Mtftp6
                  );
  OldTpl = gBS->RaiseTPL (TPL_CALLBACK);
  if (EFI_ERROR (Status)) {
    Instance->InDestroy = FALSE;
    gBS->RestoreTPL (OldTpl);
    return Status;
  }
 
  //
  // Remove the Mtftp6 instance from the children list of Mtftp6 service.
  //
  RemoveEntryList (&Instance->Link);
  Service->ChildrenNum--;
 
  gBS->RestoreTPL (OldTpl);
 
  Mtftp6DestroyInstance (Instance);
 
  return EFI_SUCCESS;
}