I2cHost.c

Go to the documentation of this file.

 
#include "I2cDxe.h"
 
EFI_DRIVER_BINDING_PROTOCOL  gI2cHostDriverBinding = {
  I2cHostDriverSupported,
  I2cHostDriverStart,
  I2cHostDriverStop,
  0x10,
  NULL,
  NULL
};
 
//
// Driver name table
//
GLOBAL_REMOVE_IF_UNREFERENCED EFI_UNICODE_STRING_TABLE  mI2cHostDriverNameTable[] = {
  { "eng;en", L"I2c Host Driver" },
  { NULL,     NULL               }
};
 
//
// EFI Component Name Protocol
//
GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME_PROTOCOL  gI2cHostComponentName = {
  (EFI_COMPONENT_NAME_GET_DRIVER_NAME)I2cHostComponentNameGetDriverName,
  (EFI_COMPONENT_NAME_GET_CONTROLLER_NAME)I2cHostComponentNameGetControllerName,
  "eng"
};
 
//
// EFI Component Name 2 Protocol
//
GLOBAL_REMOVE_IF_UNREFERENCED EFI_COMPONENT_NAME2_PROTOCOL  gI2cHostComponentName2 = {
  I2cHostComponentNameGetDriverName,
  I2cHostComponentNameGetControllerName,
  "en"
};
 
EFI_STATUS
EFIAPI
I2cHostComponentNameGetDriverName (
  IN  EFI_COMPONENT_NAME2_PROTOCOL  *This,
  IN  CHAR8                         *Language,
  OUT CHAR16                        **DriverName
  )
{
  return LookupUnicodeString2 (
           Language,
           This->SupportedLanguages,
           mI2cHostDriverNameTable,
           DriverName,
           (BOOLEAN)(This != &gI2cHostComponentName2)
           );
}
 
EFI_STATUS
EFIAPI
I2cHostComponentNameGetControllerName (
  IN  EFI_COMPONENT_NAME2_PROTOCOL  *This,
  IN  EFI_HANDLE                    ControllerHandle,
  IN  EFI_HANDLE                    ChildHandle        OPTIONAL,
  IN  CHAR8                         *Language,
  OUT CHAR16                        **ControllerName
  )
{
  return EFI_UNSUPPORTED;
}
 
