public inbox for devel@edk2.groups.io
 help / color / mirror / Atom feed
From: Ming Huang <ming.huang@linaro.org>
To: leif.lindholm@linaro.org, linaro-uefi@lists.linaro.org,
	edk2-devel@lists.01.org, graeme.gregory@linaro.org
Cc: ard.biesheuvel@linaro.org, michael.d.kinney@intel.com,
	lersek@redhat.com, guoheyi@huawei.com, wanghuiqiang@huawei.com,
	huangming23@huawei.com, zhangjinsong2@huawei.com,
	huangdaode@hisilicon.com, john.garry@huawei.com,
	xinliang.liu@linaro.org, Ming Huang <ming.huang@linaro.org>
Subject: [PATCH edk2-platforms v2 20/43] Hisilicon/I2C: Modify I2CLib.c for coding style
Date: Tue, 14 Aug 2018 16:08:40 +0800	[thread overview]
Message-ID: <20180814080903.50466-21-ming.huang@linaro.org> (raw)
In-Reply-To: <20180814080903.50466-1-ming.huang@linaro.org>

Correct coding style for I2CLib.c before adding other I2CLib patches.

Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Ming Huang <ming.huang@linaro.org>
---
 Silicon/Hisilicon/Library/I2CLib/I2CLib.c | 1034 ++++++++++----------
 1 file changed, 499 insertions(+), 535 deletions(-)

diff --git a/Silicon/Hisilicon/Library/I2CLib/I2CLib.c b/Silicon/Hisilicon/Library/I2CLib/I2CLib.c
index b5b388d756..f03d55d6b2 100644
--- a/Silicon/Hisilicon/Library/I2CLib/I2CLib.c
+++ b/Silicon/Hisilicon/Library/I2CLib/I2CLib.c
@@ -16,640 +16,604 @@
 
 
 #include <PiDxe.h>
-#include <Library/DebugLib.h>
-#include <Library/UefiBootServicesTableLib.h>
 #include <Library/ArmLib.h>
 #include <Library/BaseLib.h>
+#include <Library/DebugLib.h>
 #include <Library/I2CLib.h>
 #include <Library/TimerLib.h>
+#include <Library/UefiBootServicesTableLib.h>
 
 #include <Library/PlatformSysCtrlLib.h>
 
 #include "I2CLibInternal.h"
 #include "I2CHw.h"
 
-VOID I2C_Delay(UINT32 ulCount)
+VOID
+I2C_Delay (
+  UINT32 Count
+  )
 {
-    MicroSecondDelay(ulCount);
-    return;
+  MicroSecondDelay (Count);
+  return;
 }
 
 
 EFI_STATUS
 EFIAPI
