SpiBus.c

Go to the documentation of this file.

 
#include <Library/BaseLib.h>
#include <Library/DebugLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Protocol/SpiConfiguration.h>
#include <Protocol/SpiHc.h>
#include <Protocol/SpiIo.h>
#include "SpiBus.h"
 
BOOLEAN
EFIAPI
DevicePathsAreEqual (
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath1,
  IN CONST EFI_DEVICE_PATH_PROTOCOL  *DevicePath2
  )
{
  UINTN  Size1;
  UINTN  Size2;
 
  Size1 = GetDevicePathSize (DevicePath1);
  Size2 = GetDevicePathSize (DevicePath2);
 
  if (Size1 != Size2) {
    return FALSE;
  }
 
  if (CompareMem (DevicePath1, DevicePath2, Size1) != 0) {
    return FALSE;
  }
 
  return TRUE;
}
 
EFI_STATUS
EFIAPI
SpiChipSelect (
  IN CONST SPI_IO_CHIP  *SpiChip,
  IN BOOLEAN            PinValue
  )
{
  EFI_STATUS  Status;
 
  // Check which chip select function to use
  if (SpiChip->Protocol.SpiPeripheral->ChipSelect != NULL) {
    Status = SpiChip->Protocol.SpiPeripheral->ChipSelect (
                                                SpiChip->BusTransaction.SpiPeripheral,
                                                PinValue
                                                );
  } else {
    Status = SpiChip->SpiHc->ChipSelect (
                               SpiChip->SpiHc,
                               SpiChip->BusTransaction.SpiPeripheral,
                               PinValue
                               );
  }
 
  return Status;
}
 