EFI_STATUS
EFIAPI
I2cHostDriverSupported (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  EFI_I2C_MASTER_PROTOCOL                        *I2cMaster;
  EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL  *I2cBusConfigurationManagement;
  EFI_STATUS                                     Status;
 
  //
  //  Locate I2C Bus Configuration Management Protocol
  //
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiI2cBusConfigurationManagementProtocolGuid,
                  (VOID **)&I2cBusConfigurationManagement,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  //
  // Close the protocol because we don't use it here
  //
  gBS->CloseProtocol (
         Controller,
         &gEfiI2cBusConfigurationManagementProtocolGuid,
         This->DriverBindingHandle,
         Controller
         );
 
  //
  //  Locate I2C Master Protocol
  //
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiI2cMasterProtocolGuid,
                  (VOID **)&I2cMaster,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
I2cHostDriverStart (
  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN EFI_HANDLE                   Controller,
  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
  )
{
  EFI_STATUS                                     Status;
  EFI_I2C_MASTER_PROTOCOL                        *I2cMaster;
  EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL  *I2cBusConfigurationManagement;
  I2C_HOST_CONTEXT                               *I2cHostContext;
 
  I2cMaster                     = NULL;
  I2cHostContext                = NULL;
  I2cBusConfigurationManagement = NULL;
 
  //
  // Locate I2C Bus Configuration Management Protocol
  //
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiI2cBusConfigurationManagementProtocolGuid,
                  (VOID **)&I2cBusConfigurationManagement,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_BY_DRIVER
                  );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "I2cHost: Open I2C bus configuration error, Status = %r\n", Status));
    return Status;
  }
 
  //
  // Locate I2C Master Protocol
  //
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiI2cMasterProtocolGuid,
                  (VOID **)&I2cMaster,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "I2cHost: Open I2C master error, Status = %r\n", Status));
    goto Exit;
  }
 
  //
  // Allocate the I2C Host Context structure
  //
  I2cHostContext = AllocateZeroPool (sizeof (I2C_HOST_CONTEXT));
  if (I2cHostContext == NULL) {
    DEBUG ((DEBUG_ERROR, "I2cHost: there is no enough memory to allocate.\n"));
    Status = EFI_OUT_OF_RESOURCES;
    goto Exit;
  }
 
  //
  // Initialize the context structure for the current I2C Controller
  //
  I2cHostContext->Signature                     = I2C_HOST_SIGNATURE;
  I2cHostContext->I2cMaster                     = I2cMaster;
  I2cHostContext->I2cBusConfigurationManagement = I2cBusConfigurationManagement;
  I2cHostContext->I2cBusConfiguration           = (UINTN)-1;
  InitializeListHead (&I2cHostContext->RequestList);
 
  //
  // Reset the controller
  //
  Status = I2cMaster->Reset (I2cMaster);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "I2cHost: I2C controller reset failed!\n"));
    goto Exit;
  }
 
  //
  // Create the I2C transaction complete event
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_I2C_SYNC,
                  I2cHostRequestCompleteEvent,
                  I2cHostContext,
                  &I2cHostContext->I2cEvent
                  );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "I2cHost: create complete event error, Status = %r\n", Status));
    goto Exit;
  }
 
  //
  // Get the bus management event
  //
  Status = gBS->CreateEvent (
                  EVT_NOTIFY_SIGNAL,
                  TPL_I2C_SYNC,
                  I2cHostI2cBusConfigurationAvailable,
                  I2cHostContext,
                  &I2cHostContext->I2cBusConfigurationEvent
                  );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "I2cHost: create bus available event error, Status = %r\n", Status));
    goto Exit;
  }
 
  //
  // Build the I2C host protocol for the current I2C controller
  //
  I2cHostContext->I2cHost.QueueRequest              = I2cHostQueueRequest;
  I2cHostContext->I2cHost.I2cControllerCapabilities = I2cMaster->I2cControllerCapabilities;
 
  //
  //  Install the driver protocol
  //
  Status = gBS->InstallMultipleProtocolInterfaces (
                  &Controller,
                  &gEfiI2cHostProtocolGuid,
                  &I2cHostContext->I2cHost,
                  NULL
                  );
Exit:
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "I2cHost: Start() function failed, Status = %r\n", Status));
    if (I2cBusConfigurationManagement != NULL) {
      gBS->CloseProtocol (
             Controller,
             &gEfiI2cBusConfigurationManagementProtocolGuid,
             This->DriverBindingHandle,
             Controller
             );
    }
 
    if ((I2cHostContext != NULL) && (I2cHostContext->I2cEvent != NULL)) {
      gBS->CloseEvent (I2cHostContext->I2cEvent);
      I2cHostContext->I2cEvent = NULL;
    }
 
    if ((I2cHostContext != NULL) && (I2cHostContext->I2cBusConfigurationEvent != NULL)) {
      gBS->CloseEvent (I2cHostContext->I2cBusConfigurationEvent);
      I2cHostContext->I2cBusConfigurationEvent = NULL;
    }
 
    //
    //  Release the context structure upon failure
    //
    if (I2cHostContext != NULL) {
      FreePool (I2cHostContext);
    }
  }
 
  //
  //  Return the operation status.
  //
  return Status;
}
 