-I2C_Disable(UINT32 Socket,UINT8 Port)
+I2C_Disable (
+  UINT32 Socket,
+  UINT8  Port
+  )
 {
-    UINT32                  ulTimeCnt = I2C_READ_TIMEOUT;
-    I2C0_STATUS_U           I2cStatusReg;
-    I2C0_ENABLE_U           I2cEnableReg;
-    I2C0_ENABLE_STATUS_U    I2cEnableStatusReg;
+  UINT32                  TimeCnt = I2C_READ_TIMEOUT;
+  I2C0_STATUS_U           I2cStatusReg;
+  I2C0_ENABLE_U           I2cEnableReg;
+  I2C0_ENABLE_STATUS_U    I2cEnableStatusReg;
 
-    UINTN Base = GetI2cBase(Socket, Port);
+  UINTN Base = GetI2cBase (Socket, Port);
 
-    I2C_REG_READ((Base + I2C_STATUS_OFFSET), I2cStatusReg.Val32);
+  I2C_REG_READ ((Base + I2C_STATUS_OFFSET), I2cStatusReg.Val32);
 
-    while (I2cStatusReg.bits.activity)
-    {
-        I2C_Delay(10000);
+  while (I2cStatusReg.bits.activity) {
+    I2C_Delay (10000);
 
-        ulTimeCnt--;
-        I2C_REG_READ(Base + I2C_STATUS_OFFSET, I2cStatusReg.Val32);
-        if (0 == ulTimeCnt)
-        {
-            return EFI_DEVICE_ERROR;
-        }
+    TimeCnt--;
+    I2C_REG_READ (Base + I2C_STATUS_OFFSET, I2cStatusReg.Val32);
+    if (TimeCnt == 0) {
+      return EFI_DEVICE_ERROR;
     }
+  }
 
+  I2C_REG_READ (Base + I2C_ENABLE_OFFSET, I2cEnableReg.Val32);
+  I2cEnableReg.bits.enable = 0;
+  I2C_REG_WRITE (Base + I2C_ENABLE_OFFSET, I2cEnableReg.Val32);
 
-    I2C_REG_READ(Base + I2C_ENABLE_OFFSET, I2cEnableReg.Val32);
-    I2cEnableReg.bits.enable = 0;
-    I2C_REG_WRITE(Base + I2C_ENABLE_OFFSET,I2cEnableReg.Val32);
-
-    I2C_REG_READ(Base + I2C_ENABLE_OFFSET,I2cEnableStatusReg.Val32);
-    if (0 == I2cEnableStatusReg.bits.ic_en)
-    {
-        return EFI_SUCCESS;
-    }
-    else
-    {
-        return EFI_DEVICE_ERROR;
-    }
+  I2C_REG_READ (Base + I2C_ENABLE_OFFSET, I2cEnableStatusReg.Val32);
+  if (I2cEnableStatusReg.bits.ic_en == 0) {
+    return EFI_SUCCESS;
+  } else {
+    return EFI_DEVICE_ERROR;
+  }
 }
 
 
 EFI_STATUS
 EFIAPI
-I2C_Enable(UINT32 Socket,UINT8 Port)
+I2C_Enable (
+  UINT32 Socket,
+  UINT8  Port
+  )
 {
-    I2C0_ENABLE_U           I2cEnableReg;
-    I2C0_ENABLE_STATUS_U    I2cEnableStatusReg;
+  I2C0_ENABLE_U           I2cEnableReg;
+  I2C0_ENABLE_STATUS_U    I2cEnableStatusReg;
 
-    UINTN Base = GetI2cBase(Socket, Port);
+  UINTN Base = GetI2cBase (Socket, Port);
 
+  I2C_REG_READ (Base + I2C_ENABLE_OFFSET, I2cEnableReg.Val32);
+  I2cEnableReg.bits.enable = 1;
+  I2C_REG_WRITE (Base + I2C_ENABLE_OFFSET, I2cEnableReg.Val32);
 
-    I2C_REG_READ(Base + I2C_ENABLE_OFFSET, I2cEnableReg.Val32);
-    I2cEnableReg.bits.enable = 1;
-    I2C_REG_WRITE(Base + I2C_ENABLE_OFFSET, I2cEnableReg.Val32);
 
-
-    I2C_REG_READ(Base + I2C_ENABLE_STATUS_OFFSET, I2cEnableStatusReg.Val32);
-    if (1 == I2cEnableStatusReg.bits.ic_en)
-    {
-        return EFI_SUCCESS;
-    }
-    else
-    {
-        return EFI_DEVICE_ERROR;
-    }
+  I2C_REG_READ (Base + I2C_ENABLE_STATUS_OFFSET, I2cEnableStatusReg.Val32);
+  if (I2cEnableStatusReg.bits.ic_en == 1) {
+    return EFI_SUCCESS;
+  } else {
+    return EFI_DEVICE_ERROR;
+  }
 }
 
-void I2C_SetTarget(UINT32 Socket,UINT8 Port,UINT32 I2cDeviceAddr)
+VOID
+I2C_SetTarget (
+  UINT32 Socket,
+  UINT8  Port,
+  UINT32 I2cDeviceAddr
+  )
 {
-    I2C0_TAR_U    I2cTargetReg;
-    UINTN Base = GetI2cBase(Socket, Port);
+  I2C0_TAR_U    I2cTargetReg;
 
+  UINTN Base = GetI2cBase (Socket, Port);
 
-    I2C_REG_READ(Base + I2C_TAR_OFFSET, I2cTargetReg.Val32);
-    I2cTargetReg.bits.ic_tar = I2cDeviceAddr;
-    I2C_REG_WRITE(Base + I2C_TAR_OFFSET, I2cTargetReg.Val32);
+  I2C_REG_READ (Base + I2C_TAR_OFFSET, I2cTargetReg.Val32);
+  I2cTargetReg.bits.ic_tar = I2cDeviceAddr;
+  I2C_REG_WRITE (Base + I2C_TAR_OFFSET, I2cTargetReg.Val32);
 
-    return;
+  return;
 }
 
 
 EFI_STATUS
 EFIAPI
-I2CInit(UINT32 Socket, UINT32 Port, SPEED_MODE SpeedMode)
+I2CInit (
+  UINT32     Socket,
+  UINT32     Port,
+  SPEED_MODE SpeedMode
+  )
 {
-    I2C0_CON_U              I2cControlReg;
-    I2C0_SS_SCL_HCNT_U      I2cStandardSpeedSclHighCount;
-    I2C0_SS_SCL_LCNT_U      I2cStandardSpeedSclLowCount;
-    I2C0_RX_TL_U            I2cRxFifoReg;
-    I2C0_TX_TL_U            I2cTxFifoReg;
-    I2C0_INTR_MASK_U        I2cIntrMask;
-    EFI_STATUS              Status;
-
-    UINTN Base = GetI2cBase(Socket, Port);
-
-    if((Socket >= MAX_SOCKET) || (Port >= I2C_PORT_MAX) || (SpeedMode >= SPEED_MODE_MAX)){
-        return EFI_INVALID_PARAMETER;
-    }
-
-
-    Status = I2C_Disable(Socket,Port);
-    if(EFI_ERROR(Status))
-    {
-        return EFI_DEVICE_ERROR;
-    }
-
-
-    I2C_REG_READ(Base + I2C_CON_OFFSET, I2cControlReg.Val32);
-    I2cControlReg.bits.master = 1;
-    I2cControlReg.bits.spedd = 0x1;
-    I2cControlReg.bits.restart_en = 1;
-    I2cControlReg.bits.slave_disable = 1;
-    I2C_REG_WRITE(Base + I2C_CON_OFFSET,I2cControlReg.Val32);
-
-
-    if(Normal == SpeedMode)
-    {
-        I2C_REG_READ(Base + I2C_SS_SCL_HCNT_OFFSET,I2cStandardSpeedSclHighCount.Val32);
-        I2cStandardSpeedSclHighCount.bits.ic_ss_scl_hcnt = I2C_SS_SCLHCNT;
-        I2C_REG_WRITE(Base + I2C_SS_SCL_HCNT_OFFSET, I2cStandardSpeedSclHighCount.Val32);
-        I2C_REG_READ(Base + I2C_SS_SCL_LCNT_OFFSET, I2cStandardSpeedSclLowCount.Val32);
-        I2cStandardSpeedSclLowCount.bits.ic_ss_scl_lcnt = I2C_SS_SCLLCNT;
-        I2C_REG_WRITE(Base + I2C_SS_SCL_LCNT_OFFSET, I2cStandardSpeedSclLowCount.Val32);
-    }
-    else
-    {
-        I2C_REG_READ(Base + I2C_FS_SCL_HCNT_OFFSET,I2cStandardSpeedSclHighCount.Val32);
-        I2cStandardSpeedSclHighCount.bits.ic_ss_scl_hcnt = I2C_SS_SCLHCNT;
-        I2C_REG_WRITE(Base + I2C_FS_SCL_HCNT_OFFSET, I2cStandardSpeedSclHighCount.Val32);
-        I2C_REG_READ(Base + I2C_FS_SCL_LCNT_OFFSET, I2cStandardSpeedSclLowCount.Val32);
-        I2cStandardSpeedSclLowCount.bits.ic_ss_scl_lcnt = I2C_SS_SCLLCNT;
-        I2C_REG_WRITE(Base + I2C_FS_SCL_LCNT_OFFSET, I2cStandardSpeedSclLowCount.Val32);
-    }
-
-
-    I2C_REG_READ(Base + I2C_RX_TL_OFFSET, I2cRxFifoReg.Val32);
-    I2cRxFifoReg.bits.rx_tl = I2C_TXRX_THRESHOLD;
-    I2C_REG_WRITE(Base + I2C_RX_TL_OFFSET, I2cRxFifoReg.Val32);
-    I2C_REG_READ(Base + I2C_TX_TL_OFFSET,I2cTxFifoReg.Val32);
-    I2cTxFifoReg.bits.tx_tl = I2C_TXRX_THRESHOLD;
-    I2C_REG_WRITE(Base + I2C_TX_TL_OFFSET, I2cTxFifoReg.Val32);
-
-
-    I2C_REG_READ(Base + I2C_INTR_MASK_OFFSET, I2cIntrMask.Val32);
-    I2cIntrMask.Val32 = 0x0;
-    I2C_REG_WRITE(Base + I2C_INTR_MASK_OFFSET, I2cIntrMask.Val32);
-
-
-    Status = I2C_Enable(Socket,Port);
-    if(EFI_ERROR(Status))
-    {
-        return EFI_DEVICE_ERROR;
-    }
-
-    return I2cLibRuntimeSetup (Socket, Port);
+  I2C0_CON_U              I2cControlReg;
+  I2C0_SS_SCL_HCNT_U      I2cStandardSpeedSclHighCount;
+  I2C0_SS_SCL_LCNT_U      I2cStandardSpeedSclLowCount;
+  I2C0_RX_TL_U            I2cRxFifoReg;
+  I2C0_TX_TL_U            I2cTxFifoReg;
+  I2C0_INTR_MASK_U        I2cIntrMask;
+  EFI_STATUS              Status;
+
+  UINTN Base = GetI2cBase (Socket, Port);
+
+  if ((Socket >= MAX_SOCKET) ||
+     (Port >= I2C_PORT_MAX) ||
+     (SpeedMode >= SPEED_MODE_MAX)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Status = I2C_Disable (Socket,Port);
+  if (EFI_ERROR (Status)) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  I2C_REG_READ (Base + I2C_CON_OFFSET, I2cControlReg.Val32);
+  I2cControlReg.bits.master = 1;
+  I2cControlReg.bits.spedd = 0x1;
+  I2cControlReg.bits.restart_en = 1;
+  I2cControlReg.bits.slave_disable = 1;
+  I2C_REG_WRITE (Base + I2C_CON_OFFSET, I2cControlReg.Val32);
+
+  if (SpeedMode == Normal) {
+    I2C_REG_READ (Base + I2C_SS_SCL_HCNT_OFFSET, I2cStandardSpeedSclHighCount.Val32);
+    I2cStandardSpeedSclHighCount.bits.ic_ss_scl_hcnt = I2C_SS_SCLHCNT;
+    I2C_REG_WRITE (Base + I2C_SS_SCL_HCNT_OFFSET, I2cStandardSpeedSclHighCount.Val32);
+    I2C_REG_READ (Base + I2C_SS_SCL_LCNT_OFFSET, I2cStandardSpeedSclLowCount.Val32);
+    I2cStandardSpeedSclLowCount.bits.ic_ss_scl_lcnt = I2C_SS_SCLLCNT;
+    I2C_REG_WRITE (Base + I2C_SS_SCL_LCNT_OFFSET, I2cStandardSpeedSclLowCount.Val32);
+  } else {
+    I2C_REG_READ (Base + I2C_FS_SCL_HCNT_OFFSET, I2cStandardSpeedSclHighCount.Val32);
+    I2cStandardSpeedSclHighCount.bits.ic_ss_scl_hcnt = I2C_SS_SCLHCNT;
+    I2C_REG_WRITE (Base + I2C_FS_SCL_HCNT_OFFSET, I2cStandardSpeedSclHighCount.Val32);
+    I2C_REG_READ (Base + I2C_FS_SCL_LCNT_OFFSET, I2cStandardSpeedSclLowCount.Val32);
+    I2cStandardSpeedSclLowCount.bits.ic_ss_scl_lcnt = I2C_SS_SCLLCNT;
+    I2C_REG_WRITE (Base + I2C_FS_SCL_LCNT_OFFSET, I2cStandardSpeedSclLowCount.Val32);
+  }
+
+  I2C_REG_READ (Base + I2C_RX_TL_OFFSET, I2cRxFifoReg.Val32);
+  I2cRxFifoReg.bits.rx_tl = I2C_TXRX_THRESHOLD;
+  I2C_REG_WRITE (Base + I2C_RX_TL_OFFSET, I2cRxFifoReg.Val32);
+  I2C_REG_READ (Base + I2C_TX_TL_OFFSET, I2cTxFifoReg.Val32);
+  I2cTxFifoReg.bits.tx_tl = I2C_TXRX_THRESHOLD;
+  I2C_REG_WRITE (Base + I2C_TX_TL_OFFSET, I2cTxFifoReg.Val32);
+
+  I2C_REG_READ (Base + I2C_INTR_MASK_OFFSET, I2cIntrMask.Val32);
+  I2cIntrMask.Val32 = 0x0;
+  I2C_REG_WRITE (Base + I2C_INTR_MASK_OFFSET, I2cIntrMask.Val32);
+
+  Status = I2C_Enable (Socket, Port);
+  if (EFI_ERROR (Status)) {
+    return EFI_DEVICE_ERROR;
+  }
+
+  return I2cLibRuntimeSetup (Socket, Port);
 }
 
 EFI_STATUS
 EFIAPI
-I2CSdaConfig(UINT32 Socket, UINT32 Port)
+I2CSdaConfig (
+  UINT32 Socket,
+  UINT32 Port
+  )
 {
+  UINTN Base = GetI2cBase (Socket, Port);
 
-    UINTN Base = GetI2cBase(Socket, Port);
+  if ((Socket >= MAX_SOCKET) || (Port >= I2C_PORT_MAX)) {
+    return EFI_INVALID_PARAMETER;
+  }
 
-    if((Socket >= MAX_SOCKET) || (Port >= I2C_PORT_MAX)){
-        return EFI_INVALID_PARAMETER;
-    }
-
-    I2C_REG_WRITE(Base + I2C_SDA_HOLD, 0x14);
+  I2C_REG_WRITE (Base + I2C_SDA_HOLD, 0x14);
 
-    return EFI_SUCCESS;
+  return EFI_SUCCESS;
 }
 
 
 
-UINT32 I2C_GetTxStatus(UINT32 Socket,UINT8 Port)
+UINT32
+I2C_GetTxStatus (
+  UINT32 Socket,
+  UINT8  Port
+  )
 {
-    I2C0_TXFLR_U ulFifo;
-    UINTN Base = GetI2cBase(Socket, Port);
+  I2C0_TXFLR_U Fifo;
+  UINTN        Base = GetI2cBase (Socket, Port);
 
-    I2C_REG_READ(Base + I2C_TXFLR_OFFSET, ulFifo.Val32);
-    return ulFifo.bits.txflr;
+  I2C_REG_READ (Base + I2C_TXFLR_OFFSET, Fifo.Val32);
+  return Fifo.bits.txflr;
 }
 
 UINT32
-I2C_GetRxStatus(UINT32 Socket,UINT8 Port)
+I2C_GetRxStatus (
+  UINT32 Socket,
+  UINT8 Port
+  )
 {
-    I2C0_RXFLR_U ulFifo;
-    UINTN Base = GetI2cBase(Socket, Port);
+  I2C0_RXFLR_U Fifo;
+  UINTN Base = GetI2cBase (Socket, Port);
 
-    I2C_REG_READ(Base + I2C_RXFLR_OFFSET, ulFifo.Val32);
-    return ulFifo.bits.rxflr;
+  I2C_REG_READ (Base + I2C_RXFLR_OFFSET, Fifo.Val32);
+  return Fifo.bits.rxflr;
 }
 
 EFI_STATUS
 EFIAPI
-WriteBeforeRead(I2C_DEVICE *I2cInfo, UINT32 ulLength, UINT8 *pBuf)
+WriteBeforeRead (
+  I2C_DEVICE *I2cInfo,
+  UINT32     Length,
+  UINT8      *pBuf
+  )
 {
-    UINT32 ulFifo;
-    UINT32 ulCnt;
-    UINT32 ulTimes = 0;
+  UINT32 Fifo;
+  UINT32 Count;
+  UINT32 Times = 0;
 
-    UINTN  Base = GetI2cBase(I2cInfo->Socket, I2cInfo->Port);
+  UINTN  Base = GetI2cBase (I2cInfo->Socket, I2cInfo->Port);
 
+  I2C_SetTarget (I2cInfo->Socket, I2cInfo->Port, I2cInfo->SlaveDeviceAddress);
 
-    I2C_SetTarget(I2cInfo->Socket,I2cInfo->Port,I2cInfo->SlaveDeviceAddress);
-
-    ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    while(0 != ulFifo)
-    {
-        I2C_Delay(2);
-        if(++ulTimes > I2C_READ_TIMEOUT)
-        {
-            return EFI_TIMEOUT;
-        }
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
+  Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  while (Fifo != 0) {
+    I2C_Delay (2);
+    if (++Times > I2C_READ_TIMEOUT) {
+      return EFI_TIMEOUT;
     }
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
 
-    for(ulCnt = 0; ulCnt < ulLength; ulCnt++)
-    {
-        ulTimes = 0;
-        while(ulFifo > I2C_TXRX_THRESHOLD)
-        {
-            I2C_Delay(2);
-            if(++ulTimes > I2C_READ_TIMEOUT)
-            {
-                return EFI_TIMEOUT;
-            }
-            ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-        }
-
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, *pBuf++);
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
+  for (Count = 0; Count < Length; Count++) {
+    Times = 0;
+    while (Fifo > I2C_TXRX_THRESHOLD) {
+      I2C_Delay (2);
+      if (++Times > I2C_READ_TIMEOUT) {
+        return EFI_TIMEOUT;
+      }
+      Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
     }
 
-    ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    ulTimes = 0;
-    while(0 != ulFifo)
-    {
-        I2C_Delay(2);
-
-        if(++ulTimes > I2C_READ_TIMEOUT)
-        {
-            return EFI_TIMEOUT;
-        }
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, *pBuf++);
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
+
+  Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  Times = 0;
+  while (Fifo != 0) {
+    I2C_Delay (2);
+
+    if (++Times > I2C_READ_TIMEOUT) {
+      return EFI_TIMEOUT;
     }
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
 
-    return EFI_SUCCESS;
+  return EFI_SUCCESS;
 }
 
 
 EFI_STATUS
 EFIAPI
-I2CWrite(I2C_DEVICE *I2cInfo, UINT16 InfoOffset, UINT32 ulLength, UINT8 *pBuf)
+I2CWrite(
+  I2C_DEVICE *I2cInfo,
+  UINT16     InfoOffset,
+  UINT32     Length,
+  UINT8 *pBuf
+  )
 {
-    UINT32 ulFifo;
-    UINT32 ulTimes = 0;
-    UINT32  Idx;
-    UINTN  Base;
-
-
-    if(I2cInfo->Port >= I2C_PORT_MAX)
-    {
-        return EFI_INVALID_PARAMETER;
-    }
-
-    Base = GetI2cBase(I2cInfo->Socket, I2cInfo->Port);
-
-    (VOID)I2C_Enable(I2cInfo->Socket, I2cInfo->Port);
-
-    I2C_SetTarget(I2cInfo->Socket,I2cInfo->Port,I2cInfo->SlaveDeviceAddress);
-
-    ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    while(0 != ulFifo)
-    {
-        I2C_Delay(2);
-        if(++ulTimes > I2C_READ_TIMEOUT)
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_TIMEOUT;
-        }
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    }
-
-
-    if(I2cInfo->DeviceType)
-    {
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 8) & 0xff);
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, InfoOffset & 0xff);
-    }
-    else
-    {
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, InfoOffset & 0xff);
-    }
-
-    ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    ulTimes = 0;
-    while(0 != ulFifo)
-    {
-        I2C_Delay(2);
-        if(++ulTimes > I2C_READ_TIMEOUT)
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_TIMEOUT;
-        }
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    }
-
-    for(Idx = 0; Idx < ulLength; Idx++)
-    {
-        ulTimes = 0;
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-        while(ulFifo > I2C_TXRX_THRESHOLD)
-        {
-            I2C_Delay(2);
-            if(++ulTimes > I2C_READ_TIMEOUT)
-            {
-                (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-                return EFI_TIMEOUT;
-            }
-            ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-        }
-
-        if (Idx < ulLength - 1) {
-            I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, (*pBuf++));
-        } else {
-            //Send command stop bit for the last transfer
-            I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, (*pBuf++) | I2C_CMD_STOP_BIT);
-        }
-    }
-
-    ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    ulTimes = 0;
-    while(0 != ulFifo)
-    {
-        I2C_Delay(2);
-
-        if(++ulTimes > I2C_READ_TIMEOUT)
-        {
-            DEBUG ((EFI_D_ERROR, "I2C Write try to finished,time out!\n"));
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_TIMEOUT;
-        }
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    }
-    (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-
-    return EFI_SUCCESS;
+  UINT32 Fifo;
+  UINT32 Times = 0;
+  UINT32  Idx;
+  UINTN  Base;
+
+  if (I2cInfo->Port >= I2C_PORT_MAX) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Base = GetI2cBase (I2cInfo->Socket, I2cInfo->Port);
+
+  (VOID)I2C_Enable(I2cInfo->Socket, I2cInfo->Port);
+
+  I2C_SetTarget(I2cInfo->Socket, I2cInfo->Port, I2cInfo->SlaveDeviceAddress);
+
+  Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  while (Fifo != 0) {
+    I2C_Delay (2);
+    if (++Times > I2C_READ_TIMEOUT) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_TIMEOUT;
+    }
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
+
+  if (I2cInfo->DeviceType) {
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 8) & 0xff);
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, InfoOffset & 0xff);
+  } else {
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, InfoOffset & 0xff);
+  }
+
+  Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  Times = 0;
+  while (Fifo != 0) {
+    I2C_Delay (2);
+    if (++Times > I2C_READ_TIMEOUT) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_TIMEOUT;
+    }
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
+
+  for (Idx = 0; Idx < Length; Idx++) {
+    Times = 0;
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+    while (Fifo > I2C_TXRX_THRESHOLD) {
+      I2C_Delay (2);
+      if (++Times > I2C_READ_TIMEOUT) {
+        (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+        return EFI_TIMEOUT;
+      }
+      Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+    }
+
+    if (Idx < Length - 1) {
+      I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, (*pBuf++));
+    } else {
+      //Send command stop bit for the last transfer
+      I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, (*pBuf++) | I2C_CMD_STOP_BIT);
+    }
+  }
+
+  Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  Times = 0;
+  while (Fifo != 0) {
+    I2C_Delay (2);
+
+    if (++Times > I2C_READ_TIMEOUT) {
+      DEBUG ((DEBUG_ERROR, "I2C Write try to finished,time out!\n"));
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_TIMEOUT;
+    }
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
+  (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+
+  return EFI_SUCCESS;
 }
 
 EFI_STATUS
 EFIAPI
-I2CRead(I2C_DEVICE *I2cInfo, UINT16 InfoOffset,UINT32 ulRxLen,UINT8 *pBuf)
+I2CRead(
+  I2C_DEVICE *I2cInfo,
+  UINT16     InfoOffset,
+  UINT32     RxLen,
+  UINT8 *pBuf
+  )
 {
-    UINT32 ulFifo;
-    UINT32 ulTimes = 0;
-    UINT8  I2CWAddr[2];
-    EFI_STATUS  Status;
-    UINT32  Idx = 0;
-    UINTN Base;
-
-
-    if(I2cInfo->Port >= I2C_PORT_MAX)
-    {
-        return EFI_INVALID_PARAMETER;
-    }
-
-    (VOID)I2C_Enable(I2cInfo->Socket, I2cInfo->Port);
-    Base = GetI2cBase(I2cInfo->Socket, I2cInfo->Port);
-    if(I2cInfo->DeviceType)
-    {
-        I2CWAddr[0] = (InfoOffset >> 8) & 0xff;
-        I2CWAddr[1] = (InfoOffset & 0xff);
-        Status = WriteBeforeRead(I2cInfo, 2,I2CWAddr);
-        if(EFI_ERROR(Status))
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_ABORTED;
-        }
-    }
-    else
-    {
-        I2CWAddr[0] = (InfoOffset & 0xff);
-        Status = WriteBeforeRead(I2cInfo, 1,I2CWAddr);
-        if(EFI_ERROR(Status))
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_ABORTED;
-        }
-    }
-
-    I2C_SetTarget(I2cInfo->Socket,I2cInfo->Port,I2cInfo->SlaveDeviceAddress);
-
-    ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    while(0 != ulFifo)
-    {
-        I2C_Delay(2);
-
-        while(++ulTimes > I2C_READ_TIMEOUT)
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_TIMEOUT;
-        }
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    }
-
-    while (ulRxLen > 0) {
-        if (ulRxLen > 1) {
-            I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, I2C_READ_SIGNAL);
-        } else {
-            //Send command stop bit for the last transfer
-            I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, I2C_READ_SIGNAL | I2C_CMD_STOP_BIT);
-        }
-
-        ulTimes = 0;
-        do {
-            I2C_Delay(2);
-
-            while(++ulTimes > I2C_READ_TIMEOUT) {
-                (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-                return EFI_TIMEOUT;
-            }
-            ulFifo = I2C_GetRxStatus(I2cInfo->Socket,I2cInfo->Port);
-        }while(0 == ulFifo);
-
-        I2C_REG_READ(Base + I2C_DATA_CMD_OFFSET, pBuf[Idx++]);
-
-        ulRxLen --;
-    }
-    (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-
-    return EFI_SUCCESS;
+  UINT32      Fifo;
+  UINT32      Times = 0;
+  UINT8       I2CWAddr[2];
+  EFI_STATUS  Status;
+  UINT32      Idx = 0;
+  UINTN       Base;
+
+  if (I2cInfo->Port >= I2C_PORT_MAX) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  (VOID)I2C_Enable(I2cInfo->Socket, I2cInfo->Port);
+  Base = GetI2cBase (I2cInfo->Socket, I2cInfo->Port);
+  if (I2cInfo->DeviceType) {
+    I2CWAddr[0] = (InfoOffset >> 8) & 0xff;
+    I2CWAddr[1] = (InfoOffset & 0xff);
+    Status = WriteBeforeRead (I2cInfo, 2,I2CWAddr);
+    if (EFI_ERROR (Status)) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_ABORTED;
+    }
+  } else {
+    I2CWAddr[0] = (InfoOffset & 0xff);
+    Status = WriteBeforeRead (I2cInfo, 1, I2CWAddr);
+    if (EFI_ERROR (Status)) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_ABORTED;
+    }
+  }
+
+  I2C_SetTarget (I2cInfo->Socket, I2cInfo->Port, I2cInfo->SlaveDeviceAddress);
+
+  Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  while (Fifo != 0) {
+    I2C_Delay (2);
+
+    while (++Times > I2C_READ_TIMEOUT) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_TIMEOUT;
+    }
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
+
+  while (RxLen > 0) {
+    if (RxLen > 1) {
+      I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, I2C_READ_SIGNAL);
+    } else {
+      //Send command stop bit for the last transfer
+      I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, I2C_READ_SIGNAL | I2C_CMD_STOP_BIT);
+    }
+
+    Times = 0;
+    do {
+      I2C_Delay (2);
+
+      while (++Times > I2C_READ_TIMEOUT) {
+        (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+        return EFI_TIMEOUT;
+      }
+      Fifo = I2C_GetRxStatus (I2cInfo->Socket, I2cInfo->Port);
+    } while (Fifo == 0);
+
+    I2C_REG_READ (Base + I2C_DATA_CMD_OFFSET, pBuf[Idx++]);
+
+    RxLen --;
+  }
+  (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+
+  return EFI_SUCCESS;
 }
 
 EFI_STATUS
 EFIAPI