EFI_STATUS
EFIAPI
IsValidSpiTransaction (
  IN SPI_IO_CHIP  *SpiChip
  )
{
  // Error checking
  if (SpiChip->BusTransaction.TransactionType > SPI_TRANSACTION_WRITE_THEN_READ) {
    return EFI_INVALID_PARAMETER;
  }
 
  if (((SpiChip->BusTransaction.BusWidth != 1) && (SpiChip->BusTransaction.BusWidth != 2) && (SpiChip->BusTransaction.BusWidth != 4) &&
       (SpiChip->BusTransaction.BusWidth != 8)) || (SpiChip->BusTransaction.FrameSize == 0))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((SpiChip->BusTransaction.BusWidth == 8) && (((SpiChip->Protocol.Attributes & SPI_IO_SUPPORTS_8_BIT_DATA_BUS_WIDTH) != SPI_IO_SUPPORTS_8_BIT_DATA_BUS_WIDTH) ||
                                                  ((SpiChip->BusTransaction.SpiPeripheral->Attributes & SPI_PART_SUPPORTS_8_BIT_DATA_BUS_WIDTH) != SPI_PART_SUPPORTS_8_BIT_DATA_BUS_WIDTH)))
  {
    return EFI_INVALID_PARAMETER;
  } else if ((SpiChip->BusTransaction.BusWidth == 4) && (((SpiChip->Protocol.Attributes & SPI_IO_SUPPORTS_4_BIT_DATA_BUS_WIDTH) != SPI_IO_SUPPORTS_4_BIT_DATA_BUS_WIDTH) ||
                                                         ((SpiChip->BusTransaction.SpiPeripheral->Attributes & SPI_PART_SUPPORTS_4_BIT_DATA_BUS_WIDTH) != SPI_PART_SUPPORTS_4_BIT_DATA_BUS_WIDTH)))
  {
    return EFI_INVALID_PARAMETER;
  } else if ((SpiChip->BusTransaction.BusWidth == 2) && (((SpiChip->Protocol.Attributes & SPI_IO_SUPPORTS_4_BIT_DATA_BUS_WIDTH) != SPI_IO_SUPPORTS_4_BIT_DATA_BUS_WIDTH) ||
                                                         ((SpiChip->BusTransaction.SpiPeripheral->Attributes & SPI_PART_SUPPORTS_2_BIT_DATA_BUS_WIDTH) != SPI_PART_SUPPORTS_2_BIT_DATA_BUS_WIDTH)))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  if (((SpiChip->BusTransaction.WriteBytes > 0) && (SpiChip->BusTransaction.WriteBuffer == NULL)) || ((SpiChip->BusTransaction.ReadBytes > 0) && (SpiChip->BusTransaction.ReadBuffer == NULL))) {
    return EFI_INVALID_PARAMETER;
  }
 
  if ((SpiChip->BusTransaction.TransactionType == SPI_TRANSACTION_FULL_DUPLEX) &&  (SpiChip->BusTransaction.ReadBytes != SpiChip->BusTransaction.WriteBytes)) {
    return EFI_INVALID_PARAMETER;
  }
 
  // Check frame size, passed parameter is in bits
  if ((SpiChip->Protocol.FrameSizeSupportMask & (1<<(SpiChip->BusTransaction.FrameSize-1))) == 0) {
    return EFI_UNSUPPORTED;
  }
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
EFIAPI
Transaction (
  IN  CONST EFI_SPI_IO_PROTOCOL  *This,
  IN  EFI_SPI_TRANSACTION_TYPE   TransactionType,
  IN  BOOLEAN                    DebugTransaction,
  IN  UINT32                     ClockHz OPTIONAL,
  IN  UINT32                     BusWidth,
  IN  UINT32                     FrameSize,
  IN  UINT32                     WriteBytes,
  IN  UINT8                      *WriteBuffer,
  IN  UINT32                     ReadBytes,
  OUT UINT8                      *ReadBuffer
  )
{
  EFI_STATUS   Status;
  SPI_IO_CHIP  *SpiChip;
  UINT32       MaxClockHz;
  UINT8        *DummyReadBuffer;
  UINT8        *DummyWriteBuffer;
 
  SpiChip                               = SPI_IO_CHIP_FROM_THIS (This);
  SpiChip->BusTransaction.SpiPeripheral =
    (EFI_SPI_PERIPHERAL *)SpiChip->Protocol.SpiPeripheral;
  SpiChip->BusTransaction.TransactionType  = TransactionType;
  SpiChip->BusTransaction.DebugTransaction = DebugTransaction;
  SpiChip->BusTransaction.BusWidth         = BusWidth;
  SpiChip->BusTransaction.FrameSize        = FrameSize;
  SpiChip->BusTransaction.WriteBytes       = WriteBytes;
  SpiChip->BusTransaction.WriteBuffer      = WriteBuffer;
  SpiChip->BusTransaction.ReadBytes        = ReadBytes;
  SpiChip->BusTransaction.ReadBuffer       = ReadBuffer;
 
  // Ensure valid spi transaction parameters
  Status = IsValidSpiTransaction (SpiChip);
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  // Setup the proper clock frequency
  if (SpiChip->BusTransaction.SpiPeripheral->MaxClockHz != 0) {
    MaxClockHz = SpiChip->BusTransaction.SpiPeripheral->MaxClockHz;
  } else {
    MaxClockHz = SpiChip->BusTransaction.SpiPeripheral->SpiPart->MaxClockHz;
  }
 
  // Call proper clock function
  if (SpiChip->Protocol.SpiPeripheral->SpiBus->Clock != NULL) {
    Status = SpiChip->Protocol.SpiPeripheral->SpiBus->Clock (
                                                        SpiChip->BusTransaction.SpiPeripheral,
                                                        &MaxClockHz
                                                        );
  } else {
    Status = SpiChip->SpiHc->Clock (
                               SpiChip->SpiHc,
                               SpiChip->BusTransaction.SpiPeripheral,
                               &MaxClockHz
                               );
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = SpiChipSelect (SpiChip, SpiChip->BusTransaction.SpiPeripheral->SpiPart->ChipSelectPolarity);
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  // Check transaction types and match to HC capabilities
  if ((TransactionType == SPI_TRANSACTION_WRITE_ONLY) &&
      ((SpiChip->SpiHc->Attributes & HC_SUPPORTS_WRITE_ONLY_OPERATIONS) != HC_SUPPORTS_WRITE_ONLY_OPERATIONS))
  {
    // Convert to full duplex transaction
    SpiChip->BusTransaction.ReadBytes  = SpiChip->BusTransaction.WriteBytes;
    SpiChip->BusTransaction.ReadBuffer = AllocateZeroPool (SpiChip->BusTransaction.ReadBytes);
 
    Status = SpiChip->SpiHc->Transaction (
                               SpiChip->SpiHc,
                               &SpiChip->BusTransaction
                               );
 
    SpiChip->BusTransaction.ReadBytes = ReadBytes; // assign to passed parameter
    FreePool (SpiChip->BusTransaction.ReadBuffer); // Free temporary buffer
  } else if ((TransactionType == SPI_TRANSACTION_READ_ONLY) &&
             ((SpiChip->SpiHc->Attributes & HC_SUPPORTS_READ_ONLY_OPERATIONS) != HC_SUPPORTS_READ_ONLY_OPERATIONS))
  {
    // Convert to full duplex transaction
    SpiChip->BusTransaction.WriteBytes  = SpiChip->BusTransaction.WriteBytes;
    SpiChip->BusTransaction.WriteBuffer = AllocateZeroPool (SpiChip->BusTransaction.WriteBytes);
 
    Status = SpiChip->SpiHc->Transaction (
                               SpiChip->SpiHc,
                               &SpiChip->BusTransaction
                               );
 
    SpiChip->BusTransaction.WriteBytes = WriteBytes;
    FreePool (SpiChip->BusTransaction.WriteBuffer);
  } else if ((TransactionType == SPI_TRANSACTION_WRITE_THEN_READ) &&
             ((SpiChip->SpiHc->Attributes & HC_SUPPORTS_WRITE_THEN_READ_OPERATIONS) != HC_SUPPORTS_WRITE_THEN_READ_OPERATIONS))
  {
    // Convert to full duplex transaction
    DummyReadBuffer                    = AllocateZeroPool (WriteBytes);
    DummyWriteBuffer                   = AllocateZeroPool (ReadBytes);
    SpiChip->BusTransaction.ReadBuffer = DummyReadBuffer;
    SpiChip->BusTransaction.ReadBytes  = WriteBytes;
 
    Status = SpiChip->SpiHc->Transaction (
                               SpiChip->SpiHc,
                               &SpiChip->BusTransaction
                               );
 
    if (EFI_ERROR (Status)) {
      return Status;
    }
 
    // Write is done, now need to read, restore passed in read buffer info
    SpiChip->BusTransaction.ReadBuffer = ReadBuffer;
    SpiChip->BusTransaction.ReadBytes  = ReadBytes;
 
    SpiChip->BusTransaction.WriteBuffer = DummyWriteBuffer;
    SpiChip->BusTransaction.WriteBytes  = ReadBytes;
 
    Status = SpiChip->SpiHc->Transaction (
                               SpiChip->SpiHc,
                               &SpiChip->BusTransaction
                               );
    // Restore write data
    SpiChip->BusTransaction.WriteBuffer = WriteBuffer;
    SpiChip->BusTransaction.WriteBytes  = WriteBytes;
 
    FreePool (DummyReadBuffer);
    FreePool (DummyWriteBuffer);
  } else {
    // Supported transaction type, just pass info the SPI HC Protocol Transaction
    Status = SpiChip->SpiHc->Transaction (
                               SpiChip->SpiHc,
                               &SpiChip->BusTransaction
                               );
  }
 
  if (EFI_ERROR (Status)) {
    return Status;
  }
 
  Status = SpiChipSelect (SpiChip, !SpiChip->BusTransaction.SpiPeripheral->SpiPart->ChipSelectPolarity);
 
  return Status;
}
 
EFI_STATUS
EFIAPI
UpdateSpiPeripheral (
  IN CONST EFI_SPI_IO_PROTOCOL  *This,
  IN CONST EFI_SPI_PERIPHERAL   *SpiPeripheral
  )
{
  EFI_STATUS   Status;
  SPI_IO_CHIP  *SpiChip;
 
  DEBUG ((DEBUG_VERBOSE, "%a: SPI Bus - Entry\n", __func__));
 
  SpiChip = SPI_IO_CHIP_FROM_THIS (This);
 
  if ((SpiPeripheral == NULL) || (SpiPeripheral->SpiBus == NULL) ||
      (SpiPeripheral->SpiPart == NULL))
  {
    return EFI_INVALID_PARAMETER;
  }
 
  // EFI_INVALID_PARAMETER if SpiPeripheral->SpiBus is pointing at wrong bus
  if (!DevicePathsAreEqual (SpiPeripheral->SpiBus->ControllerPath, SpiChip->SpiBus->ControllerPath)) {
    return EFI_INVALID_PARAMETER;
  }
 
  SpiChip->Protocol.OriginalSpiPeripheral = SpiChip->Protocol.SpiPeripheral;
  SpiChip->Protocol.SpiPeripheral         = SpiPeripheral;
 
  Status = EFI_SUCCESS;
  DEBUG ((
    DEBUG_VERBOSE,
    "%a: SPI Bus - Exit Status=%r\n",
    __func__,
    Status
    ));
  return Status;
}