/** @file
|
*
|
* Copyright (c) 2017, Rockchip Inc. All rights reserved.
|
*
|
* This program and the accompanying materials
|
* are licensed and made available under the terms and conditions of the BSD License
|
* which accompanies this distribution. The full text of the license may be found at
|
* http://opensource.org/licenses/bsd-license.php
|
*
|
* THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
* WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
*
|
**/
|
|
#include <PiDxe.h>
|
#include <Library/DebugLib.h>
|
#include <Library/UefiBootServicesTableLib.h>
|
#include <Library/ArmLib.h>
|
#include <Library/BaseLib.h>
|
#include <Library/TimerLib.h>
|
#include <Library/IoLib.h>
|
|
#include <Library/I2CLib.h>
|
|
/* i2c timerout */
|
#define I2C_TIMEOUT_US 100000 // 100000us = 100ms
|
#define I2C_RETRY_COUNT 3
|
|
/* i2c error return code */
|
#define I2C_OK 0
|
#define I2C_ERROR_TIMEOUT -1
|
#define I2C_ERROR_NOACK -2
|
#define I2C_ERROR_IO -3
|
|
/* rk i2c fifo max transfer bytes */
|
#define RK_I2C_FIFO_SIZE 32
|
|
/* rk i2c device register size */
|
#define RK_I2C_REGISTER_SIZE 3
|
|
#define RK_CEIL(x, y) \
|
({ unsigned long __x = (x), __y = (y); (__x + __y - 1) / __y; })
|
|
#define I2C_ADAP_SEL_BIT(nr) ((nr) + 11)
|
#define I2C_ADAP_SEL_MASK(nr) ((nr) + 27)
|
|
/* Control register */
|
#define I2C_CON 0x000
|
#define I2C_CON_EN (1 << 0)
|
#define I2C_CON_MOD(mod) ((mod) << 1)
|
#define I2C_MODE_TX 0x00
|
#define I2C_MODE_TRX 0x01
|
#define I2C_MODE_RX 0x02
|
#define I2C_MODE_RRX 0x03
|
#define I2C_CON_MASK (3 << 1)
|
|
#define I2C_CON_START (1 << 3)
|
#define I2C_CON_STOP (1 << 4)
|
#define I2C_CON_LASTACK (1 << 5)
|
#define I2C_CON_ACTACK (1 << 6)
|
|
/* Clock dividor register */
|
#define I2C_CLKDIV 0x004
|
#define I2C_CLKDIV_VAL(divl, divh) (((divl) & 0xffff) | (((divh) << 16) & 0xffff0000))
|
|
/* the slave address accessed for master rx mode */
|
#define I2C_MRXADDR 0x008
|
#define I2C_MRXADDR_SET(vld, addr) (((vld) << 24) | (addr))
|
|
/* the slave register address accessed for master rx mode */
|
#define I2C_MRXRADDR 0x00c
|
#define I2C_MRXRADDR_SET(vld, raddr) (((vld) << 24) | (raddr))
|
|
/* master tx count */
|
#define I2C_MTXCNT 0x010
|
|
/* master rx count */
|
#define I2C_MRXCNT 0x014
|
|
/* interrupt enable register */
|
#define I2C_IEN 0x018
|
#define I2C_BTFIEN (1 << 0)
|
#define I2C_BRFIEN (1 << 1)
|
#define I2C_MBTFIEN (1 << 2)
|
#define I2C_MBRFIEN (1 << 3)
|
#define I2C_STARTIEN (1 << 4)
|
#define I2C_STOPIEN (1 << 5)
|
#define I2C_NAKRCVIEN (1 << 6)
|
|
/* interrupt pending register */
|
#define I2C_IPD 0x01c
|
#define I2C_BTFIPD (1 << 0)
|
#define I2C_BRFIPD (1 << 1)
|
#define I2C_MBTFIPD (1 << 2)
|
#define I2C_MBRFIPD (1 << 3)
|
#define I2C_STARTIPD (1 << 4)
|
#define I2C_STOPIPD (1 << 5)
|
#define I2C_NAKRCVIPD (1 << 6)
|
#define I2C_IPD_ALL_CLEAN 0x7f
|
|
/* finished count */
|
#define I2C_FCNT 0x020
|
|
/* I2C tx data register */
|
#define I2C_TXDATA_BASE 0X100
|
|
/* I2C rx data register */
|
#define I2C_RXDATA_BASE 0x200
|
|
/* register io */
|
#define I2CRegReadl(addr) MmioRead32(addr)
|
#define I2CRegWritel(val, addr) MmioWrite32(addr, val)
|
|
/* Get pll rate by id */
|
#define FRAC_MODE 0
|
#define MHZ (1000*1000)
|
static UINT32
|
RkClkPllGetRate (
|
enum RkPllsId pll_id
|
)
|
{
|
UINT32 Con, PllCon0, PllCon1, PllCon2, Dsmp;
|
|
if (pll_id == PPLL_ID) {
|
Con = PmuCruReadl(PMUCRU_PLL_CON(0, 3)) & PLL_MODE_MSK;
|
PllCon0 = PmuCruReadl(PMUCRU_PLL_CON(0, 0));
|
PllCon1 = PmuCruReadl(PMUCRU_PLL_CON(0, 1));
|
PllCon2 = PmuCruReadl(PMUCRU_PLL_CON(0, 2));
|
Dsmp = PLL_GET_DSMPD(PmuCruReadl(PMUCRU_PLL_CON(0, 3)));
|
} else {
|
Con = CruReadl(CRU_PLL_CON(pll_id, 3)) & PLL_MODE_MSK;
|
PllCon0 = CruReadl(CRU_PLL_CON(pll_id, 0));
|
PllCon1 = CruReadl(CRU_PLL_CON(pll_id, 1));
|
PllCon2 = CruReadl(CRU_PLL_CON(pll_id, 2));
|
Dsmp = PLL_GET_DSMPD(CruReadl(CRU_PLL_CON(pll_id, 3)));
|
}
|
|
if (Con == PLL_MODE_SLOW) { /* slow mode */
|
return 24 * MHZ;
|
} else if (Con == PLL_MODE_NORM) { /* normal mode */
|
UINT32 Rate = 0, FracRate64 = 0;
|
|
/* integer mode */
|
Rate = (UINT32)(24) * PLL_GET_FBDIV(PllCon0);
|
Rate = Rate / PLL_GET_REFDIV(PllCon1);
|
if (FRAC_MODE == Dsmp) {
|
/* fractional mode */
|
FracRate64 = (UINT32)(24) * PLL_GET_FRAC(PllCon2);
|
FracRate64 = FracRate64 / PLL_GET_REFDIV(PllCon1);
|
Rate += FracRate64 >> 24;
|
}
|
Rate = Rate / PLL_GET_POSTDIV1(PllCon1);
|
Rate = Rate / PLL_GET_POSTDIV2(PllCon1);
|
return Rate * MHZ;
|
} else { /* deep slow mode */
|
return 32768;
|
}
|
}
|
|
static UINT32
|
RkClkGetI2CClk (
|
UINT32 BusId
|
)
|
{
|
UINT32 Con = 0;
|
UINT32 Div = 1;
|
UINT32 PmuPll;
|
|
PmuPll = RkClkPllGetRate(PPLL_ID);
|
if (BusId == 0) {
|
Con = PmuCruReadl(PMUCRU_CLKSELS_CON(2));
|
Div = ((Con >> 0) & 0x7F) + 1;
|
} else if (BusId == 4) {
|
Con = PmuCruReadl(PMUCRU_CLKSELS_CON(3));
|
Div = ((Con >> 0) & 0x7F) + 1;
|
} else if (BusId == 8) {
|
Con = PmuCruReadl(PMUCRU_CLKSELS_CON(2));
|
Div = ((Con >> 8) & 0x7F) + 1;
|
}
|
|
return (UINT32)(PmuPll / Div);
|
}
|
|
static void
|
RkI2CGetDiv (
|
UINT32 Div,
|
UINT32 *Divh,
|
UINT32 *Divl
|
)
|
{
|
if (Div % 2 == 0) {
|
*Divh = Div / 2;
|
*Divl = Div / 2;
|
} else {
|
*Divh = RK_CEIL(Div, 2);
|
*Divl = Div / 2;
|
}
|
}
|
|
EFI_STATUS
|
RkI2CSetClk (
|
UINT32 BusId,
|
UINT32 SclRate
|
)
|
{
|
UINT32 I2CRate;
|
UINT32 Div, Divl, Divh;
|
struct RkI2CInfo *I2CInfo = (struct RkI2CInfo *)RkI2CGetBase(BusId);
|
|
if (I2CInfo->Speed == SclRate) {
|
return EFI_SUCCESS;
|
}
|
/* First get i2c rate from pclk */
|
I2CRate = RkClkGetI2CClk(BusId);
|
|
Div = RK_CEIL(I2CRate, SclRate * 8) - 2;
|
if (Div < 0) {
|
Divh = Divl = 0;
|
} else {
|
RkI2CGetDiv(Div, &Divh, &Divl);
|
}
|
I2CRegWritel(I2C_CLKDIV_VAL(Divl, Divh), I2CInfo->Regs + I2C_CLKDIV);
|
|
I2CInfo->Speed = SclRate;
|
|
DEBUG ((EFI_D_VERBOSE, "RkI2CSetClk: i2c rate = %d, scl rate = %d\n", I2CRate, SclRate));
|
DEBUG ((EFI_D_VERBOSE, "set i2c clk div = %d, divh = %d, divl = %d\n", Div, Divh, Divl));
|
DEBUG ((EFI_D_VERBOSE, "set clk(I2C_CLKDIV: 0x%08x)\n", I2CRegReadl(I2CInfo->Regs + I2C_CLKDIV)));
|
|
return EFI_SUCCESS;
|
}
|
|
EFI_STATUS
|
RkI2CIomux (
|
enum RkI2CBusID BusId
|
)
|
{
|
if (BusId == I2C_CH0) {
|
MmioWrite32(RK3399_PMU_GRF_BASE + PMU_GRF_GPIO1B_IOMUX, (3 << 30) | (2 << 14));
|
MmioWrite32(RK3399_PMU_GRF_BASE + PMU_GRF_GPIO1C_IOMUX, (3 << 16) | (2 << 0));
|
} else {
|
DEBUG ((EFI_D_ERROR, "I2C iomux error, PLS check i2c config!\n"));
|
return EFI_LOAD_ERROR;
|
}
|
|
return EFI_SUCCESS;
|
}
|
|
EFI_STATUS
|
RkI2CInit (
|
UINT32 BusId,
|
UINT32 Speed
|
)
|
{
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
Status = RkI2CIomux(BusId);
|
if(EFI_ERROR (Status)){
|
goto EXIT;
|
}
|
|
Status = RkI2CSetClk(BusId, Speed);
|
if(EFI_ERROR (Status)){
|
goto EXIT;
|
}
|
|
EXIT:
|
return Status;
|
}
|
|
EFI_STATUS
|
RkI2CSendStartBit (
|
struct RkI2CInfo *I2CInfo
|
)
|
{
|
UINT32 TimeOut = I2C_TIMEOUT_US;
|
|
DEBUG ((EFI_D_VERBOSE, "I2c Send Start bit.\n"));
|
I2CRegWritel(I2C_IPD_ALL_CLEAN, I2CInfo->Regs + I2C_IPD);
|
|
I2CRegWritel(I2C_CON_EN | I2C_CON_START, I2CInfo->Regs + I2C_CON);
|
I2CRegWritel(I2C_STARTIEN, I2CInfo->Regs + I2C_IEN);
|
|
while (TimeOut--) {
|
if (I2CRegReadl(I2CInfo->Regs + I2C_IPD) & I2C_STARTIPD) {
|
I2CRegWritel(I2C_STARTIPD, I2CInfo->Regs + I2C_IPD);
|
break;
|
}
|
MicroSecondDelay(1);
|
}
|
if (TimeOut <= 0) {
|
DEBUG ((EFI_D_ERROR, "I2C Send Start Bit Timeout\n"));
|
return EFI_LOAD_ERROR;
|
}
|
|
return EFI_SUCCESS;
|
}
|
|
EFI_STATUS
|
RkI2CSendStopBit (
|
struct RkI2CInfo *I2CInfo
|
)
|
{
|
int TimeOut = I2C_TIMEOUT_US;
|
|
DEBUG ((EFI_D_VERBOSE, "I2c Send Stop bit.\n"));
|
I2CRegWritel(I2C_IPD_ALL_CLEAN, I2CInfo->Regs + I2C_IPD);
|
|
I2CRegWritel(I2C_CON_EN | I2C_CON_STOP, I2CInfo->Regs + I2C_CON);
|
I2CRegWritel(I2C_CON_STOP, I2CInfo->Regs + I2C_IEN);
|
|
while (TimeOut--) {
|
if (I2CRegReadl(I2CInfo->Regs + I2C_IPD) & I2C_STOPIPD) {
|
I2CRegWritel(I2C_STOPIPD, I2CInfo->Regs + I2C_IPD);
|
break;
|
}
|
MicroSecondDelay(1);
|
}
|
|
if (TimeOut <= 0) {
|
DEBUG ((EFI_D_ERROR, "I2C Send Stop Bit Timeout\n"));
|
return EFI_LOAD_ERROR;
|
}
|
|
return EFI_SUCCESS;
|
}
|
|
EFI_STATUS
|
RkI2CDisable (
|
struct RkI2CInfo *i2c
|
)
|
{
|
I2CRegWritel(0, i2c->Regs + I2C_CON);
|
|
return EFI_SUCCESS;
|
}
|
|
EFI_STATUS
|
RkI2CWrite (
|
struct RkI2CInfo *I2CInfo,
|
UINT8 Chip,
|
UINT32 Reg,
|
UINT32 RLen,
|
UINT8 *Buf,
|
UINT32 BLen
|
)
|
{
|
EFI_STATUS Status = EFI_SUCCESS;
|
int TimeOut = I2C_TIMEOUT_US;
|
UINT8 *PBuf = Buf;
|
UINT32 BytesRemainLen = BLen + RLen + 1;
|
UINT32 BytesTranferedLen = 0;
|
UINT32 WordsTranferedLen = 0;
|
UINT32 TxData;
|
UINT32 i, j;
|
|
DEBUG ((EFI_D_VERBOSE, "RkI2CWrite: chip = %d, reg = %d, r_len = %d, b_len = %d\n", Chip, Reg, RLen, BLen));
|
|
Status = RkI2CSendStartBit(I2CInfo);
|
if(EFI_ERROR (Status)){
|
goto EXIT;
|
}
|
|
while (BytesRemainLen) {
|
if (BytesRemainLen > RK_I2C_FIFO_SIZE) {
|
BytesTranferedLen = 32;
|
} else {
|
BytesTranferedLen = BytesRemainLen;
|
}
|
WordsTranferedLen = RK_CEIL(BytesTranferedLen, 4);
|
|
for (i = 0; i < WordsTranferedLen; i++) {
|
TxData = 0;
|
for (j = 0; j < 4; j++) {
|
if ((i * 4 + j) == BytesTranferedLen) {
|
break;
|
}
|
|
if (i == 0 && j == 0) {
|
TxData |= (Chip << 1);
|
} else if (i == 0 && j <= RLen) {
|
TxData |= (Reg & (0xff << ((j - 1) * 8))) << 8;
|
} else {
|
TxData |= (*PBuf++)<<(j * 8);
|
}
|
I2CRegWritel(TxData, I2CInfo->Regs + I2C_TXDATA_BASE + i * 4);
|
}
|
DEBUG ((EFI_D_VERBOSE, "I2c Write TXDATA[%d] = 0x%x\n", i, TxData));
|
}
|
|
I2CRegWritel(I2C_CON_EN | I2C_CON_MOD(I2C_MODE_TX), I2CInfo->Regs + I2C_CON);
|
I2CRegWritel(BytesTranferedLen, I2CInfo->Regs + I2C_MTXCNT);
|
I2CRegWritel(I2C_MBTFIEN | I2C_NAKRCVIEN, I2CInfo->Regs + I2C_IEN);
|
|
TimeOut = I2C_TIMEOUT_US;
|
while (TimeOut--) {
|
if (I2CRegReadl(I2CInfo->Regs + I2C_IPD) & I2C_NAKRCVIPD) {
|
I2CRegWritel(I2C_NAKRCVIPD, I2CInfo->Regs + I2C_IPD);
|
}
|
if (I2CRegReadl(I2CInfo->Regs + I2C_IPD) & I2C_MBTFIPD) {
|
I2CRegWritel(I2C_MBTFIPD, I2CInfo->Regs + I2C_IPD);
|
break;
|
}
|
MicroSecondDelay(1);
|
}
|
|
if (TimeOut <= 0) {
|
DEBUG ((EFI_D_ERROR, "I2C Write Data Timeout\n"));
|
Status = EFI_LOAD_ERROR;
|
goto EXIT;
|
|
}
|
|
BytesRemainLen -= BytesTranferedLen;
|
DEBUG ((EFI_D_VERBOSE, "I2C Write bytes_remain_len %d\n", BytesRemainLen));
|
}
|
|
EXIT:
|
// Send stop bit
|
RkI2CSendStopBit(I2CInfo);
|
// Disable Controller
|
RkI2CDisable(I2CInfo);
|
|
return Status;
|
}
|
|
EFI_STATUS
|
RkI2CRead (
|
struct RkI2CInfo *I2CInfo,
|
UINT8 Chip,
|
UINT32 Reg,
|
UINT32 RLen,
|
UINT8 *Buf,
|
UINT32 BLen
|
)
|
{
|
EFI_STATUS Status = EFI_SUCCESS;
|
int TimeOut = I2C_TIMEOUT_US;
|
UINT8 *PBuf = Buf;
|
UINT32 BytesRemainLen = BLen;
|
UINT32 BytesTranferedLen = 0;
|
UINT32 WordsTranferedLen = 0;
|
UINT32 Con = 0;
|
UINT32 RxData;
|
UINT32 i, j;
|
|
DEBUG ((EFI_D_VERBOSE, "RkI2CRead: Chip = %d, Reg = %d, RLen = %d, BLen = %d\n", Chip, Reg, RLen, BLen));
|
Status = RkI2CSendStartBit(I2CInfo);
|
if(EFI_ERROR (Status)){
|
goto EXIT;
|
}
|
|
I2CRegWritel(I2C_MRXADDR_SET(1, Chip << 1 | 1), I2CInfo->Regs + I2C_MRXADDR);
|
if (RLen == 0) {
|
I2CRegWritel(0, I2CInfo->Regs + I2C_MRXRADDR);
|
} else if (RLen < 4) {
|
I2CRegWritel(I2C_MRXRADDR_SET(RLen, Reg), I2CInfo->Regs + I2C_MRXRADDR);
|
} else {
|
DEBUG ((EFI_D_ERROR, "I2C Read: addr len %d not supported\n", RLen));
|
Status = EFI_LOAD_ERROR;
|
goto EXIT;
|
}
|
|
while (BytesRemainLen) {
|
if (BytesRemainLen > RK_I2C_FIFO_SIZE) {
|
Con = I2C_CON_EN | I2C_CON_MOD(I2C_MODE_TRX);
|
BytesTranferedLen = 32;
|
} else {
|
Con = I2C_CON_EN | I2C_CON_MOD(I2C_MODE_TRX) | I2C_CON_LASTACK;
|
BytesTranferedLen = BytesRemainLen;
|
}
|
WordsTranferedLen = RK_CEIL(BytesTranferedLen, 4);
|
|
I2CRegWritel(Con, I2CInfo->Regs + I2C_CON);
|
I2CRegWritel(BytesTranferedLen, I2CInfo->Regs + I2C_MRXCNT);
|
I2CRegWritel(I2C_MBRFIEN | I2C_NAKRCVIEN, I2CInfo->Regs + I2C_IEN);
|
|
TimeOut = I2C_TIMEOUT_US;
|
while (TimeOut--) {
|
if (I2CRegReadl(I2CInfo->Regs + I2C_IPD) & I2C_NAKRCVIPD) {
|
I2CRegWritel(I2C_NAKRCVIPD, I2CInfo->Regs + I2C_IPD);
|
}
|
if (I2CRegReadl(I2CInfo->Regs + I2C_IPD) & I2C_MBRFIPD) {
|
I2CRegWritel(I2C_MBRFIPD, I2CInfo->Regs + I2C_IPD);
|
break;
|
}
|
MicroSecondDelay(1);
|
}
|
|
if (TimeOut <= 0) {
|
DEBUG ((EFI_D_ERROR, "I2C Read Data Timeout\n"));
|
Status = EFI_LOAD_ERROR;
|
goto EXIT;
|
}
|
|
for (i = 0; i < WordsTranferedLen; i++) {
|
RxData = I2CRegReadl(I2CInfo->Regs + I2C_RXDATA_BASE + i * 4);
|
DEBUG ((EFI_D_VERBOSE, "I2c Read RXDATA[%d] = 0x%x\n", i, RxData));
|
for (j = 0; j < 4; j++) {
|
if ((i * 4 + j) == BytesTranferedLen) {
|
break;
|
}
|
*PBuf++ = (RxData >> (j * 8)) & 0xff;
|
}
|
}
|
BytesRemainLen -= BytesTranferedLen;
|
DEBUG ((EFI_D_VERBOSE, "I2C Read bytes_remain_len %d\n", BytesRemainLen));
|
}
|
|
EXIT:
|
// Send stop bit
|
RkI2CSendStopBit(I2CInfo);
|
// Disable Controller
|
RkI2CDisable(I2CInfo);
|
|
return Status;
|
}
|
|
EFI_STATUS
|
EFIAPI
|
I2CWrite (
|
UINT32 BusId,
|
UINT8 Chip,
|
UINT32 Addr,
|
UINT32 Alen,
|
UINT8 *Buf,
|
UINT32 Len
|
)
|
{
|
EFI_STATUS Status = EFI_SUCCESS;
|
struct RkI2CInfo *I2CInfo = (struct RkI2CInfo *)RkI2CGetBase(BusId);
|
|
if (I2CInfo == NULL) {
|
return -1;
|
}
|
if ((Buf == NULL) && (Len != 0)) {
|
DEBUG ((EFI_D_ERROR, "I2CWrite: buf == NULL\n"));
|
return -2;
|
}
|
|
Status = RkI2CWrite(I2CInfo, Chip, Addr, Alen, Buf, Len);
|
if(EFI_ERROR (Status)){
|
goto EXIT;
|
}
|
|
EXIT:
|
return Status;
|
}
|
|
EFI_STATUS
|
EFIAPI
|
I2CRead (
|
UINT32 BusId,
|
UINT8 Chip,
|
UINT32 Addr,
|
UINT32 Alen,
|
UINT8 *Buf,
|
UINT32 Len)
|
{
|
EFI_STATUS Status = EFI_SUCCESS;
|
struct RkI2CInfo *I2CInfo = (struct RkI2CInfo *)RkI2CGetBase(BusId);
|
|
if (I2CInfo == NULL) {
|
return EFI_LOAD_ERROR;
|
}
|
if ((Buf == NULL) && (Len != 0)) {
|
DEBUG ((EFI_D_ERROR, "I2CRead: buf == NULL\n"));
|
return EFI_LOAD_ERROR;
|
}
|
|
Status = RkI2CRead(I2CInfo, Chip, Addr, Alen, Buf, Len);
|
if(EFI_ERROR (Status)){
|
goto EXIT;
|
}
|
|
EXIT:
|
return Status;
|
}
|
|
EFI_STATUS
|
EFIAPI
|
I2CInit(
|
UINT32 BusID,
|
UINT32 speed
|
)
|
{
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
DEBUG ((EFI_D_VERBOSE, "I2CInit\n"));
|
|
Status = RkI2CInit(BusID, speed);
|
if(EFI_ERROR (Status)){
|
goto EXIT;
|
}
|
|
Status = RkI2cLibRuntimeSetup(BusID);
|
if(EFI_ERROR (Status)){
|
goto EXIT;
|
}
|
|
EXIT:
|
return Status;
|
}
|
|