EFI_STATUS
EFIAPI
I2cHostDriverStop (
  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
  IN  EFI_HANDLE                   Controller,
  IN  UINTN                        NumberOfChildren,
  IN  EFI_HANDLE                   *ChildHandleBuffer
  )
{
  EFI_STATUS             Status;
  I2C_HOST_CONTEXT       *I2cHostContext;
  EFI_I2C_HOST_PROTOCOL  *I2cHost;
  EFI_TPL                TplPrevious;
 
  TplPrevious = EfiGetCurrentTpl ();
  if (TplPrevious > TPL_I2C_SYNC) {
    DEBUG ((DEBUG_ERROR, "I2cHost: TPL %d is too high in Stop.\n", TplPrevious));
    return EFI_DEVICE_ERROR;
  }
 
  Status = gBS->OpenProtocol (
                  Controller,
                  &gEfiI2cHostProtocolGuid,
                  (VOID **)&I2cHost,
                  This->DriverBindingHandle,
                  Controller,
                  EFI_OPEN_PROTOCOL_GET_PROTOCOL
                  );
 
  if (EFI_ERROR (Status)) {
    return EFI_DEVICE_ERROR;
  }
 
  I2cHostContext = I2C_HOST_CONTEXT_FROM_PROTOCOL (I2cHost);
 
  //
  // Raise TPL for critical section
  //
  TplPrevious = gBS->RaiseTPL (TPL_I2C_SYNC);
 
  //
  // If there is pending request or pending bus configuration, do not stop
  //
  Status = EFI_DEVICE_ERROR;
  if (  (!I2cHostContext->I2cBusConfigurationManagementPending)
     && IsListEmpty (&I2cHostContext->RequestList))
  {
    //
    //  Remove the I2C host protocol
    //
    Status = gBS->UninstallMultipleProtocolInterfaces (
                    Controller,
                    &gEfiI2cHostProtocolGuid,
                    I2cHost,
                    NULL
                    );
  }
 
  //
  // Leave critical section
  //
  gBS->RestoreTPL (TplPrevious);
  if (!EFI_ERROR (Status)) {
    gBS->CloseProtocol (
           Controller,
           &gEfiI2cBusConfigurationManagementProtocolGuid,
           This->DriverBindingHandle,
           Controller
           );
 
    //
    // Release I2c Host resources
    //
    if (I2cHostContext->I2cBusConfigurationEvent != NULL) {
      gBS->CloseEvent (I2cHostContext->I2cBusConfigurationEvent);
      I2cHostContext->I2cBusConfigurationEvent = NULL;
    }
 
    if (I2cHostContext->I2cEvent != NULL) {
      gBS->CloseEvent (I2cHostContext->I2cEvent);
      I2cHostContext->I2cEvent = NULL;
    }
 
    FreePool (I2cHostContext);
  }
 
  //
  //  Return the stop status
  //
  return Status;
}
 
VOID
EFIAPI
I2cHostI2cBusConfigurationAvailable (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  I2C_HOST_CONTEXT         *I2cHostContext;
  EFI_I2C_MASTER_PROTOCOL  *I2cMaster;
  I2C_REQUEST              *I2cRequest;
  LIST_ENTRY               *EntryHeader;
  LIST_ENTRY               *Entry;
  EFI_STATUS               Status;
 
  //
  // Mark this I2C bus configuration management operation as complete
  //
  I2cHostContext = (I2C_HOST_CONTEXT *)Context;
  I2cMaster      = I2cHostContext->I2cMaster;
  ASSERT (I2cMaster != NULL);
  //
  // Clear flag to indicate I2C bus configuration is finished
  //
  I2cHostContext->I2cBusConfigurationManagementPending = FALSE;
 
  //
  //  Validate the completion status
  //
  if (EFI_ERROR (I2cHostContext->Status)) {
    //
    // Setting I2C bus configuration failed before
    //
    I2cHostRequestComplete (I2cHostContext, I2cHostContext->Status);
 
    //
    // Unknown I2C bus configuration
    // Force next operation to enable the I2C bus configuration
    //
    I2cHostContext->I2cBusConfiguration = (UINTN)-1;
 
    //
    // Do not continue current I2C request
    //
    return;
  }
 
  //
  // Get the first request in the link with FIFO order
  //
  EntryHeader = &I2cHostContext->RequestList;
  Entry       = GetFirstNode (EntryHeader);
  I2cRequest  = I2C_REQUEST_FROM_ENTRY (Entry);
 
  //
  // Update the I2C bus configuration of the current I2C request
  //
  I2cHostContext->I2cBusConfiguration = I2cRequest->I2cBusConfiguration;
 
  //
  // Start an I2C operation on the host, the status is returned by I2cHostContext->Status
  //
  Status = I2cMaster->StartRequest (
                        I2cMaster,
                        I2cRequest->SlaveAddress,
                        I2cRequest->RequestPacket,
                        I2cHostContext->I2cEvent,
                        &I2cHostContext->Status
                        );
 
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "I2cHostI2cBusConfigurationAvailable: Error starting I2C operation, %r\n", Status));
  }
}
 
EFI_STATUS
I2cHostRequestComplete (
  I2C_HOST_CONTEXT  *I2cHostContext,
  EFI_STATUS        Status
  )
{
  I2C_REQUEST  *I2cRequest;
  LIST_ENTRY   *EntryHeader;
  LIST_ENTRY   *Entry;
 
  //
  // Remove the current I2C request from the list
  //
  EntryHeader = &I2cHostContext->RequestList;
  Entry       = GetFirstNode (EntryHeader);
  I2cRequest  = I2C_REQUEST_FROM_ENTRY (Entry);
 
  //
  // Save the status for QueueRequest
  //
  if ( NULL != I2cRequest->Status ) {
    *I2cRequest->Status = Status;
  }
 
  //
  //  Notify the user of the I2C request completion
  //
  if ( NULL != I2cRequest->Event ) {
    gBS->SignalEvent (I2cRequest->Event);
  }
 
  //
  // Done with this request, remove the current request from list
  //
  RemoveEntryList (&I2cRequest->Link);
  FreePool (I2cRequest->RequestPacket);
  FreePool (I2cRequest);
 
  //
  // If there is more I2C request, start next one
  //
  if (!IsListEmpty (EntryHeader)) {
    I2cHostRequestEnable (I2cHostContext);
  }
 
  return Status;
}
 
VOID
EFIAPI
I2cHostRequestCompleteEvent (
  IN EFI_EVENT  Event,
  IN VOID       *Context
  )
{
  I2C_HOST_CONTEXT  *I2cHostContext;
 
  //
  // Handle the completion event
  //
  I2cHostContext = (I2C_HOST_CONTEXT *)Context;
  I2cHostRequestComplete (I2cHostContext, I2cHostContext->Status);
}
 
EFI_STATUS
I2cHostRequestEnable (
  I2C_HOST_CONTEXT  *I2cHostContext
  )
{
  UINTN                                                I2cBusConfiguration;
  CONST EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL  *I2cBusConfigurationManagement;
  I2C_REQUEST                                          *I2cRequest;
  EFI_STATUS                                           Status;
  EFI_TPL                                              TplPrevious;
  LIST_ENTRY                                           *EntryHeader;
  LIST_ENTRY                                           *Entry;
 
  //
  //  Assume pending request
  //
  Status = EFI_NOT_READY;
 
  I2cBusConfigurationManagement = I2cHostContext->I2cBusConfigurationManagement;
 
  //
  //  Validate the I2c bus configuration
  //
  EntryHeader = &I2cHostContext->RequestList;
  Entry       = GetFirstNode (EntryHeader);
  I2cRequest  = I2C_REQUEST_FROM_ENTRY (Entry);
 
  I2cBusConfiguration = I2cRequest->I2cBusConfiguration;
 
  if (I2cHostContext->I2cBusConfiguration != I2cBusConfiguration ) {
    //
    // Set flag to indicate I2C bus configuration is in progress
    //
    I2cHostContext->I2cBusConfigurationManagementPending = TRUE;
    //
    //  Update bus configuration for this device's requesting bus configuration
    //
    Status = I2cBusConfigurationManagement->EnableI2cBusConfiguration (
                                              I2cBusConfigurationManagement,
                                              I2cBusConfiguration,
                                              I2cHostContext->I2cBusConfigurationEvent,
                                              &I2cHostContext->Status
                                              );
  } else {
    //
    //  I2C bus configuration is same, no need change configuration and start I2c transaction directly
    //
    TplPrevious = gBS->RaiseTPL (TPL_I2C_SYNC);
 
    //
    //  Same I2C bus configuration
    //
    I2cHostContext->Status = EFI_SUCCESS;
    I2cHostI2cBusConfigurationAvailable (I2cHostContext->I2cBusConfigurationEvent, I2cHostContext);
 
    //
    //  Release the thread synchronization
    //
    gBS->RestoreTPL (TplPrevious);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
I2cHostQueueRequest (
  IN CONST EFI_I2C_HOST_PROTOCOL  *This,
  IN UINTN                        I2cBusConfiguration,
  IN UINTN                        SlaveAddress,
  IN EFI_EVENT                    Event            OPTIONAL,
  IN EFI_I2C_REQUEST_PACKET       *RequestPacket,
  OUT EFI_STATUS                  *I2cStatus       OPTIONAL
  )
{
  EFI_STATUS        Status;
  EFI_EVENT         SyncEvent;
  EFI_TPL           TplPrevious;
  I2C_REQUEST       *I2cRequest;
  I2C_HOST_CONTEXT  *I2cHostContext;
  BOOLEAN           FirstRequest;
  UINTN             RequestPacketSize;
  UINTN             StartBit;
 
  SyncEvent    = NULL;
  FirstRequest = FALSE;
  Status       = EFI_SUCCESS;
 
  if (RequestPacket == NULL) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((SlaveAddress & I2C_ADDRESSING_10_BIT) != 0) {
    //
    // 10-bit address, bits 0-9 are used for 10-bit I2C slave addresses,
    // bits 10-30 are reserved bits and must be zero
    //
    StartBit = 10;
  } else {
    //
    // 7-bit address, Bits 0-6 are used for 7-bit I2C slave addresses,
    // bits 7-30 are reserved bits and must be zero
    //
    StartBit = 7;
  }
 
  if (BitFieldRead32 ((UINT32)SlaveAddress, StartBit, 30) != 0) {
    //
    // Reserved bit set in the SlaveAddress parameter
    //
    return EFI_NOT_FOUND;
  }
 
  I2cHostContext = I2C_HOST_CONTEXT_FROM_PROTOCOL (This);
 
  if (Event == NULL) {
    //
    // For synchronous transaction, register an event used to wait for finishing synchronous transaction
    //
    Status = gBS->CreateEvent (
                    0,
                    TPL_I2C_SYNC,
                    NULL,
                    NULL,
                    &SyncEvent
                    );
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  //
  // TPL should be at or below TPL_NOTIFY.
  // For synchronous requests this routine must be called at or below TPL_CALLBACK.
  //
  TplPrevious = EfiGetCurrentTpl ();
  if ((TplPrevious > TPL_I2C_SYNC) || ((Event == NULL) && (TplPrevious > TPL_CALLBACK))) {
    DEBUG ((DEBUG_ERROR, "ERROR - TPL %d is too high!\n", TplPrevious));
    return EFI_INVALID_PARAMETER;
  }
 
  //
  // Allocate the request structure
  //
  I2cRequest = AllocateZeroPool (sizeof (I2C_REQUEST));
  if (I2cRequest == NULL) {
    DEBUG ((DEBUG_ERROR, "WARNING - Failed to allocate I2C_REQUEST!\n"));
    return EFI_OUT_OF_RESOURCES;
  }
 
  //
  // Initialize the request
  //
  I2cRequest->Signature           = I2C_REQUEST_SIGNATURE;
  I2cRequest->I2cBusConfiguration = I2cBusConfiguration;
  I2cRequest->SlaveAddress        = SlaveAddress;
  I2cRequest->Event               = (Event == NULL) ? SyncEvent : Event;
  I2cRequest->Status              = I2cStatus;
 
  //
  // Copy request packet into private buffer, as RequestPacket may be freed during asynchronous transaction
  //
  RequestPacketSize         = sizeof (UINTN) + RequestPacket->OperationCount * sizeof (EFI_I2C_OPERATION);
  I2cRequest->RequestPacket = AllocateZeroPool (RequestPacketSize);
  ASSERT (I2cRequest->RequestPacket != NULL);
  CopyMem (I2cRequest->RequestPacket, RequestPacket, RequestPacketSize);
 
  //
  // Synchronize with the other threads
  //
  gBS->RaiseTPL (TPL_I2C_SYNC);
 
  FirstRequest = IsListEmpty (&I2cHostContext->RequestList);
 
  //
  // Insert new I2C request in the list
  //
  InsertTailList (&I2cHostContext->RequestList, &I2cRequest->Link);
 
  //
  // Release the thread synchronization
  //
  gBS->RestoreTPL (TplPrevious);
 
  if (FirstRequest) {
    //
    // Start the first I2C request, then the subsequent of I2C request will continue
    //
    Status = I2cHostRequestEnable (I2cHostContext);
  }
 
  if (Event != NULL) {
    //
    // For asynchronous, return EFI_SUCCESS indicating that the asynchronously I2C transaction was queued.
    // No real I2C operation status in I2cStatus
    //
    return EFI_SUCCESS;
  }
 
  //
  // For synchronous transaction, wait for the operation completion
  //
  do {
    Status = gBS->CheckEvent (SyncEvent);
  } while (Status == EFI_NOT_READY);
 
  //
  // Get the I2C operation status
  //
  Status = I2cHostContext->Status;
 
  //
  // Return the I2C operation status
  //
  if (I2cStatus != NULL) {
    *I2cStatus = Status;
  }
 
  //
  // Close the event if necessary
  //
  if (SyncEvent != NULL) {
    gBS->CloseEvent (SyncEvent);
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
InitializeI2cHost (
  IN EFI_HANDLE        ImageHandle,
  IN EFI_SYSTEM_TABLE  *SystemTable
  )
{
  EFI_STATUS  Status;
 
  //
  // Install driver model protocol(s).
  //
  Status = EfiLibInstallDriverBindingComponentName2 (
             ImageHandle,
             SystemTable,
             &gI2cHostDriverBinding,
             ImageHandle,
             &gI2cHostComponentName,
             &gI2cHostComponentName2
             );
  ASSERT_EFI_ERROR (Status);
  return Status;
}
 
EFI_STATUS
EFIAPI
I2cHostUnload (
  IN EFI_HANDLE  ImageHandle
  )
{
  EFI_STATUS                    Status;
  EFI_HANDLE                    *DeviceHandleBuffer;
  UINTN                         DeviceHandleCount;
  UINTN                         Index;
  EFI_COMPONENT_NAME_PROTOCOL   *ComponentName;
  EFI_COMPONENT_NAME2_PROTOCOL  *ComponentName2;
 
  //
  // Get the list of all I2C Controller handles in the handle database.
  // If there is an error getting the list, then the unload
  // operation fails.
  //
  Status = gBS->LocateHandleBuffer (
                  ByProtocol,
                  &gEfiI2cHostProtocolGuid,
                  NULL,
                  &DeviceHandleCount,
                  &DeviceHandleBuffer
                  );
 
  if (!EFI_ERROR (Status)) {
    //
    // Disconnect the driver specified by ImageHandle from all
    // the devices in the handle database.
    //
    for (Index = 0; Index < DeviceHandleCount; Index++) {
      Status = gBS->DisconnectController (
                      DeviceHandleBuffer[Index],
                      ImageHandle,
                      NULL
                      );
      if (EFI_ERROR (Status)) {
        goto Done;
      }
    }
  }
 
  //
  // Uninstall all the protocols installed in the driver entry point
  //
  Status = gBS->UninstallMultipleProtocolInterfaces (
                  gI2cHostDriverBinding.DriverBindingHandle,
                  &gEfiDriverBindingProtocolGuid,
                  &gI2cHostDriverBinding,
                  NULL
                  );
  ASSERT_EFI_ERROR (Status);
 
  //
  // Note we have to one by one uninstall the following protocols.
  // It's because some of them are optionally installed based on
  // the following PCD settings.
  //   gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnosticsDisable
  //   gEfiMdePkgTokenSpaceGuid.PcdComponentNameDisable
  //   gEfiMdePkgTokenSpaceGuid.PcdDriverDiagnostics2Disable
  //   gEfiMdePkgTokenSpaceGuid.PcdComponentName2Disable
  //
  Status = gBS->HandleProtocol (
                  gI2cHostDriverBinding.DriverBindingHandle,
                  &gEfiComponentNameProtocolGuid,
                  (VOID **)&ComponentName
                  );
  if (!EFI_ERROR (Status)) {
    gBS->UninstallProtocolInterface (
           gI2cHostDriverBinding.DriverBindingHandle,
           &gEfiComponentNameProtocolGuid,
           ComponentName
           );
  }
 
  Status = gBS->HandleProtocol (
                  gI2cHostDriverBinding.DriverBindingHandle,
                  &gEfiComponentName2ProtocolGuid,
                  (VOID **)&ComponentName2
                  );
  if (!EFI_ERROR (Status)) {
    gBS->UninstallProtocolInterface (
           gI2cHostDriverBinding.DriverBindingHandle,
           &gEfiComponentName2ProtocolGuid,
           ComponentName2
           );
  }
 
  Status = EFI_SUCCESS;
 
Done:
  //
  // Free the buffer containing the list of handles from the handle database
  //
  if (DeviceHandleBuffer != NULL) {
    gBS->FreePool (DeviceHandleBuffer);
  }
 
  return Status;
}