-I2CReadMultiByte(I2C_DEVICE *I2cInfo, UINT32 InfoOffset,UINT32 ulRxLen,UINT8 *pBuf)
+I2CReadMultiByte (
+  I2C_DEVICE *I2cInfo,
+  UINT32     InfoOffset,
+  UINT32     RxLen,
+  UINT8      *pBuf
+  )
 {
-    UINT32 ulCnt;
-    UINT16 usTotalLen = 0;
-    UINT32 ulFifo;
-    UINT32 ulTimes = 0;
-    UINT8  I2CWAddr[4];
-    EFI_STATUS  Status;
-    UINT32  BytesLeft;
-    UINT32  Idx = 0;
-    UINTN Base;
-
-
-    if(I2cInfo->Port >= I2C_PORT_MAX)
-    {
-        return EFI_INVALID_PARAMETER;
-    }
-
-    (VOID)I2C_Enable(I2cInfo->Socket, I2cInfo->Port);
-    Base = GetI2cBase(I2cInfo->Socket, I2cInfo->Port);
-    if(I2cInfo->DeviceType == DEVICE_TYPE_E2PROM)
-    {
-        I2CWAddr[0] = (InfoOffset >> 8) & 0xff;
-        I2CWAddr[1] = (InfoOffset & 0xff);
-        Status = WriteBeforeRead(I2cInfo, 2,I2CWAddr);
-        if(EFI_ERROR(Status))
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_ABORTED;
-        }
-    }
-
-    else if(I2cInfo->DeviceType == DEVICE_TYPE_CPLD_3BYTE_OPERANDS)
-    {
-        I2CWAddr[0] = (InfoOffset >> 16) & 0xff;
-        I2CWAddr[1] = (InfoOffset >> 8) & 0xff;
-        I2CWAddr[2] = (InfoOffset & 0xff);
-        Status = WriteBeforeRead(I2cInfo, 3,I2CWAddr);
-        if(EFI_ERROR(Status))
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_ABORTED;
-        }
-    }
-
-    else if(I2cInfo->DeviceType == DEVICE_TYPE_CPLD_4BYTE_OPERANDS)
-    {
-        I2CWAddr[0] = (InfoOffset >> 24) & 0xff;
-        I2CWAddr[1] = (InfoOffset >> 16) & 0xff;
-        I2CWAddr[2] = (InfoOffset >> 8) & 0xff;
-        I2CWAddr[3] = (InfoOffset & 0xff);
-        Status = WriteBeforeRead(I2cInfo, 4,I2CWAddr);
-        if(EFI_ERROR(Status))
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_ABORTED;
-        }
-    }
-
-    else
-    {
-        I2CWAddr[0] = (InfoOffset & 0xff);
-        Status = WriteBeforeRead(I2cInfo, 1,I2CWAddr);
-        if(EFI_ERROR(Status))
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_ABORTED;
-        }
-    }
-
-
-    I2C_SetTarget(I2cInfo->Socket,I2cInfo->Port,I2cInfo->SlaveDeviceAddress);
-    usTotalLen = ulRxLen;
-    BytesLeft = usTotalLen;
-
-    for(ulCnt = 0; ulCnt < BytesLeft; ulCnt++) {
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, I2C_READ_SIGNAL);
-    }
-
-
-    for(ulCnt = 0; ulCnt < BytesLeft; ulCnt++) {
-        ulTimes = 0;
-        do {
-            I2C_Delay(2);
-
-            while(++ulTimes > I2C_READ_TIMEOUT) {
-                (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-                return EFI_TIMEOUT;
-            }
-            ulFifo = I2C_GetRxStatus(I2cInfo->Socket,I2cInfo->Port);
-        }while(0 == ulFifo);
-
-        I2C_REG_READ(Base + I2C_DATA_CMD_OFFSET, pBuf[Idx++]);
-    }
-    (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-
-    return EFI_SUCCESS;
+  UINT32      Count;
+  UINT16      TotalLen = 0;
+  UINT32      Fifo;
+  UINT32      Times = 0;
+  UINT8       I2CWAddr[4];
+  EFI_STATUS  Status;
+  UINT32      BytesLeft;
+  UINT32      Idx = 0;
+  UINTN       Base;
+
+  if (I2cInfo->Port >= I2C_PORT_MAX) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  (VOID)I2C_Enable (I2cInfo->Socket, I2cInfo->Port);
+  Base = GetI2cBase (I2cInfo->Socket, I2cInfo->Port);
+  if (I2cInfo->DeviceType == DEVICE_TYPE_E2PROM) {
+    I2CWAddr[0] = (InfoOffset >> 8) & 0xff;
+    I2CWAddr[1] = (InfoOffset & 0xff);
+    Status = WriteBeforeRead (I2cInfo, 2,I2CWAddr);
+    if (EFI_ERROR (Status)) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_ABORTED;
+    }
+  } else if (I2cInfo->DeviceType == DEVICE_TYPE_CPLD_3BYTE_OPERANDS) {
+    I2CWAddr[0] = (InfoOffset >> 16) & 0xff;
+    I2CWAddr[1] = (InfoOffset >> 8) & 0xff;
+    I2CWAddr[2] = (InfoOffset & 0xff);
+    Status = WriteBeforeRead (I2cInfo, 3, I2CWAddr);
+    if (EFI_ERROR (Status)) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_ABORTED;
+    }
+  } else if (I2cInfo->DeviceType == DEVICE_TYPE_CPLD_4BYTE_OPERANDS) {
+    I2CWAddr[0] = (InfoOffset >> 24) & 0xff;
+    I2CWAddr[1] = (InfoOffset >> 16) & 0xff;
+    I2CWAddr[2] = (InfoOffset >> 8) & 0xff;
+    I2CWAddr[3] = (InfoOffset & 0xff);
+    Status = WriteBeforeRead (I2cInfo, 4,I2CWAddr);
+    if (EFI_ERROR (Status)) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_ABORTED;
+    }
+  } else {
+    I2CWAddr[0] = (InfoOffset & 0xff);
+    Status = WriteBeforeRead (I2cInfo, 1,I2CWAddr);
+    if (EFI_ERROR (Status)) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_ABORTED;
+    }
+  }
+
+  I2C_SetTarget(I2cInfo->Socket, I2cInfo->Port, I2cInfo->SlaveDeviceAddress);
+  TotalLen = RxLen;
+  BytesLeft = TotalLen;
+
+  for (Count = 0; Count < BytesLeft; Count++) {
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, I2C_READ_SIGNAL);
+  }
+
+  for (Count = 0; Count < BytesLeft; Count++) {
+    Times = 0;
+    do {
+      I2C_Delay (2);
+
+      while (++Times > I2C_READ_TIMEOUT) {
+        (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+        return EFI_TIMEOUT;
+      }
+      Fifo = I2C_GetRxStatus (I2cInfo->Socket, I2cInfo->Port);
+    } while (Fifo == 0);
+
+    I2C_REG_READ (Base + I2C_DATA_CMD_OFFSET, pBuf[Idx++]);
+  }
+  (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+
+  return EFI_SUCCESS;
 }
 
 EFI_STATUS
 EFIAPI
-I2CWriteMultiByte(I2C_DEVICE *I2cInfo, UINT32 InfoOffset, UINT32 ulLength, UINT8 *pBuf)
+I2CWriteMultiByte(
+  I2C_DEVICE *I2cInfo,
+  UINT32     InfoOffset,
+  UINT32     Length,
+  UINT8      *pBuf
+  )
 {
-    UINT32 ulFifo;
-    UINT32 ulTimes = 0;
-    UINT32  Idx;
-    UINTN  Base;
-
-
-    if(I2cInfo->Port >= I2C_PORT_MAX)
-    {
-        return EFI_INVALID_PARAMETER;
-    }
-
-    Base = GetI2cBase(I2cInfo->Socket, I2cInfo->Port);
-
-    (VOID)I2C_Enable(I2cInfo->Socket, I2cInfo->Port);
-
-    I2C_SetTarget(I2cInfo->Socket,I2cInfo->Port,I2cInfo->SlaveDeviceAddress);
-
-    ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    while(0 != ulFifo)
-    {
-        I2C_Delay(2);
-        if(++ulTimes > I2C_READ_TIMEOUT)
-        {
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_TIMEOUT;
-        }
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    }
-
-
-    if(I2cInfo->DeviceType == DEVICE_TYPE_CPLD_3BYTE_OPERANDS)
-    {
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 16) & 0xff);
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 8) & 0xff);
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, InfoOffset & 0xff);
-    }
-
-    else if(I2cInfo->DeviceType == DEVICE_TYPE_CPLD_4BYTE_OPERANDS)
-    {
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 24) & 0xff);
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 16) & 0xff);
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 8) & 0xff);
-        I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, InfoOffset & 0xff);
-    }
-
-    else
-    {
-
-    }
-
-    ulTimes = 0;
-    for(Idx = 0; Idx < ulLength; Idx++)
-    {
-
-       I2C_REG_WRITE(Base + I2C_DATA_CMD_OFFSET, *pBuf++);
-
-    }
-
-    ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    ulTimes = 0;
-    while(0 != ulFifo)
-    {
-        I2C_Delay(2);
-
-        if(++ulTimes > I2C_READ_TIMEOUT)
-        {
-            DEBUG ((EFI_D_ERROR, "I2C Write try to finished,time out!\n"));
-            (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-            return EFI_TIMEOUT;
-        }
-        ulFifo = I2C_GetTxStatus(I2cInfo->Socket,I2cInfo->Port);
-    }
-    (VOID)I2C_Disable(I2cInfo->Socket, I2cInfo->Port);
-
-    return EFI_SUCCESS;
+  UINT32 Fifo;
+  UINT32 Times = 0;
+  UINT32  Idx;
+  UINTN  Base;
+
+  if (I2cInfo->Port >= I2C_PORT_MAX) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  Base = GetI2cBase (I2cInfo->Socket, I2cInfo->Port);
+
+  (VOID)I2C_Enable(I2cInfo->Socket, I2cInfo->Port);
+
+  I2C_SetTarget(I2cInfo->Socket, I2cInfo->Port, I2cInfo->SlaveDeviceAddress);
+
+  Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  while (0 != Fifo) {
+    I2C_Delay (2);
+    if (++Times > I2C_READ_TIMEOUT) {
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_TIMEOUT;
+    }
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
+
+  if (I2cInfo->DeviceType == DEVICE_TYPE_CPLD_3BYTE_OPERANDS) {
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 16) & 0xff);
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 8) & 0xff);
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, InfoOffset & 0xff);
+  } else if (I2cInfo->DeviceType == DEVICE_TYPE_CPLD_4BYTE_OPERANDS) {
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 24) & 0xff);
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 16) & 0xff);
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, (InfoOffset >> 8) & 0xff);
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, InfoOffset & 0xff);
+  } else {
+  }
+
+  Times = 0;
+  for (Idx = 0; Idx < Length; Idx++) {
+    I2C_REG_WRITE (Base + I2C_DATA_CMD_OFFSET, *pBuf++);
+  }
+
+  Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  Times = 0;
+  while (Fifo != 0) {
+    I2C_Delay (2);
+
+    if (++Times > I2C_READ_TIMEOUT) {
+      DEBUG ((DEBUG_ERROR, "I2C Write try to finished,time out!\n"));
+      (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+      return EFI_TIMEOUT;
+    }
+    Fifo = I2C_GetTxStatus (I2cInfo->Socket, I2cInfo->Port);
+  }
+  (VOID)I2C_Disable (I2cInfo->Socket, I2cInfo->Port);
+
+  return EFI_SUCCESS;
 }
 
