/********************************************************************************
|
Copyright (C) 2016 Marvell International Ltd.
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
*******************************************************************************/
|
|
#include <Protocol/BoardDesc.h>
|
#include <Protocol/I2cMaster.h>
|
#include <Protocol/I2cEnumerate.h>
|
#include <Protocol/I2cBusConfigurationManagement.h>
|
#include <Protocol/DevicePath.h>
|
#include <Protocol/MvI2c.h>
|
|
#include <Library/BaseLib.h>
|
#include <Library/IoLib.h>
|
#include <Library/DebugLib.h>
|
#include <Library/PcdLib.h>
|
#include <Library/UefiLib.h>
|
#include <Library/MemoryAllocationLib.h>
|
#include <Library/UefiBootServicesTableLib.h>
|
|
#include "MvI2cDxe.h"
|
|
STATIC MV_I2C_BAUD_RATE baud_rate;
|
|
STATIC MV_I2C_DEVICE_PATH MvI2cDevicePathProtocol = {
|
{
|
{
|
HARDWARE_DEVICE_PATH,
|
HW_VENDOR_DP,
|
{
|
(UINT8)(OFFSET_OF (MV_I2C_DEVICE_PATH, End)),
|
(UINT8)(OFFSET_OF (MV_I2C_DEVICE_PATH, End) >> 8),
|
},
|
},
|
EFI_CALLER_ID_GUID
|
},
|
0, // Instance
|
{
|
END_DEVICE_PATH_TYPE,
|
END_ENTIRE_DEVICE_PATH_SUBTYPE,
|
{
|
sizeof(EFI_DEVICE_PATH_PROTOCOL),
|
0
|
}
|
}
|
};
|
|
STATIC
|
UINT32
|
I2C_READ(
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN UINTN off)
|
{
|
ASSERT (I2cMasterContext != NULL);
|
return MmioRead32 (I2cMasterContext->BaseAddress + off);
|
}
|
|
STATIC
|
EFI_STATUS
|
I2C_WRITE (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN UINTN off,
|
IN UINT32 Value)
|
{
|
ASSERT (I2cMasterContext != NULL);
|
return MmioWrite32 (I2cMasterContext->BaseAddress + off, Value);
|
}
|
|
EFI_STATUS
|
EFIAPI
|
MvI2cInitialiseController (
|
IN EFI_HANDLE ImageHandle,
|
IN EFI_SYSTEM_TABLE *SystemTable,
|
IN EFI_PHYSICAL_ADDRESS BaseAddress
|
)
|
{
|
EFI_STATUS Status;
|
I2C_MASTER_CONTEXT *I2cMasterContext;
|
STATIC INTN Bus = 0;
|
MV_I2C_DEVICE_PATH *DevicePath;
|
|
DevicePath = AllocateCopyPool (sizeof(MvI2cDevicePathProtocol),
|
&MvI2cDevicePathProtocol);
|
if (DevicePath == NULL) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: I2C device path allocation failed\n"));
|
return EFI_OUT_OF_RESOURCES;
|
}
|
DevicePath->Instance = Bus;
|
|
/* if attachment succeeds, this gets freed at ExitBootServices */
|
I2cMasterContext = AllocateZeroPool (sizeof (I2C_MASTER_CONTEXT));
|
if (I2cMasterContext == NULL) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: I2C master context allocation failed\n"));
|
return EFI_OUT_OF_RESOURCES;
|
}
|
I2cMasterContext->Signature = I2C_MASTER_SIGNATURE;
|
I2cMasterContext->I2cMaster.Reset = MvI2cReset;
|
I2cMasterContext->I2cMaster.StartRequest = MvI2cStartRequest;
|
I2cMasterContext->I2cEnumerate.Enumerate = MvI2cEnumerate;
|
I2cMasterContext->I2cBusConf.EnableI2cBusConfiguration = MvI2cEnableConf;
|
I2cMasterContext->TclkFrequency = PcdGet32 (PcdI2cClockFrequency);
|
I2cMasterContext->BaseAddress = BaseAddress;
|
I2cMasterContext->Bus = Bus;
|
/* I2cMasterContext->Lock is responsible for serializing I2C operations */
|
EfiInitializeLock(&I2cMasterContext->Lock, TPL_NOTIFY);
|
|
MvI2cCalBaudRate( I2cMasterContext,
|
PcdGet32 (PcdI2cBaudRate),
|
&baud_rate,
|
I2cMasterContext->TclkFrequency
|
);
|
|
Status = gBS->InstallMultipleProtocolInterfaces(
|
&I2cMasterContext->Controller,
|
&gEfiI2cMasterProtocolGuid,
|
&I2cMasterContext->I2cMaster,
|
&gEfiI2cEnumerateProtocolGuid,
|
&I2cMasterContext->I2cEnumerate,
|
&gEfiI2cBusConfigurationManagementProtocolGuid,
|
&I2cMasterContext->I2cBusConf,
|
&gEfiDevicePathProtocolGuid,
|
(EFI_DEVICE_PATH_PROTOCOL *) DevicePath,
|
NULL);
|
|
if (EFI_ERROR(Status)) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: Installing protocol interfaces failed!\n"));
|
goto fail;
|
}
|
DEBUG((DEBUG_ERROR, "Succesfully installed controller %d at 0x%llx\n", Bus,
|
I2cMasterContext->BaseAddress));
|
|
Bus++;
|
|
return EFI_SUCCESS;
|
|
fail:
|
FreePool(I2cMasterContext);
|
return Status;
|
}
|
|
STATIC
|
VOID
|
EFIAPI
|
OnEndOfDxe (
|
IN EFI_EVENT Event,
|
IN VOID *Context
|
)
|
{
|
MV_I2C_DEVICE_PATH *DevicePath;
|
EFI_DEVICE_PATH_PROTOCOL *DevicePathPointer;
|
EFI_HANDLE DeviceHandle;
|
EFI_STATUS Status;
|
|
gBS->CloseEvent (Event);
|
|
DevicePath = AllocateCopyPool (sizeof (MvI2cDevicePathProtocol),
|
&MvI2cDevicePathProtocol);
|
if (DevicePath == NULL) {
|
DEBUG ((DEBUG_ERROR, "MvI2cDxe: I2C device path allocation failed\n"));
|
return;
|
}
|
|
do {
|
DevicePathPointer = (EFI_DEVICE_PATH_PROTOCOL *)DevicePath;
|
Status = gBS->LocateDevicePath (&gEfiI2cMasterProtocolGuid,
|
&DevicePathPointer,
|
&DeviceHandle);
|
if (EFI_ERROR (Status)) {
|
break;
|
}
|
|
Status = gBS->ConnectController (DeviceHandle, NULL, NULL, TRUE);
|
DEBUG ((DEBUG_INFO,
|
"%a: ConnectController () returned %r\n",
|
__FUNCTION__,
|
Status));
|
|
DevicePath->Instance++;
|
} while (TRUE);
|
|
gBS->FreePool (DevicePath);
|
}
|
|
|
EFI_STATUS
|
EFIAPI
|
MvI2cInitialise (
|
IN EFI_HANDLE ImageHandle,
|
IN EFI_SYSTEM_TABLE *SystemTable
|
)
|
{
|
MARVELL_BOARD_DESC_PROTOCOL *BoardDescProtocol;
|
EFI_EVENT EndOfDxeEvent;
|
MV_BOARD_I2C_DESC *Desc;
|
EFI_STATUS Status;
|
UINTN Index;
|
|
/* Obtain list of available controllers */
|
Status = gBS->LocateProtocol (&gMarvellBoardDescProtocolGuid,
|
NULL,
|
(VOID **)&BoardDescProtocol);
|
if (EFI_ERROR (Status)) {
|
return Status;
|
}
|
|
Status = BoardDescProtocol->BoardDescI2cGet (BoardDescProtocol, &Desc);
|
if (EFI_ERROR (Status)) {
|
return Status;
|
}
|
|
/* Initialize enabled chips */
|
for (Index = 0; Index < Desc->I2cDevCount; Index++) {
|
Status = MvI2cInitialiseController(
|
ImageHandle,
|
SystemTable,
|
Desc[Index].SoC->I2cBaseAddress
|
);
|
if (EFI_ERROR(Status))
|
return Status;
|
}
|
|
BoardDescProtocol->BoardDescFree (Desc);
|
|
Status = gBS->CreateEventEx (EVT_NOTIFY_SIGNAL,
|
TPL_CALLBACK,
|
OnEndOfDxe,
|
NULL,
|
&gEfiEndOfDxeEventGroupGuid,
|
&EndOfDxeEvent);
|
ASSERT_EFI_ERROR (Status);
|
|
return EFI_SUCCESS;
|
}
|
|
STATIC
|
VOID
|
MvI2cControlClear (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN UINT32 Mask)
|
{
|
UINT32 Value;
|
|
/* clears given bits in I2C_CONTROL register */
|
Value = I2C_READ(I2cMasterContext, I2C_CONTROL);
|
Value &= ~Mask;
|
I2C_WRITE(I2cMasterContext, I2C_CONTROL, Value);
|
}
|
|
STATIC
|
VOID
|
MvI2cControlSet (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN UINT32 Mask)
|
{
|
UINT32 Value;
|
|
/* sets given bits in I2C_CONTROL register */
|
Value = I2C_READ(I2cMasterContext, I2C_CONTROL);
|
Value |= Mask;
|
I2C_WRITE(I2cMasterContext, I2C_CONTROL, Value);
|
}
|
|
STATIC
|
VOID
|
MvI2cClearIflg (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext
|
)
|
{
|
MvI2cPollCtrl (I2cMasterContext, I2C_OPERATION_TIMEOUT, I2C_CONTROL_IFLG);
|
MvI2cControlClear(I2cMasterContext, I2C_CONTROL_IFLG);
|
}
|
|
/* Timeout is given in us */
|
STATIC
|
UINTN
|
MvI2cPollCtrl (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN UINTN Timeout,
|
IN UINT32 Mask)
|
{
|
Timeout /= 10;
|
while (!(I2C_READ(I2cMasterContext, I2C_CONTROL) & Mask)) {
|
gBS->Stall(10);
|
if (--Timeout == 0)
|
return (Timeout);
|
}
|
return (0);
|
}
|
|
/*
|
* 'Timeout' is given in us. Note also that Timeout handling is not exact --
|
* MvI2cLockedStart() total wait can be more than 2 x Timeout
|
* (MvI2cPollCtrl() is called twice). 'Mask' can be either I2C_STATUS_START
|
* or I2C_STATUS_RPTD_START
|
*/
|
STATIC
|
EFI_STATUS
|
MvI2cLockedStart (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN INT32 Mask,
|
IN UINT8 Slave,
|
IN UINTN Timeout
|
)
|
{
|
UINTN ReadAccess, IflgSet = 0;
|
UINT32 I2cStatus;
|
|
if (Mask == I2C_STATUS_RPTD_START) {
|
/* read IFLG to know if it should be cleared later */
|
IflgSet = I2C_READ(I2cMasterContext, I2C_CONTROL) & I2C_CONTROL_IFLG;
|
}
|
|
MvI2cControlSet(I2cMasterContext, I2C_CONTROL_START);
|
|
if (Mask == I2C_STATUS_RPTD_START && IflgSet) {
|
DEBUG((DEBUG_INFO, "MvI2cDxe: IFLG set, clearing\n"));
|
MvI2cClearIflg(I2cMasterContext);
|
}
|
|
if (MvI2cPollCtrl(I2cMasterContext, Timeout, I2C_CONTROL_IFLG)) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: Timeout sending %sSTART condition\n",
|
Mask == I2C_STATUS_START ? "" : "repeated "));
|
return EFI_NO_RESPONSE;
|
}
|
|
I2cStatus = I2C_READ(I2cMasterContext, I2C_STATUS);
|
if (I2cStatus != Mask) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: wrong I2cStatus (%02x) after sending %sSTART condition\n",
|
I2cStatus, Mask == I2C_STATUS_START ? "" : "repeated "));
|
return EFI_DEVICE_ERROR;
|
}
|
|
I2C_WRITE(I2cMasterContext, I2C_DATA, Slave);
|
gBS->Stall(I2C_OPERATION_TIMEOUT);
|
MvI2cClearIflg(I2cMasterContext);
|
|
if (MvI2cPollCtrl(I2cMasterContext, Timeout, I2C_CONTROL_IFLG)) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: Timeout sending Slave address\n"));
|
return EFI_NO_RESPONSE;
|
}
|
|
ReadAccess = (Slave & 0x1) ? 1 : 0;
|
I2cStatus = I2C_READ(I2cMasterContext, I2C_STATUS);
|
if (I2cStatus != (ReadAccess ?
|
I2C_STATUS_ADDR_R_ACK : I2C_STATUS_ADDR_W_ACK)) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: no ACK (I2cStatus: %02x) after sending Slave address\n",
|
I2cStatus));
|
return EFI_NO_RESPONSE;
|
}
|
|
return EFI_SUCCESS;
|
}
|
|
#define ABSSUB(a,b) (((a) > (b)) ? (a) - (b) : (b) - (a))
|
STATIC
|
VOID
|
MvI2cCalBaudRate (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN CONST UINT32 target,
|
IN OUT MV_I2C_BAUD_RATE *rate,
|
UINT32 clk
|
)
|
{
|
UINT32 cur, diff, diff0, baud;
|
UINTN m, n, m0, n0;
|
|
/* Read initial m0, n0 values from register */
|
baud = I2C_READ(I2cMasterContext, I2C_BAUD_RATE);
|
m0 = I2C_M_FROM_BAUD(baud);
|
n0 = I2C_N_FROM_BAUD(baud);
|
/* Calculate baud rate. */
|
diff0 = 0xffffffff;
|
|
for (n = 0; n < 8; n++) {
|
for (m = 0; m < 16; m++) {
|
cur = I2C_BAUD_RATE_RAW(clk,m,n);
|
diff = ABSSUB(target, cur);
|
if (diff < diff0) {
|
m0 = m;
|
n0 = n;
|
diff0 = diff;
|
}
|
}
|
}
|
rate->raw = I2C_BAUD_RATE_RAW(clk, m0, n0);
|
rate->param = I2C_BAUD_RATE_PARAM(m0, n0);
|
rate->m = m0;
|
rate->n = n0;
|
}
|
|
EFI_STATUS
|
EFIAPI
|
MvI2cReset (
|
IN CONST EFI_I2C_MASTER_PROTOCOL *This
|
)
|
{
|
UINT32 param;
|
I2C_MASTER_CONTEXT *I2cMasterContext = I2C_SC_FROM_MASTER(This);
|
|
param = baud_rate.param;
|
|
EfiAcquireLock (&I2cMasterContext->Lock);
|
I2C_WRITE(I2cMasterContext, I2C_SOFT_RESET, 0x0);
|
gBS->Stall(2 * I2C_OPERATION_TIMEOUT);
|
I2C_WRITE(I2cMasterContext, I2C_BAUD_RATE, param);
|
I2C_WRITE(I2cMasterContext, I2C_CONTROL, I2C_CONTROL_I2CEN | I2C_CONTROL_ACK);
|
gBS->Stall(I2C_OPERATION_TIMEOUT);
|
EfiReleaseLock (&I2cMasterContext->Lock);
|
|
return EFI_SUCCESS;
|
}
|
|
/*
|
* Timeout is given in us
|
*/
|
STATIC
|
EFI_STATUS
|
MvI2cRepeatedStart (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN UINT8 Slave,
|
IN UINTN Timeout
|
)
|
{
|
EFI_STATUS Status;
|
|
EfiAcquireLock (&I2cMasterContext->Lock);
|
Status = MvI2cLockedStart(I2cMasterContext, I2C_STATUS_RPTD_START, Slave,
|
Timeout);
|
EfiReleaseLock (&I2cMasterContext->Lock);
|
|
if (EFI_ERROR(Status)) {
|
MvI2cStop(I2cMasterContext);
|
}
|
return Status;
|
}
|
|
/*
|
* Timeout is given in us
|
*/
|
STATIC
|
EFI_STATUS
|
MvI2cStart (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN UINT8 Slave,
|
IN UINTN Timeout
|
)
|
{
|
EFI_STATUS Status;
|
|
EfiAcquireLock (&I2cMasterContext->Lock);
|
Status = MvI2cLockedStart(I2cMasterContext, I2C_STATUS_START, Slave, Timeout);
|
EfiReleaseLock (&I2cMasterContext->Lock);
|
|
if (EFI_ERROR(Status)) {
|
MvI2cStop(I2cMasterContext);
|
}
|
return Status;
|
}
|
|
STATIC
|
EFI_STATUS
|
MvI2cStop (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext
|
)
|
{
|
EfiAcquireLock (&I2cMasterContext->Lock);
|
MvI2cControlSet(I2cMasterContext, I2C_CONTROL_STOP);
|
gBS->Stall(I2C_OPERATION_TIMEOUT);
|
MvI2cClearIflg(I2cMasterContext);
|
EfiReleaseLock (&I2cMasterContext->Lock);
|
|
return EFI_SUCCESS;
|
}
|
|
STATIC
|
EFI_STATUS
|
MvI2cRead (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN OUT UINT8 *Buf,
|
IN UINTN Length,
|
IN OUT UINTN *read,
|
IN UINTN last,
|
IN UINTN delay
|
)
|
{
|
UINT32 I2cStatus;
|
UINTN LastByte;
|
EFI_STATUS Status;
|
|
EfiAcquireLock (&I2cMasterContext->Lock);
|
*read = 0;
|
while (*read < Length) {
|
/*
|
* Check if we are reading last byte of the last Buffer,
|
* do not send ACK then, per I2C specs
|
*/
|
LastByte = ((*read == Length - 1) && last) ? 1 : 0;
|
if (LastByte)
|
MvI2cControlClear(I2cMasterContext, I2C_CONTROL_ACK);
|
else
|
MvI2cControlSet(I2cMasterContext, I2C_CONTROL_ACK);
|
|
gBS->Stall (I2C_OPERATION_TIMEOUT);
|
MvI2cClearIflg(I2cMasterContext);
|
|
if (MvI2cPollCtrl(I2cMasterContext, delay, I2C_CONTROL_IFLG)) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: Timeout reading data\n"));
|
Status = EFI_NO_RESPONSE;
|
goto out;
|
}
|
|
I2cStatus = I2C_READ(I2cMasterContext, I2C_STATUS);
|
if (I2cStatus != (LastByte ?
|
I2C_STATUS_DATA_RD_NOACK : I2C_STATUS_DATA_RD_ACK)) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: wrong I2cStatus (%02x) while reading\n", I2cStatus));
|
Status = EFI_DEVICE_ERROR;
|
goto out;
|
}
|
|
*Buf++ = I2C_READ(I2cMasterContext, I2C_DATA);
|
(*read)++;
|
}
|
Status = EFI_SUCCESS;
|
out:
|
EfiReleaseLock (&I2cMasterContext->Lock);
|
return (Status);
|
}
|
|
STATIC
|
EFI_STATUS
|
MvI2cWrite (
|
IN I2C_MASTER_CONTEXT *I2cMasterContext,
|
IN OUT CONST UINT8 *Buf,
|
IN UINTN Length,
|
IN OUT UINTN *Sent,
|
IN UINTN Timeout
|
)
|
{
|
UINT32 status;
|
EFI_STATUS Status;
|
|
EfiAcquireLock (&I2cMasterContext->Lock);
|
*Sent = 0;
|
while (*Sent < Length) {
|
I2C_WRITE(I2cMasterContext, I2C_DATA, *Buf++);
|
|
MvI2cClearIflg(I2cMasterContext);
|
if (MvI2cPollCtrl(I2cMasterContext, Timeout, I2C_CONTROL_IFLG)) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: Timeout writing data\n"));
|
Status = EFI_NO_RESPONSE;
|
goto out;
|
}
|
|
status = I2C_READ(I2cMasterContext, I2C_STATUS);
|
if (status != I2C_STATUS_DATA_WR_ACK) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: wrong status (%02x) while writing\n", status));
|
Status = EFI_DEVICE_ERROR;
|
goto out;
|
}
|
(*Sent)++;
|
}
|
Status = EFI_SUCCESS;
|
out:
|
EfiReleaseLock (&I2cMasterContext->Lock);
|
return (Status);
|
}
|
|
/*
|
* MvI2cStartRequest should be called only by I2cHost.
|
* I2C device drivers ought to use EFI_I2C_IO_PROTOCOL instead.
|
*/
|
STATIC
|
EFI_STATUS
|
MvI2cStartRequest (
|
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
|
)
|
{
|
UINTN Count;
|
UINTN ReadMode;
|
UINTN Transmitted;
|
I2C_MASTER_CONTEXT *I2cMasterContext = I2C_SC_FROM_MASTER(This);
|
EFI_I2C_OPERATION *Operation;
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
ASSERT (RequestPacket != NULL);
|
ASSERT (I2cMasterContext != NULL);
|
|
for (Count = 0; Count < RequestPacket->OperationCount; Count++) {
|
Operation = &RequestPacket->Operation[Count];
|
ReadMode = Operation->Flags & I2C_FLAG_READ;
|
|
if (Count == 0) {
|
Status = MvI2cStart (I2cMasterContext,
|
(SlaveAddress << 1) | ReadMode,
|
I2C_TRANSFER_TIMEOUT);
|
} else if (!(Operation->Flags & I2C_FLAG_NORESTART)) {
|
Status = MvI2cRepeatedStart (I2cMasterContext,
|
(SlaveAddress << 1) | ReadMode,
|
I2C_TRANSFER_TIMEOUT);
|
}
|
|
/* I2C transaction was aborted, so stop further transactions */
|
if (EFI_ERROR (Status)) {
|
MvI2cStop (I2cMasterContext);
|
break;
|
}
|
|
/*
|
* If sending the slave address was successful,
|
* proceed to read or write section.
|
*/
|
if (ReadMode) {
|
Status = MvI2cRead (I2cMasterContext,
|
Operation->Buffer,
|
Operation->LengthInBytes,
|
&Transmitted,
|
Count == 1,
|
I2C_TRANSFER_TIMEOUT);
|
Operation->LengthInBytes = Transmitted;
|
} else {
|
Status = MvI2cWrite (I2cMasterContext,
|
Operation->Buffer,
|
Operation->LengthInBytes,
|
&Transmitted,
|
I2C_TRANSFER_TIMEOUT);
|
Operation->LengthInBytes = Transmitted;
|
}
|
|
/*
|
* The I2C read or write transaction failed.
|
* Stop the I2C transaction.
|
*/
|
if (EFI_ERROR (Status)) {
|
MvI2cStop (I2cMasterContext);
|
break;
|
}
|
|
/* Check if there is any more data to be sent */
|
if (Count == RequestPacket->OperationCount - 1) {
|
MvI2cStop ( I2cMasterContext );
|
}
|
}
|
|
if (I2cStatus != NULL)
|
*I2cStatus = EFI_SUCCESS;
|
if (Event != NULL)
|
gBS->SignalEvent(Event);
|
return EFI_SUCCESS;
|
}
|
|
STATIC CONST EFI_GUID DevGuid = I2C_GUID;
|
|
STATIC
|
EFI_STATUS
|
MvI2cAllocDevice (
|
IN UINT8 SlaveAddress,
|
IN UINT8 Bus,
|
IN OUT CONST EFI_I2C_DEVICE **Device
|
)
|
{
|
EFI_STATUS Status;
|
EFI_I2C_DEVICE *Dev;
|
UINT32 *TmpSlaveArray;
|
EFI_GUID *TmpGuidP;
|
|
Status = gBS->AllocatePool ( EfiBootServicesData,
|
sizeof(EFI_I2C_DEVICE),
|
(VOID **) &Dev );
|
if (EFI_ERROR(Status)) {
|
DEBUG((DEBUG_ERROR, "MvI2cDxe: I2C device memory allocation failed\n"));
|
return Status;
|
}
|
*Device = Dev;
|
Dev->DeviceIndex = SlaveAddress;
|
Dev->DeviceIndex = I2C_DEVICE_INDEX(Bus, SlaveAddress);
|
Dev->SlaveAddressCount = 1;
|
Dev->I2cBusConfiguration = 0;
|
Status = gBS->AllocatePool ( EfiBootServicesData,
|
sizeof(UINT32),
|
(VOID **) &TmpSlaveArray);
|
if (EFI_ERROR(Status)) {
|
goto fail1;
|
}
|
TmpSlaveArray[0] = SlaveAddress;
|
Dev->SlaveAddressArray = TmpSlaveArray;
|
|
Status = gBS->AllocatePool ( EfiBootServicesData,
|
sizeof(EFI_GUID),
|
(VOID **) &TmpGuidP);
|
if (EFI_ERROR(Status)) {
|
goto fail2;
|
}
|
*TmpGuidP = DevGuid;
|
Dev->DeviceGuid = TmpGuidP;
|
|
DEBUG((DEBUG_INFO, "MvI2c: allocated device with address %x\n", (UINTN)SlaveAddress));
|
return EFI_SUCCESS;
|
|
fail2:
|
FreePool(TmpSlaveArray);
|
fail1:
|
FreePool(Dev);
|
|
return Status;
|
}
|
|
/*
|
* It is called by I2cBus to enumerate devices on I2C bus. In this case,
|
* enumeration is based on PCD configuration - all Slave addresses specified
|
* in PCD get their corresponding EFI_I2C_DEVICE structures here.
|
*
|
* After enumeration succeeds, Supported() function of drivers that installed
|
* DriverBinding protocol is called.
|
*/
|
STATIC
|
EFI_STATUS
|
EFIAPI
|
MvI2cEnumerate (
|
IN CONST EFI_I2C_ENUMERATE_PROTOCOL *This,
|
IN OUT CONST EFI_I2C_DEVICE **Device
|
)
|
{
|
UINT8 *DevicesPcd;
|
UINT8 *DeviceBusPcd;
|
UINTN Index, NextIndex, DevCount;
|
UINT8 NextDeviceAddress;
|
I2C_MASTER_CONTEXT *I2cMasterContext = I2C_SC_FROM_ENUMERATE(This);
|
|
DevCount = PcdGetSize (PcdI2cSlaveAddresses);
|
DevicesPcd = PcdGetPtr (PcdI2cSlaveAddresses);
|
DeviceBusPcd = PcdGetPtr (PcdI2cSlaveBuses);
|
if (*Device == NULL) {
|
for (Index = 0; Index < DevCount ; Index++) {
|
if (DeviceBusPcd[Index] != I2cMasterContext->Bus)
|
continue;
|
if (Index < DevCount)
|
MvI2cAllocDevice (DevicesPcd[Index], I2cMasterContext->Bus, Device);
|
return EFI_SUCCESS;
|
}
|
} else {
|
/* Device is not NULL, so something was already allocated */
|
for (Index = 0; Index < DevCount; Index++) {
|
if (DeviceBusPcd[Index] != I2cMasterContext->Bus)
|
continue;
|
if (DevicesPcd[Index] == I2C_DEVICE_ADDRESS((*Device)->DeviceIndex)) {
|
for (NextIndex = Index + 1; NextIndex < DevCount; NextIndex++) {
|
if (DeviceBusPcd[NextIndex] != I2cMasterContext->Bus)
|
continue;
|
NextDeviceAddress = DevicesPcd[NextIndex];
|
if (NextIndex < DevCount)
|
MvI2cAllocDevice(NextDeviceAddress, I2cMasterContext->Bus, Device);
|
return EFI_SUCCESS;
|
}
|
}
|
}
|
*Device = NULL;
|
return EFI_SUCCESS;
|
}
|
return EFI_SUCCESS;
|
}
|
|
STATIC
|
EFI_STATUS
|
EFIAPI
|
MvI2cEnableConf (
|
IN CONST EFI_I2C_BUS_CONFIGURATION_MANAGEMENT_PROTOCOL *This,
|
IN UINTN I2cBusConfiguration,
|
IN EFI_EVENT Event OPTIONAL,
|
IN EFI_STATUS *I2cStatus OPTIONAL
|
)
|
{
|
/* do nothing */
|
if (I2cStatus != NULL)
|
I2cStatus = EFI_SUCCESS;
|
if (Event != NULL)
|
gBS->SignalEvent(Event);
|
return EFI_SUCCESS;
|
}
|
