ksz8851snl_spi.c

Go to the documentation of this file.

/**************************************************************************/
#include <stdio.h>
#include <stdint.h>

#include "ksz8851snl_spi.h"
#include "em_assert.h"
#include "em_common.h"
#include "em_gpio.h"
#include "spidrv.h"

#define BOGUS_BYTE           0xFF               
#define REG_MASK             0x03               
#define OPCODE_REG_READ      0x00               
#define OPCODE_REG_WRITE     0x40               
#define OPCODE_FIFO_READ     0x80               
#define OPCODE_FIFO_WRITE    0xC0               
#define ADDRESS_MS2B_POS     0x06               
#define ADDRESS_SHIFT        0x02               
#define BYTE_ENABLE          0x03               
#define BYTE_ENABLE_SHIFT    0x02               
/* GPIO pins used for SPI communication. */
/*(USART 1, Location #1) */
#define ETH_CS_PIN       3                      
#define ETH_CS_PORT      gpioPortD              
static SPIDRV_HandleData_t spiHandleData;
static SPIDRV_Handle_t spiHandle = &spiHandleData;

/**************************************************************************/
void KSZ8851SNL_SPI_Init(void)
{
  Ecode_t result;
  SPIDRV_Init_t initData = SPIDRV_MASTER_USART1;
  initData.bitRate = 8000000; // 8 MHz max safe speed
  initData.frameLength = 8;
  initData.dummyTxValue = BOGUS_BYTE;
  initData.bitOrder = spidrvBitOrderMsbFirst;
  initData.clockMode = spidrvClockMode0;
  initData.csControl = spidrvCsControlApplication;

  result = SPIDRV_Init(spiHandle, &initData);
  EFM_ASSERT(result == ECODE_EMDRV_SPIDRV_OK);

  GPIO_PinModeSet(ETH_CS_PORT, ETH_CS_PIN, gpioModePushPull, 1);
}


/**************************************************************************/
static void KSZ8851SNL_SPI_Transmit(int numBytes, const uint8_t * data)
{
  Ecode_t result;
  int remaining = numBytes;

  /* The spidrv is using dma to transfer bytes to the USART (spi)
   * this is why we must transmit bytes in chunks of at most
   * DMADRV_MAX_XFER_COUNT (1024 on EFM32GG990F1024)
   */
  do {
    int count  = SL_MIN(remaining, DMADRV_MAX_XFER_COUNT);
    result     = SPIDRV_MTransmitB(spiHandle, data, count);
    remaining -= count;
    data      += count;
  } while (result == ECODE_EMDRV_SPIDRV_OK && remaining > 0);

  EFM_ASSERT(result == ECODE_EMDRV_SPIDRV_OK);
}


/**************************************************************************/
static void KSZ8851SNL_SPI_Receive(int numBytes, uint8_t * buffer)
{
  Ecode_t result;
  int remaining = numBytes;

  /* The spidrv is using dma to receive bytes from the USART (spi)
   * this is why we must receive bytes in chunks of at most
   * DMADRV_MAX_XFER_COUNT (1024 on EFM32GG990F1024)
   */
  do {
    int count  = SL_MIN(remaining, DMADRV_MAX_XFER_COUNT);
    result     = SPIDRV_MReceiveB(spiHandle, buffer, count);
    remaining -= count;
    buffer    += count;
  } while (result == ECODE_EMDRV_SPIDRV_OK && remaining > 0);

  EFM_ASSERT(result == ECODE_EMDRV_SPIDRV_OK);
}


/**************************************************************************/
static void KSZ8851SNL_SPI_SetChipSelect(bool enable)
{
  if (enable)
  {
    GPIO_PinOutClear(ETH_CS_PORT, ETH_CS_PIN);
  }
  else
  {
    GPIO_PinOutSet(ETH_CS_PORT, ETH_CS_PIN);
  }
}


/**************************************************************************/
uint16_t KSZ8851SNL_SPI_ReadRegister(uint8_t reg)
{
  uint16_t value = 0x0000;
  uint8_t txBuffer[4];
  uint8_t rxBuffer[4];

  txBuffer[0]  = OPCODE_REG_READ;
  txBuffer[0] |= BYTE_ENABLE << (BYTE_ENABLE_SHIFT + (reg & REG_MASK));
  txBuffer[0] |= (reg >> ADDRESS_MS2B_POS);
  txBuffer[1]  = (reg << ADDRESS_SHIFT) & 0xf0;

  KSZ8851SNL_SPI_SetChipSelect(true);
  SPIDRV_MTransferB(spiHandle, txBuffer, rxBuffer, 4);
  KSZ8851SNL_SPI_SetChipSelect(false);

  value = (rxBuffer[3] << 8) | rxBuffer[2];
  return value;
}


/**************************************************************************/
void KSZ8851SNL_SPI_WriteRegister(uint8_t reg, uint16_t value)
{
  uint8_t txBuffer[4];

  txBuffer[0]  = OPCODE_REG_WRITE | (BYTE_ENABLE << (BYTE_ENABLE_SHIFT + (reg & REG_MASK)));
  txBuffer[0] |= reg >> ADDRESS_MS2B_POS;
  txBuffer[1]  = (reg << ADDRESS_SHIFT) & 0xf0;
  txBuffer[2]  = value & 0xff;
  txBuffer[3]  = (value >> 8) & 0xff;

  KSZ8851SNL_SPI_SetChipSelect(true);
  KSZ8851SNL_SPI_Transmit(4, txBuffer);
  KSZ8851SNL_SPI_SetChipSelect(false);
}


/*************************************************************************/
void KSZ8851SNL_SPI_ReadFifo(int numBytes, uint8_t *data)
{
  EFM_ASSERT(numBytes >= 0 && numBytes < 12000);
  EFM_ASSERT(data != NULL);

  uint8_t cmd = OPCODE_FIFO_READ;
  uint8_t dummy[4];

  KSZ8851SNL_SPI_SetChipSelect(true);
  KSZ8851SNL_SPI_Transmit(1, &cmd);
  KSZ8851SNL_SPI_Receive(4, dummy);
  KSZ8851SNL_SPI_Receive(numBytes, data);
  KSZ8851SNL_SPI_SetChipSelect(false);
}

/*************************************************************************/
void KSZ8851SNL_SPI_WriteFifoBegin(void)
{
  uint8_t cmd = OPCODE_FIFO_WRITE;
  /* Enable chip select */
  KSZ8851SNL_SPI_SetChipSelect(true);
  /* Send Write command */
  KSZ8851SNL_SPI_Transmit(1, &cmd);
}

/*************************************************************************/
void KSZ8851SNL_SPI_WriteFifo(int numBytes, const uint8_t *data)
{
  EFM_ASSERT(numBytes >= 0 && numBytes < 12000);
  EFM_ASSERT(data != NULL);

  KSZ8851SNL_SPI_Transmit(numBytes, data);
}


/*************************************************************************/
void KSZ8851SNL_SPI_WriteFifoEnd(void)
{
  KSZ8851SNL_SPI_SetChipSelect(false);
}