-- 
2.17.0



  parent reply	other threads:[~2018-08-14  8:10 UTC|newest]

Thread overview: 93+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2018-08-14  8:08 [PATCH edk2-platforms v2 00/43] Upload for D06 platform Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 01/43] Silicon/Hisilicon: Modify the MRC interface for other module Ming Huang
2018-08-21 17:50   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 02/43] Silicon/Hisilicon: Separate PlatformArch.h Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 03/43] Silicon/Hisilicon/Acpi: Move some macro to PlatformArch.h Ming Huang
2018-08-17 13:23   ` Leif Lindholm
2018-08-18  7:26     ` Ming
2018-08-14  8:08 ` [PATCH edk2-platforms v2 04/43] Silicon/Hisilicon/D0x: Move dimm size definition " Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 05/43] Silicon/Hisilicon/D0x: Move RAS macro " Ming Huang
2018-08-21 17:48   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 06/43] Hisilicon/D0x: Move CustomData.Fv to common path of Hisilicon Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 07/43] Hisilicon/D0x: Move IpmiCmdLib " Ming Huang
2018-08-15 13:58   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 08/43] Hisilicon/D0x: Unify FlashFvbDxe driver Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 09/43] Hisilicon/D0X: Rename the global variable gDS3231RtcDevice Ming Huang
2018-08-21 17:59   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 10/43] Hisilicon/D06: Add several base file for D06 Ming Huang
2018-08-21 21:56   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 11/43] Platform/Hisilicon/D06: Add M41T83RealTimeClockLib Ming Huang
2018-08-21 22:57   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 12/43] Platform/Hisilicon/D06: Add edk2-non-osi components for D06 Ming Huang
2018-08-22  9:49   ` Leif Lindholm
2018-08-22 14:54     ` Ming
2018-08-22 16:43       ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 13/43] Hisilicon/D06: Add OemMiscLibD06 Ming Huang
2018-08-22 10:17   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 14/43] Silicon/Hisilicon/D06: Wait for all disk ready Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 15/43] Silicon/Hisilicon/Acpi: Unify HisiAcipPlatformDxe Ming Huang
2018-08-22 10:29   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 16/43] Hisilicon/D06: Add Debug Serial Port Init Driver Ming Huang
2018-08-22 11:01   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 17/43] Hisilicon/D06: Add ACPI Tables for D06 Ming Huang
2018-08-22 11:49   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 18/43] Hisilicon/D06: Add Hi1620OemConfigUiLib Ming Huang
2018-08-22 14:14   ` Leif Lindholm
2018-08-22 15:11     ` Ming
2018-08-14  8:08 ` [PATCH edk2-platforms v2 19/43] Silicon/Hisilicon/D06: Stop watchdog Ming Huang
2018-08-22 14:17   ` Leif Lindholm
2018-08-14  8:08 ` Ming Huang [this message]
2018-08-14  8:08 ` [PATCH edk2-platforms v2 21/43] Silicon/Hisilicon/I2C: Refactor I2C library Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 22/43] Silicon/Hisilicon/D06: Fix I2C enable fail issue for D06 Ming Huang
2018-08-22 14:21   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 23/43] Silicon/Hisilicon/D06: Add I2C delay for HNS auto config Ming Huang
2018-08-22 14:27   ` Leif Lindholm
2018-08-22 15:16     ` Ming
2018-08-22 16:46       ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 24/43] Hisilicon/I2C: Fix a typo issue Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 25/43] Silicon/Hisilicon/D06: Optimize HNS config CDR post time Ming Huang
2018-08-22 14:30   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 26/43] Silicon/Hisilicon/Setup: Add Setup Item "EnableGOP" Ming Huang
2018-08-22 14:33   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 27/43] Hisilicon/Hi1620: Add ACPI PPTT table Ming Huang
2018-08-22 14:39   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 28/43] Platform/Hisilicon/D06: Enable ACPI PPTT Ming Huang
2018-08-22 14:40   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 29/43] Platform/Hisilicon/D06: Add OemNicLib Ming Huang
2018-08-14  8:08 ` [PATCH edk2-platforms v2 30/43] Platform/Hisilicon/D06: Add OemNicConfig2P Driver Ming Huang
2018-08-22 14:57   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 31/43] Hisilicon/D0x: Update SMBIOS type9 info Ming Huang
2018-08-22 15:01   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 32/43] Platform/Hisilicon/D06: Add EarlyConfigPeim peim Ming Huang
2018-08-22 15:04   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 33/43] Platform/Hisilicon/D06: Add PciHostBridgeLib Ming Huang
2018-08-22 15:09   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 34/43] Hisilicon/D06: add apei driver Ming Huang
2018-08-22 15:31   ` Leif Lindholm
2018-08-23  7:35     ` Ming
2018-08-23  9:43       ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 35/43] Silicon/Hisilicon/D06: Add some Lpc macro to LpcLib.h Ming Huang
2018-08-22 15:33   ` Leif Lindholm
2018-08-23  7:39     ` Ming
2018-08-23  9:44       ` Leif Lindholm
2018-08-23  9:51         ` Ming
2018-08-14  8:08 ` [PATCH edk2-platforms v2 36/43] Platform/Hisilicon/D06: Add capsule upgrade support Ming Huang
2018-08-22 18:42   ` Leif Lindholm
2018-08-24 14:43     ` Ard Biesheuvel
2018-08-14  8:08 ` [PATCH edk2-platforms v2 37/43] Silicon/Hisilicon/D06: Modify for close slave core clock Ming Huang
2018-08-22 15:44   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 38/43] Silicon/Hisilicon/D06: Add I2C Bus Exception handle function Ming Huang
2018-08-22 15:45   ` Leif Lindholm
2018-08-14  8:08 ` [PATCH edk2-platforms v2 39/43] Silicon/Hisilicon/Setup: Support SPCR table switch Ming Huang
2018-08-23  9:54   ` Ming
2018-08-23  9:57     ` Leif Lindholm
2018-08-14  8:09 ` [PATCH edk2-platforms v2 40/43] Silicon/Hisilicon/setup: Support SMMU switch Ming Huang
2018-08-22 18:42   ` Leif Lindholm
2018-08-14  8:09 ` [PATCH edk2-platforms v2 41/43] Hisilicon/D06: Add PciPlatformLib Ming Huang
2018-08-22 16:12   ` Leif Lindholm
2018-08-14  8:09 ` [PATCH edk2-platforms v2 42/43] Hisilicon/D06: Add edk2-non-osi Shell components Ming Huang
2018-08-22 18:48   ` Leif Lindholm
2018-08-23  8:37     ` Ming
2018-08-14  8:09 ` [PATCH edk2-platforms v2 43/43] Platform/Hisilicon/D0x: Update version string to 18.08 Ming Huang
2018-08-22 16:09   ` Leif Lindholm
2018-08-22 18:49 ` [PATCH edk2-platforms v2 00/43] Upload for D06 platform Leif Lindholm

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-list from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=20180814080903.50466-21-ming.huang@linaro.org \
    --to=devel@edk2.groups.io \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox