[edk2-platforms] [PATCH v2 05/11] Silicon/NXP: Add support for I2c driver

["Meenakshi Aggarwal" <meenakshi.aggarwal@nxp.com>]

I2C driver produces gEfiI2cMasterProtocolGuid which can be
used by other modules.

Signed-off-by: Meenakshi Aggarwal <meenakshi.aggarwal@nxp.com>
---

Notes:
    v2:
    - indentation correction
    - STATIC variable with 'm' prefix

 Silicon/NXP/Drivers/I2cDxe/I2cDxe.inf      |  58 ++
 Silicon/NXP/Drivers/I2cDxe/I2cDxe.h        | 100 +++
 Silicon/NXP/Drivers/I2cDxe/ComponentName.c | 179 +++++
 Silicon/NXP/Drivers/I2cDxe/DriverBinding.c | 235 +++++++
 Silicon/NXP/Drivers/I2cDxe/I2cDxe.c        | 690 ++++++++++++++++++++
 5 files changed, 1262 insertions(+)

diff --git a/Silicon/NXP/Drivers/I2cDxe/I2cDxe.inf b/Silicon/NXP/Drivers/I2cDxe/I2cDxe.inf
new file mode 100644
index 000000000000..0c0bf63bb2e2
--- /dev/null
+++ b/Silicon/NXP/Drivers/I2cDxe/I2cDxe.inf
@@ -0,0 +1,58 @@
+#  @file
+#
+#  Component description file for I2c driver
+#
+#  Copyright (c) 2015, Freescale Semiconductor, Inc. All rights reserved.
+#  Copyright 2017-2019 NXP
+#
+#  SPDX-License-Identifier: BSD-2-Clause-Patent
+#
+#
+
+[Defines]
+  INF_VERSION                    = 0x0001001A
+  BASE_NAME                      = I2cDxe
+  FILE_GUID                      = 5f2927ba-1b04-4d5f-8bef-2b50c635d1e7
+  MODULE_TYPE                    = DXE_DRIVER
+  VERSION_STRING                 = 1.0
+  ENTRY_POINT                    = I2cDxeEntryPoint
+  UNLOAD                         = I2cDxeUnload
+
+[Sources.common]
+  ComponentName.c
+  DriverBinding.c
+  I2cDxe.c
+
+[LibraryClasses]
+  ArmLib
+  BaseMemoryLib
+  DevicePathLib
+  IoLib
+  MemoryAllocationLib
+  PcdLib
+  SocLib
+  TimerLib
+  UefiBootServicesTableLib
+  UefiDriverEntryPoint
+  UefiLib
+
+[Guids]
+  gNxpNonDiscoverableI2cMasterGuid
+
+[Packages]
+  MdeModulePkg/MdeModulePkg.dec
+  MdePkg/MdePkg.dec
+  Silicon/NXP/NxpQoriqLs.dec
+
+[Protocols]
+  gEdkiiNonDiscoverableDeviceProtocolGuid    ## TO_START
+  gEfiI2cMasterProtocolGuid                  ## BY_START
+
+[Pcd]
+  gNxpQoriqLsTokenSpaceGuid.PcdI2cSpeed
+  gNxpQoriqLsTokenSpaceGuid.PcdI2c0BaseAddr
+  gNxpQoriqLsTokenSpaceGuid.PcdI2cSize
+  gNxpQoriqLsTokenSpaceGuid.PcdNumI2cController
+
+[Depex]
+  TRUE
diff --git a/Silicon/NXP/Drivers/I2cDxe/I2cDxe.h b/Silicon/NXP/Drivers/I2cDxe/I2cDxe.h
new file mode 100644
index 000000000000..02a29a5cf2b9
--- /dev/null
+++ b/Silicon/NXP/Drivers/I2cDxe/I2cDxe.h
@@ -0,0 +1,100 @@
+/** I2cDxe.h
+  Header defining the constant, base address amd function for I2C controller
+
+  Copyright 2017-2019 NXP
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#ifndef I2C_DXE_H_
+#define I2C_DXE_H_
+
+#include <Library/UefiLib.h>
+#include <Uefi.h>
+
+#include <Protocol/I2cMaster.h>
+#include <Protocol/NonDiscoverableDevice.h>
+
+#define I2C_CR_IIEN               (1 << 6)
+#define I2C_CR_MSTA               (1 << 5)
+#define I2C_CR_MTX                (1 << 4)
+#define I2C_CR_TX_NO_AK           (1 << 3)
+#define I2C_CR_RSTA               (1 << 2)
+
+#define I2C_SR_ICF                (1 << 7)
+#define I2C_SR_IBB                (1 << 5)
+#define I2C_SR_IAL                (1 << 4)
+#define I2C_SR_IIF                (1 << 1)
+#define I2C_SR_RX_NO_AK           (1 << 0)
+
+#define I2C_CR_IEN                (0 << 7)
+#define I2C_CR_IDIS               (1 << 7)
+#define I2C_SR_IIF_CLEAR          (1 << 1)
+
+#define BUS_IDLE                  (0 | (I2C_SR_IBB << 8))
+#define BUS_BUSY                  (I2C_SR_IBB | (I2C_SR_IBB << 8))
+#define IIF                       (I2C_SR_IIF | (I2C_SR_IIF << 8))
+
+#define I2C_FLAG_WRITE            0x0
+
+#define I2C_STATE_RETRIES         50000
+
+#define RETRY_COUNT               3
+
+#define NXP_I2C_SIGNATURE         SIGNATURE_32 ('N', 'I', '2', 'C')
+#define NXP_I2C_FROM_THIS(a)      CR ((a), NXP_I2C_MASTER, \
+                                    I2cMaster, NXP_I2C_SIGNATURE)
+
+extern EFI_COMPONENT_NAME2_PROTOCOL gNxpI2cDriverComponentName2;
+
+#pragma pack(1)
+typedef struct {
+  VENDOR_DEVICE_PATH              Vendor;
+  UINT64                          MmioBase;
+  EFI_DEVICE_PATH_PROTOCOL        End;
+} NXP_I2C_DEVICE_PATH;
+#pragma pack()
+
+typedef struct {
+  UINT32                          Signature;
+  EFI_I2C_MASTER_PROTOCOL         I2cMaster;
+  NXP_I2C_DEVICE_PATH             DevicePath;
+  NON_DISCOVERABLE_DEVICE         *Dev;
+} NXP_I2C_MASTER;
+
+/**
+  Record defining i2c registers
+**/
+typedef struct {
+  UINT8     I2cAdr;
+  UINT8     I2cFdr;
+  UINT8     I2cCr;
+  UINT8     I2cSr;
+  UINT8     I2cDr;
+} I2C_REGS;
+
+typedef struct {
+  UINT16   SCLDivider;
+  UINT16   BusClockRate;
+} CLK_DIV;
+
+extern
+UINT64
+GetBusFrequency (
+  VOID
+  );
+
+EFI_STATUS
+NxpI2cInit (
+  IN EFI_HANDLE  DriverBindingHandle,
+  IN EFI_HANDLE  ControllerHandle
+  );
+
+EFI_STATUS
+NxpI2cRelease (
+  IN EFI_HANDLE  DriverBindingHandle,
+  IN EFI_HANDLE  ControllerHandle
+  );
+
+#endif //I2C_DXE_H_
diff --git a/Silicon/NXP/Drivers/I2cDxe/ComponentName.c b/Silicon/NXP/Drivers/I2cDxe/ComponentName.c
new file mode 100644
index 000000000000..a71d75c2913a
--- /dev/null
+++ b/Silicon/NXP/Drivers/I2cDxe/ComponentName.c
@@ -0,0 +1,179 @@
+/** @file
+
+  Copyright 2018-2019 NXP
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "I2cDxe.h"
+
+STATIC EFI_UNICODE_STRING_TABLE mNxpI2cDriverNameTable[] = {
+  {
+    "en",
+    (CHAR16 *)L"Nxp I2C Driver"
+  },
+  { }
+};
+
+STATIC EFI_UNICODE_STRING_TABLE mNxpI2cControllerNameTable[] = {
+  {
+    "en",
+    (CHAR16 *)L"Nxp I2C Controller"
+  },
+  { }
+};
+
+/**
+  Retrieves a Unicode string that is the user readable name of the driver.
+
+  This function retrieves the user readable name of a driver in the form of a
+  Unicode string. If the driver specified by This has a user readable name in
+  the language specified by Language, then a pointer to the driver name is
+  returned in DriverName, and EFI_SUCCESS is returned. If the driver specified
+  by This does not support the language specified by Language,
+  then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language. This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified
+                                in RFC 4646 or ISO 639-2 language code format.
+
+  @param  DriverName[out]       A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                driver specified by This in the language
+                                specified by Language.
+
+  @retval EFI_SUCCESS           The Unicode string for the Driver specified by
+                                This and the language specified by Language was
+                                returned in DriverName.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER DriverName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+STATIC
+EFI_STATUS
+EFIAPI
+NxpI2cGetDriverName (
+  IN  EFI_COMPONENT_NAME2_PROTOCOL  *This,
+  IN  CHAR8                         *Language,
+  OUT CHAR16                        **DriverName
+  )
+{
+  return LookupUnicodeString2 (Language,
+                               This->SupportedLanguages,
+                               mNxpI2cDriverNameTable,
+                               DriverName,
+                               FALSE);
+}
+
+/**
+  Retrieves a Unicode string that is the user readable name of the controller
+  that is being managed by a driver.
+
+  This function retrieves the user readable name of the controller specified by
+  ControllerHandle and ChildHandle in the form of a Unicode string. If the
+  driver specified by This has a user readable name in the language specified by
+  Language, then a pointer to the controller name is returned in ControllerName,
+  and EFI_SUCCESS is returned.  If the driver specified by This is not currently
+  managing the controller specified by ControllerHandle and ChildHandle,
+  then EFI_UNSUPPORTED is returned.  If the driver specified by This does not
+  support the language specified by Language, then EFI_UNSUPPORTED is returned.
+
+  @param  This[in]              A pointer to the EFI_COMPONENT_NAME2_PROTOCOL or
+                                EFI_COMPONENT_NAME_PROTOCOL instance.
+
+  @param  ControllerHandle[in]  The handle of a controller that the driver
+                                specified by This is managing.  This handle
+                                specifies the controller whose name is to be
+                                returned.
+
+  @param  ChildHandle[in]       The handle of the child controller to retrieve
+                                the name of.  This is an optional parameter that
+                                may be NULL.  It will be NULL for device
+                                drivers.  It will also be NULL for a bus drivers
+                                that wish to retrieve the name of the bus
+                                controller.  It will not be NULL for a bus
+                                driver that wishes to retrieve the name of a
+                                child controller.
+
+  @param  Language[in]          A pointer to a Null-terminated ASCII string
+                                array indicating the language.  This is the
+                                language of the driver name that the caller is
+                                requesting, and it must match one of the
+                                languages specified in SupportedLanguages. The
+                                number of languages supported by a driver is up
+                                to the driver writer. Language is specified in
+                                RFC 4646 or ISO 639-2 language code format.
+
+  @param  ControllerName[out]   A pointer to the Unicode string to return.
+                                This Unicode string is the name of the
+                                controller specified by ControllerHandle and
+                                ChildHandle in the language specified by
+                                Language from the point of view of the driver
+                                specified by This.
+
+  @retval EFI_SUCCESS           The Unicode string for the user readable name in
+                                the language specified by Language for the
+                                driver specified by This was returned in
+                                DriverName.
+
+  @retval EFI_INVALID_PARAMETER ControllerHandle is NULL.
+
+  @retval EFI_INVALID_PARAMETER ChildHandle is not NULL and it is not a valid
+                                EFI_HANDLE.
+
+  @retval EFI_INVALID_PARAMETER Language is NULL.
+
+  @retval EFI_INVALID_PARAMETER ControllerName is NULL.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This is not currently
+                                managing the controller specified by
+                                ControllerHandle and ChildHandle.
+
+  @retval EFI_UNSUPPORTED       The driver specified by This does not support
+                                the language specified by Language.
+
+**/
+STATIC
+EFI_STATUS
+EFIAPI
+NxpI2cGetControllerName (
+  IN  EFI_COMPONENT_NAME2_PROTOCOL                    *This,
+  IN  EFI_HANDLE                                      ControllerHandle,
+  IN  EFI_HANDLE                                      ChildHandle        OPTIONAL,
+  IN  CHAR8                                           *Language,
+  OUT CHAR16                                          **ControllerName
+  )
+{
+  if (ChildHandle != NULL) {
+    return EFI_UNSUPPORTED;
+  }
+
+  return LookupUnicodeString2 (Language,
+                               This->SupportedLanguages,
+                               mNxpI2cControllerNameTable,
+                               ControllerName,
+                               FALSE);
+}
+
+//
+// EFI Component Name 2 Protocol
+//
+EFI_COMPONENT_NAME2_PROTOCOL gNxpI2cDriverComponentName2 = {
+  NxpI2cGetDriverName,
+  NxpI2cGetControllerName,
+  "en"
+};
diff --git a/Silicon/NXP/Drivers/I2cDxe/DriverBinding.c b/Silicon/NXP/Drivers/I2cDxe/DriverBinding.c
new file mode 100644
index 000000000000..59320447b5fd
--- /dev/null
+++ b/Silicon/NXP/Drivers/I2cDxe/DriverBinding.c
@@ -0,0 +1,235 @@
+/** @file
+
+  Copyright 2018-2019 NXP
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+
+#include <Protocol/DriverBinding.h>
+
+#include "I2cDxe.h"
+
+/**
+  Tests to see if this driver supports a given controller.
+
+  @param  This[in]                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL
+                                   instance.
+  @param  ControllerHandle[in]     The handle of the controller to test.
+  @param  RemainingDevicePath[in]  The remaining device path.
+                                   (Ignored - this is not a bus driver.)
+
+  @retval EFI_SUCCESS              The driver supports this controller.
+  @retval EFI_ALREADY_STARTED      The device specified by ControllerHandle is
+                                   already being managed by the driver specified
+                                   by This.
+  @retval EFI_UNSUPPORTED          The device specified by ControllerHandle is
+                                   not supported by the driver specified by This.
+
+**/
+EFI_STATUS
+EFIAPI
+NxpI2cDriverBindingSupported (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath
+  )
+{
+  NON_DISCOVERABLE_DEVICE    *Dev;
+  EFI_STATUS                 Status;
+
+  //
+  //  Connect to the non-discoverable device
+  //
+  Status = gBS->OpenProtocol (ControllerHandle,
+                              &gEdkiiNonDiscoverableDeviceProtocolGuid,
+                              (VOID **) &Dev,
+                              This->DriverBindingHandle,
+                              ControllerHandle,
+                              EFI_OPEN_PROTOCOL_BY_DRIVER);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  if (CompareGuid (Dev->Type, &gNxpNonDiscoverableI2cMasterGuid)) {
+    Status = EFI_SUCCESS;
+  } else {
+    Status = EFI_UNSUPPORTED;
+  }
+
+  //
+  // Clean up.
+  //
+  gBS->CloseProtocol (ControllerHandle,
+                      &gEdkiiNonDiscoverableDeviceProtocolGuid,
+                      This->DriverBindingHandle,
+                      ControllerHandle);
+
+  return Status;
+}
+
+
+/**
+  Starts a device controller or a bus controller.
+
+  @param[in]  This                 A pointer to the EFI_DRIVER_BINDING_PROTOCOL
+                                   instance.
+  @param[in]  ControllerHandle     The handle of the device to start. This
+                                   handle must support a protocol interface that
+                                   supplies an I/O abstraction to the driver.
+  @param[in]  RemainingDevicePath  The remaining portion of the device path.
+                                   (Ignored - this is not a bus driver.)
+
+  @retval EFI_SUCCESS              The device was started.
+  @retval EFI_DEVICE_ERROR         The device could not be started due to a
+                                   device error.
+  @retval EFI_OUT_OF_RESOURCES     The request could not be completed due to a
+                                   lack of resources.
+
+**/
+EFI_STATUS
+EFIAPI
+NxpI2cDriverBindingStart (
+  IN EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN EFI_HANDLE                   ControllerHandle,
+  IN EFI_DEVICE_PATH_PROTOCOL     *RemainingDevicePath OPTIONAL
+  )
+{
+  return NxpI2cInit (This->DriverBindingHandle, ControllerHandle);
+}
+
+
+/**
+  Stops a device controller or a bus controller.
+
+  @param[in]  This              A pointer to the EFI_DRIVER_BINDING_PROTOCOL
+                                instance.
+  @param[in]  ControllerHandle  A handle to the device being stopped. The handle
+                                must support a bus specific I/O protocol for the
+                                driver to use to stop the device.
+  @param[in]  NumberOfChildren  The number of child device handles in
+                                ChildHandleBuffer.
+  @param[in]  ChildHandleBuffer An array of child handles to be freed. May be
+                                NULL if NumberOfChildren is 0.
+
+  @retval EFI_SUCCESS           The device was stopped.
+  @retval EFI_DEVICE_ERROR      The device could not be stopped due to a device
+                                error.
+
+**/
+EFI_STATUS
+EFIAPI
+NxpI2cDriverBindingStop (
+  IN  EFI_DRIVER_BINDING_PROTOCOL  *This,
+  IN  EFI_HANDLE                  ControllerHandle,
+  IN  UINTN                       NumberOfChildren,
+  IN  EFI_HANDLE                  *ChildHandleBuffer OPTIONAL
+  )
+{
+  return NxpI2cRelease (This->DriverBindingHandle, ControllerHandle);
+}
+
+
+STATIC EFI_DRIVER_BINDING_PROTOCOL  gNxpI2cDriverBinding = {
+  NxpI2cDriverBindingSupported,
+  NxpI2cDriverBindingStart,
+  NxpI2cDriverBindingStop,
+  0xa,
+  NULL,
+  NULL
+};
+
+
+/**
+  The entry point of I2c UEFI Driver.
+
+  @param  ImageHandle                The image handle of the UEFI Driver.
+  @param  SystemTable                A pointer to the EFI System Table.
+
+  @retval  EFI_SUCCESS               The Driver or UEFI Driver exited normally.
+  @retval  EFI_INCOMPATIBLE_VERSION  _gUefiDriverRevision is greater than
+                                     SystemTable->Hdr.Revision.
+
+**/
+EFI_STATUS
+EFIAPI
+I2cDxeEntryPoint (
+  IN  EFI_HANDLE          ImageHandle,
+  IN  EFI_SYSTEM_TABLE    *SystemTable
+  )
+{
+  EFI_STATUS    Status;
+
+  //
+  //  Add the driver to the list of drivers
+  //
+  Status = EfiLibInstallDriverBindingComponentName2 (
+             ImageHandle, SystemTable, &gNxpI2cDriverBinding, ImageHandle,
+             NULL, &gNxpI2cDriverComponentName2);
+  ASSERT_EFI_ERROR (Status);
+
+  return EFI_SUCCESS;
+}
+
+
+/**
+  Unload function for the I2c UEFI Driver.
+
+  @param  ImageHandle[in]        The allocated handle for the EFI image
+
+  @retval EFI_SUCCESS            The driver was unloaded successfully
+  @retval EFI_INVALID_PARAMETER  ImageHandle is not a valid image handle.
+
+**/
+EFI_STATUS
+EFIAPI
+I2cDxeUnload (
+  IN EFI_HANDLE  ImageHandle
+  )
+{
+  EFI_STATUS  Status;
+  EFI_HANDLE  *HandleBuffer;
+  UINTN       HandleCount;
+  UINTN       Index;
+
+  //
+  // Retrieve all USB I/O handles in the handle database
+  //
+  Status = gBS->LocateHandleBuffer (ByProtocol,
+                                    &gEdkiiNonDiscoverableDeviceProtocolGuid,
+                                    NULL,
+                                    &HandleCount,
+                                    &HandleBuffer);
+  if (EFI_ERROR (Status)) {
+    return Status;
+  }
+
+  //
+  // Disconnect the driver from the handles in the handle database
+  //
+  for (Index = 0; Index < HandleCount; Index++) {
+    Status = gBS->DisconnectController (HandleBuffer[Index],
+                                        gImageHandle,
+                                        NULL);
+  }
+
+  //
+  // Free the handle array
+  //
+  gBS->FreePool (HandleBuffer);
+
+  //
+  // Uninstall protocols installed by the driver in its entrypoint
+  //
+  Status = gBS->UninstallMultipleProtocolInterfaces (ImageHandle,
+                  &gEfiDriverBindingProtocolGuid,
+                  &gNxpI2cDriverBinding,
+                  NULL
+                  );
+
+  return EFI_SUCCESS;
+}
diff --git a/Silicon/NXP/Drivers/I2cDxe/I2cDxe.c b/Silicon/NXP/Drivers/I2cDxe/I2cDxe.c
new file mode 100644
index 000000000000..853c426fbca2
--- /dev/null
+++ b/Silicon/NXP/Drivers/I2cDxe/I2cDxe.c
@@ -0,0 +1,690 @@
+/** I2cDxe.c
+  I2c driver APIs for read, write, initialize, set speed and reset
+
+  Copyright 2017-2019 NXP
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include <Library/BaseMemoryLib.h>
+#include <Library/DebugLib.h>
+#include <Library/DevicePathLib.h>
+#include <Library/IoLib.h>
+#include <Library/MemoryAllocationLib.h>
+#include <Library/TimerLib.h>
+#include <Library/UefiBootServicesTableLib.h>
+#include <Library/UefiLib.h>
+
+#include "I2cDxe.h"
+
+STATIC CONST EFI_I2C_CONTROLLER_CAPABILITIES mI2cControllerCapabilities = {
+  0,
+  0,
+  0,
+  0
+};
+
+STATIC CONST CLK_DIV mClkDiv[] = {
+  { 20,  0x00 }, { 22, 0x01 }, { 24, 0x02 }, { 26, 0x03 },
+  { 28,  0x04 }, { 30, 0x05 }, { 32, 0x09 }, { 34, 0x06 },
+  { 36,  0x0A }, { 40, 0x07 }, { 44, 0x0C }, { 48, 0x0D },
+  { 52,  0x43 }, { 56, 0x0E }, { 60, 0x45 }, { 64, 0x12 },
+  { 68,  0x0F }, { 72, 0x13 }, { 80, 0x14 }, { 88, 0x15 },
+  { 96,  0x19 }, { 104, 0x16 }, { 112, 0x1A }, { 128, 0x17 },
+  { 136, 0x4F }, { 144, 0x1C }, { 160, 0x1D }, { 176, 0x55 },
+  { 192, 0x1E }, { 208, 0x56 }, { 224, 0x22 }, { 228, 0x24 },
+  { 240, 0x1F }, { 256, 0x23 }, { 288, 0x5C }, { 320, 0x25 },
+  { 384, 0x26 }, { 448, 0x2A }, { 480, 0x27 }, { 512, 0x2B },
+  { 576, 0x2C }, { 640, 0x2D }, { 768, 0x31 }, { 896, 0x32 },
+  { 960, 0x2F }, { 1024, 0x33 }, { 1152, 0x34 }, { 1280, 0x35 },
+  { 1536, 0x36 }, { 1792, 0x3A }, { 1920, 0x37 }, { 2048, 0x3B },
+  { 2304, 0x3C }, { 2560, 0x3D }, { 3072, 0x3E }, { 3584, 0x7A },
+  { 3840, 0x3F }, { 4096, 0x7B }, { 5120, 0x7D }, { 6144, 0x7E }
+};
+
+/**
+  Calculate and return proper clock divider
+
+  @param  Rate       desired clock rate
+
+  @retval ClkDiv     Index value used to get Bus Clock Rate
+
+**/
+STATIC
+UINT8
+GetClkDivIndex (
+  IN  UINT32         Rate
+  )
+{
+  UINTN              ClkRate;
+  UINT32             Div;
+  UINT8              Index;
+
+  Index = 0;
+  ClkRate = GetBusFrequency ();
+
+  Div = (ClkRate + Rate - 1) / Rate;
+
+  if (Div < mClkDiv[0].SCLDivider) {
+    return 0;
+  }
+
+  do {
+    if (mClkDiv[Index].SCLDivider >= Div ) {
+      return Index;
+    }
+    Index++;
+  } while (Index < ARRAY_SIZE (mClkDiv));
+
+  return (ARRAY_SIZE (mClkDiv) - 1);
+}
+
+/**
+  Function used to check if i2c is in mentioned state or not
+
+  @param   I2cRegs        Pointer to I2C registers
+  @param   State          i2c state need to be checked
+
+  @retval  EFI_NOT_READY  Arbitration was lost
+  @retval  EFI_TIMEOUT    Timeout occured
+  @retval  CurrState      Value of state register
+
+**/
+STATIC
+EFI_STATUS
+WaitForI2cState (
+  IN  I2C_REGS            *I2cRegs,
+  IN  UINT32              State
+  )
+{
+  UINT8                   CurrState;
+  UINT64                  Count;
+
+  for (Count = 0; Count < I2C_STATE_RETRIES; Count++) {
+    MemoryFence ();
+    CurrState = MmioRead8 ((UINTN)&I2cRegs->I2cSr);
+    if (CurrState & I2C_SR_IAL) {
+      MmioWrite8 ((UINTN)&I2cRegs->I2cSr, CurrState | I2C_SR_IAL);
+      return EFI_NOT_READY;
+    }
+
+    if ((CurrState & (State >> 8)) == (UINT8)State) {
+      return CurrState;
+    }
+  }
+
+  return EFI_TIMEOUT;
+}
+
+/**
+  Function to transfer byte on i2c
+
+  @param   I2cRegs        Pointer to i2c registers
+  @param   Byte           Byte to be transferred on i2c bus
+
+  @retval  EFI_NOT_READY  Arbitration was lost
+  @retval  EFI_TIMEOUT    Timeout occured
+  @retval  EFI_NOT_FOUND  ACK was not recieved
+  @retval  EFI_SUCCESS    Data transfer was succesful
+
+**/
+STATIC
+EFI_STATUS
+TransferByte (
+  IN  I2C_REGS            *I2cRegs,
+  IN  UINT8               Byte
+  )
+{
+  EFI_STATUS              RetVal;
+
+  MmioWrite8 ((UINTN)&I2cRegs->I2cSr, I2C_SR_IIF_CLEAR);
+  MmioWrite8 ((UINTN)&I2cRegs->I2cDr, Byte);
+
+  RetVal = WaitForI2cState (I2cRegs, IIF);
+  if ((RetVal == EFI_TIMEOUT) || (RetVal == EFI_NOT_READY)) {
+    return RetVal;
+  }
+
+  if (RetVal & I2C_SR_RX_NO_AK) {
+    return EFI_NOT_FOUND;
+  }
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Function to stop transaction on i2c bus
+
+  @param   I2cRegs          Pointer to i2c registers
+
+  @retval  EFI_NOT_READY    Arbitration was lost
+  @retval  EFI_TIMEOUT      Timeout occured
+  @retval  EFI_SUCCESS      Stop operation was successful
+
+**/
+STATIC
+EFI_STATUS
+I2cStop (
+  IN  I2C_REGS             *I2cRegs
+  )
+{
+  EFI_STATUS               RetVal;
+  UINT32                   Temp;
+
+  Temp = MmioRead8 ((UINTN)&I2cRegs->I2cCr);
+
+  Temp &= ~(I2C_CR_MSTA | I2C_CR_MTX);
+  MmioWrite8 ((UINTN)&I2cRegs->I2cCr, Temp);
+
+  RetVal = WaitForI2cState (I2cRegs, BUS_IDLE);
+
+  if (RetVal < 0) {
+    return RetVal;
+  } else {
+    return EFI_SUCCESS;
+  }
+}
+
+/**
+  Function to send start signal, Chip Address and
+  memory offset
+
+  @param   I2cRegs         Pointer to i2c base registers
+  @param   Chip            Chip Address
+  @param   Offset          Slave memory's offset
+  @param   AddressLength   length of chip address
+
+  @retval  EFI_NOT_READY   Arbitration lost
+  @retval  EFI_TIMEOUT     Failed to initialize data transfer in predefined time
+  @retval  EFI_NOT_FOUND   ACK was not recieved
+  @retval  EFI_SUCCESS     Read was successful
+
+**/
+STATIC
+EFI_STATUS
+InitTransfer (
+  IN  I2C_REGS             *I2cRegs,
+  IN  UINT8                Chip,
+  IN  UINT32               Offset,
+  IN  INT32                AddressLength
+  )
+{
+  UINT32                   Temp;
+  EFI_STATUS               RetVal;
+
+  // Enable I2C controller
+  if (MmioRead8 ((UINTN)&I2cRegs->I2cCr) & I2C_CR_IDIS) {
+    MmioWrite8 ((UINTN)&I2cRegs->I2cCr, I2C_CR_IEN);
+  }
+
+  if (MmioRead8 ((UINTN)&I2cRegs->I2cAdr) == (Chip << 1)) {
+    MmioWrite8 ((UINTN)&I2cRegs->I2cAdr, (Chip << 1) ^ 2);
+  }
+
+  MmioWrite8 ((UINTN)&I2cRegs->I2cSr, I2C_SR_IIF_CLEAR);
+  RetVal = WaitForI2cState (I2cRegs, BUS_IDLE);
+  if ((RetVal == EFI_TIMEOUT) || (RetVal == EFI_NOT_READY)) {
+    return RetVal;
+  }
+
+  // Start I2C transaction
+  Temp = MmioRead8 ((UINTN)&I2cRegs->I2cCr);
+  // set to master mode
+  Temp |= I2C_CR_MSTA;
+  MmioWrite8 ((UINTN)&I2cRegs->I2cCr, Temp);
+
+  RetVal = WaitForI2cState (I2cRegs, BUS_BUSY);
+  if ((RetVal == EFI_TIMEOUT) || (RetVal == EFI_NOT_READY)) {
+    return RetVal;
+  }
+
+  Temp |= I2C_CR_MTX | I2C_CR_TX_NO_AK;
+  MmioWrite8 ((UINTN)&I2cRegs->I2cCr, Temp);
+
+  // write slave Address
+  RetVal = TransferByte (I2cRegs, Chip << 1);
+  if (RetVal != EFI_SUCCESS) {
+    return RetVal;
+  }
+
+  if (AddressLength >= 0) {
+    while (AddressLength--) {
+      RetVal = TransferByte (I2cRegs, (Offset >> (AddressLength * 8)) & 0xff);
+      if (RetVal != EFI_SUCCESS)
+        return RetVal;
+    }
+  }
+  return EFI_SUCCESS;
+}
+
+/**
+  Function to check if i2c bus is idle
+
+  @param   Base          Pointer to base address of I2c controller
+
+  @retval  EFI_SUCCESS
+
+**/
+STATIC
+INT32
+I2cBusIdle (
+  IN  VOID               *Base
+  )
+{
+  return EFI_SUCCESS;
+}
+
+/**
+  Function to initiate data transfer on i2c bus
+
+  @param   I2cRegs         Pointer to i2c base registers
+  @param   Chip            Chip Address
+  @param   Offset          Slave memory's offset
+  @param   AddressLength   length of chip address
+
+  @retval  EFI_NOT_READY   Arbitration lost
+  @retval  EFI_TIMEOUT     Failed to initialize data transfer in predefined time
+  @retval  EFI_NOT_FOUND   ACK was not recieved
+  @retval  EFI_SUCCESS     Read was successful
+
+**/
+STATIC
+EFI_STATUS
+InitDataTransfer (
+  IN  I2C_REGS             *I2cRegs,
+  IN  UINT8                Chip,
+  IN  UINT32               Offset,
+  IN  INT32                AddressLength
+  )
+{
+  EFI_STATUS               RetVal;
+  INT32                    Retry;
+
+  for (Retry = 0; Retry < RETRY_COUNT; Retry++) {
+    RetVal = InitTransfer (I2cRegs, Chip, Offset, AddressLength);
+    if (RetVal == EFI_SUCCESS) {
+      return EFI_SUCCESS;
+    }
+
+    I2cStop (I2cRegs);
+
+    if (EFI_NOT_FOUND == RetVal) {
+      return RetVal;
+    }
+
+    // Disable controller
+    if (RetVal != EFI_NOT_READY) {
+      MmioWrite8 ((UINTN)&I2cRegs->I2cCr, I2C_CR_IDIS);
+    }
+
+    if (I2cBusIdle (I2cRegs) < 0) {
+      break;
+    }
+  }
+  return RetVal;
+}
+
+/**
+  Function to read data using i2c bus
+
+  @param   BaseAddr        I2c Controller Base Address
+  @param   Chip            Address of slave device from where data to be read
+  @param   Offset          Offset of slave memory
+  @param   AddressLength   Address length of slave
+  @param   Buffer          A pointer to the destination buffer for the data
+  @param   Len             Length of data to be read
+
+  @retval  EFI_NOT_READY   Arbitration lost
+  @retval  EFI_TIMEOUT     Failed to initialize data transfer in predefined time
+  @retval  EFI_NOT_FOUND   ACK was not recieved
+  @retval  EFI_SUCCESS     Read was successful
+
+**/
+STATIC
+EFI_STATUS
+I2cDataRead (
+  IN  UINTN                BaseAddr,
+  IN  UINT8                Chip,
+  IN  UINT32               Offset,
+  IN  UINT32               AddressLength,
+  IN  UINT8                *Buffer,
+  IN  UINT32               Len
+  )
+{
+  EFI_STATUS               RetVal;
+  UINT32                   Temp;
+  INT32                    I;
+  I2C_REGS                 *I2cRegs;
+
+  I2cRegs = (I2C_REGS *)(BaseAddr);
+
+  RetVal = InitDataTransfer (I2cRegs, Chip, Offset, AddressLength);
+  if (RetVal != EFI_SUCCESS) {
+    return RetVal;
+  }
+
+  Temp = MmioRead8 ((UINTN)&I2cRegs->I2cCr);
+  Temp |= I2C_CR_RSTA;
+  MmioWrite8 ((UINTN)&I2cRegs->I2cCr, Temp);
+
+  RetVal = TransferByte (I2cRegs, (Chip << 1) | 1);
+  if (RetVal != EFI_SUCCESS) {
+    I2cStop (I2cRegs);
+    return RetVal;
+  }
+
+  // setup bus to read data
+  Temp = MmioRead8 ((UINTN)&I2cRegs->I2cCr);
+  Temp &= ~(I2C_CR_MTX | I2C_CR_TX_NO_AK);
+  if (Len == 1) {
+    Temp |= I2C_CR_TX_NO_AK;
+  }
+
+  MmioWrite8 ((UINTN)&I2cRegs->I2cCr, Temp);
+  MmioWrite8 ((UINTN)&I2cRegs->I2cSr, I2C_SR_IIF_CLEAR);
+
+  // Dummy Read to initiate recieve operation
+  MmioRead8 ((UINTN)&I2cRegs->I2cDr);
+
+  for (I = 0; I < Len; I++) {
+    RetVal = WaitForI2cState (I2cRegs, IIF);
+    if ((RetVal == EFI_TIMEOUT) || (RetVal == EFI_NOT_READY)) {
+       I2cStop (I2cRegs);
+       return RetVal;
+    }
+    //
+    // It must generate STOP before read I2DR to prevent
+    // controller from generating another clock cycle
+    //
+    if (I == (Len - 1)) {
+      I2cStop (I2cRegs);
+    } else if (I == (Len - 2)) {
+      Temp = MmioRead8 ((UINTN)&I2cRegs->I2cCr);
+      Temp |= I2C_CR_TX_NO_AK;
+      MmioWrite8 ((UINTN)&I2cRegs->I2cCr, Temp);
+    }
+    MmioWrite8 ((UINTN)&I2cRegs->I2cSr, I2C_SR_IIF_CLEAR);
+    Buffer[I] = MmioRead8 ((UINTN)&I2cRegs->I2cDr);
+  }
+
+  I2cStop (I2cRegs);
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Function to write data using i2c bus
+
+  @param   BaseAddr        I2c Controller Base Address
+  @param   Chip            Address of slave device where data to be written
+  @param   Offset          Offset of slave memory
+  @param   AddressLength   Address length of slave
+  @param   Buffer          A pointer to the source buffer for the data
+  @param   Len             Length of data to be write
+
+  @retval  EFI_NOT_READY   Arbitration lost
+  @retval  EFI_TIMEOUT     Failed to initialize data transfer in predefined time
+  @retval  EFI_NOT_FOUND   ACK was not recieved
+  @retval  EFI_SUCCESS     Read was successful
+
+**/
+STATIC
+EFI_STATUS
+I2cDataWrite (
+  IN  UINTN                BaseAddr,
+  IN  UINT8                Chip,
+  IN  UINT32               Offset,
+  IN  INT32                AddressLength,
+  OUT UINT8                *Buffer,
+  IN  INT32                Len
+  )
+{
+  EFI_STATUS               RetVal;
+  I2C_REGS                 *I2cRegs;
+  INT32                    I;
+
+  I2cRegs = (I2C_REGS *)BaseAddr;
+
+  RetVal = InitDataTransfer (I2cRegs, Chip, Offset, AddressLength);
+  if (RetVal != EFI_SUCCESS) {
+    return RetVal;
+  }
+
+  // Write operation
+  for (I = 0; I < Len; I++) {
+    RetVal = TransferByte (I2cRegs, Buffer[I]);
+    if (RetVal != EFI_SUCCESS) {
+      break;
+    }
+  }
+
+  I2cStop (I2cRegs);
+  return RetVal;
+}
+
+/**
+  Function to set i2c bus frequency
+
+  @param   This            Pointer to I2c master protocol
+  @param   BusClockHertz   value to be set
+
+  @retval EFI_SUCCESS      Operation successfull
+**/
+STATIC
+EFI_STATUS
+EFIAPI
+SetBusFrequency (
+  IN CONST EFI_I2C_MASTER_PROTOCOL   *This,
+  IN OUT UINTN                       *BusClockHertz
+ )
+{
+  I2C_REGS                 *I2cRegs;
+  UINT8                    ClkId;
+  UINT8                    SpeedId;
+  NXP_I2C_MASTER           *I2c;
+
+  I2c = NXP_I2C_FROM_THIS (This);
+
+  I2cRegs = (I2C_REGS *)(I2c->Dev->Resources[0].AddrRangeMin);
+
+  ClkId = GetClkDivIndex (*BusClockHertz);
+  SpeedId = mClkDiv[ClkId].BusClockRate;
+
+  // Store divider value
+  MmioWrite8 ((UINTN)&I2cRegs->I2cFdr, SpeedId);
+
+  MemoryFence ();
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Function to reset I2c Controller
+
+  @param  This             Pointer to I2c master protocol
+
+  @return EFI_SUCCESS      Operation successfull
+**/
+STATIC
+EFI_STATUS
+EFIAPI
+Reset (
+  IN CONST EFI_I2C_MASTER_PROTOCOL *This
+  )
+{
+  I2C_REGS                         *I2cRegs;
+  NXP_I2C_MASTER                   *I2c;
+
+  I2c = NXP_I2C_FROM_THIS (This);
+
+  I2cRegs = (I2C_REGS *)(I2c->Dev->Resources[0].AddrRangeMin);
+
+  // Reset module
+  MmioWrite8 ((UINTN)&I2cRegs->I2cCr, I2C_CR_IDIS);
+  MmioWrite8 ((UINTN)&I2cRegs->I2cSr, 0);
+
+  MemoryFence ();
+
+  return EFI_SUCCESS;
+}
+
+STATIC
+EFI_STATUS
+EFIAPI
+StartRequest (
+  IN CONST EFI_I2C_MASTER_PROTOCOL *This,
+  IN UINTN                         SlaveAddress,
+  IN EFI_I2C_REQUEST_PACKET        *RequestPacket,
+  IN EFI_EVENT                     Event            OPTIONAL,
+  OUT EFI_STATUS                   *I2cStatus       OPTIONAL
+  )
+{
+  NXP_I2C_MASTER                   *I2c;
+  UINT32                           Count;
+  INT32                            RetVal;
+  UINT32                           Length;
+  UINT8                            *Buffer;
+  UINT32                           Flag;
+  UINT32                           RegAddress;
+  UINT32                           OffsetLength;
+
+  RegAddress = 0;
+
+  I2c = NXP_I2C_FROM_THIS (This);
+
+  if (RequestPacket->OperationCount <= 0) {
+    DEBUG ((DEBUG_ERROR,"%a: Operation count is not valid %d\n",
+           __FUNCTION__, RequestPacket->OperationCount));
+    return EFI_INVALID_PARAMETER;
+  }
+
+  OffsetLength = RequestPacket->Operation[0].LengthInBytes;
+  RegAddress = *RequestPacket->Operation[0].Buffer;
+
+  for (Count = 1; Count < RequestPacket->OperationCount; Count++) {
+    Flag = RequestPacket->Operation[Count].Flags;
+    Length = RequestPacket->Operation[Count].LengthInBytes;
+    Buffer = RequestPacket->Operation[Count].Buffer;
+
+    if (Length <= 0) {
+      DEBUG ((DEBUG_ERROR,"%a: Invalid length of buffer %d\n",
+             __FUNCTION__, Length));
+      return EFI_INVALID_PARAMETER;
+    }
+
+    if (Flag == I2C_FLAG_READ) {
+      RetVal = I2cDataRead (I2c->Dev->Resources[0].AddrRangeMin, SlaveAddress,
+                            RegAddress, OffsetLength, Buffer, Length);
+      if (RetVal != EFI_SUCCESS) {
+        DEBUG ((DEBUG_ERROR,"%a: I2c read operation failed (error %d)\n",
+               __FUNCTION__, RetVal));
+        return RetVal;
+      }
+    } else if (Flag == I2C_FLAG_WRITE) {
+      RetVal = I2cDataWrite (I2c->Dev->Resources[0].AddrRangeMin, SlaveAddress,
+                             RegAddress, OffsetLength, Buffer, Length);
+      if (RetVal != EFI_SUCCESS) {
+        DEBUG ((DEBUG_ERROR,"%a: I2c write operation failed (error %d)\n",
+               __FUNCTION__, RetVal));
+        return RetVal;
+      }
+    } else {
+      DEBUG ((DEBUG_ERROR,"%a: Invalid Flag %d\n", __FUNCTION__, Flag));
+      return EFI_INVALID_PARAMETER;
+    }
+  }
+
+  return EFI_SUCCESS;
+}
+
+EFI_STATUS
+NxpI2cInit (
+  IN EFI_HANDLE             DriverBindingHandle,
+  IN EFI_HANDLE             ControllerHandle
+  )
+{
+  EFI_STATUS                RetVal;
+  NON_DISCOVERABLE_DEVICE   *Dev;
+  NXP_I2C_MASTER            *I2c;
+
+  RetVal = gBS->OpenProtocol (ControllerHandle,
+                              &gEdkiiNonDiscoverableDeviceProtocolGuid,
+                              (VOID **)&Dev, DriverBindingHandle,
+                              ControllerHandle, EFI_OPEN_PROTOCOL_BY_DRIVER);
+  if (EFI_ERROR (RetVal)) {
+    return RetVal;
+  }
+
+  I2c = AllocateZeroPool (sizeof (NXP_I2C_MASTER));
+
+  I2c->Signature                            = NXP_I2C_SIGNATURE;
+  I2c->I2cMaster.SetBusFrequency            = SetBusFrequency;
+  I2c->I2cMaster.Reset                      = Reset;
+  I2c->I2cMaster.StartRequest               = StartRequest;
+  I2c->I2cMaster.I2cControllerCapabilities  = &mI2cControllerCapabilities;
+  I2c->Dev                                  = Dev;
+
+  CopyGuid (&I2c->DevicePath.Vendor.Guid, &gEfiCallerIdGuid);
+  I2c->DevicePath.MmioBase = I2c->Dev->Resources[0].AddrRangeMin;
+  SetDevicePathNodeLength (&I2c->DevicePath.Vendor,
+    sizeof (I2c->DevicePath) - sizeof (I2c->DevicePath.End));
+  SetDevicePathEndNode (&I2c->DevicePath.End);
+
+  RetVal = gBS->InstallMultipleProtocolInterfaces (&ControllerHandle,
+                  &gEfiI2cMasterProtocolGuid, (VOID**)&I2c->I2cMaster,
+                  &gEfiDevicePathProtocolGuid, &I2c->DevicePath,
+                  NULL);
+
+  if (EFI_ERROR (RetVal)) {
+    FreePool (I2c);
+    gBS->CloseProtocol (ControllerHandle,
+                        &gEdkiiNonDiscoverableDeviceProtocolGuid,
+                        DriverBindingHandle,
+                        ControllerHandle);
+  }
+
+  return RetVal;
+}
+
+EFI_STATUS
+NxpI2cRelease (
+  IN EFI_HANDLE                 DriverBindingHandle,
+  IN EFI_HANDLE                 ControllerHandle
+  )
+{
+  EFI_I2C_MASTER_PROTOCOL       *I2cMaster;
+  EFI_STATUS                    RetVal;
+  NXP_I2C_MASTER                *I2c;
+
+  RetVal = gBS->HandleProtocol (ControllerHandle,
+                                &gEfiI2cMasterProtocolGuid,
+                                (VOID **)&I2cMaster);
+  ASSERT_EFI_ERROR (RetVal);
+  if (EFI_ERROR (RetVal)) {
+    return RetVal;
+  }
+
+  I2c = NXP_I2C_FROM_THIS (I2cMaster);
+
+  RetVal = gBS->UninstallMultipleProtocolInterfaces (ControllerHandle,
+                  &gEfiI2cMasterProtocolGuid, I2cMaster,
+                  &gEfiDevicePathProtocolGuid, &I2c->DevicePath,
+                  NULL);
+  if (EFI_ERROR (RetVal)) {
+    return RetVal;
+  }
+
+  RetVal = gBS->CloseProtocol (ControllerHandle,
+                               &gEdkiiNonDiscoverableDeviceProtocolGuid,
+                               DriverBindingHandle,
+                               ControllerHandle);
+  ASSERT_EFI_ERROR (RetVal);
+  if (EFI_ERROR (RetVal)) {
+    return RetVal;
+  }
+
+  gBS->FreePool (I2c);
+
+  return EFI_SUCCESS;
+}
-- 
1.9.1