spi.c

/**
  ******************************************************************************
  * @file    spi.c
  * @author  CMS Application Team
  * @version Vx.x.x
  * @date    24-April-2022
  * @brief   This file provides firmware functions to manage the following 
  *          functionalities of the Serial Peripheral interface (SPI):           
  @verbatim       
 ===============================================================================
                        ##### How to use this driver #####
 ===============================================================================
    [..]
            
    @endverbatim        
  ******************************************************************************
  * @attention
  *
  *
  ******************************************************************************
  */

/* Includes ------------------------------------------------------------------*/
#include "spi.h"
#include "cgc.h"

/* Private typedef -----------------------------------------------------------*/
/* Private define ------------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
/* Private functions ---------------------------------------------------------*/

/** @defgroup SPI_Private_Functions
  * @{
  */
NSS_FUNC_T NSS;
/**
  * @brief  De-initialize the SPI peripheral registers to their default reset values.
  * @note   None
  * @retval None
  */
void SPI_DeInit(SPI_Type* SPIx)
{
	if(SPIx == SPIHS0)
	{
		CGC_PER2PeriphClockCmd(CGC_PER2Periph_SPIHS0, DISABLE);
	}
	else if(SPIx == SPIHS1)
	{
		CGC_PER2PeriphClockCmd(CGC_PER2Periph_SPIHS1, DISABLE);
	}
}

/**
  * @brief  Initializes the SPIx peripheral according to the specified 
  *         parameters in the SPI_InitStruct.
  * @param  SPI_InitStruct: pointer to a SPI_InitTypeDef structure that
  *         contains the configuration information for the specified SPI peripheral.
  * @retval None
  */
void SPI_Init(SPI_Type* SPIx,SPI_InitTypeDef* SPI_InitStruct)
{
	uint32_t tmpreg = 0;

	/* Check the SPI parameters */
    assert_param(IS_SPI_ALL_PERIPH(SPIx));
	assert_param(IS_SPI_MODE(SPI_InitStruct->SPI_Mode));
	assert_param(IS_SPI_DATASIZE(SPI_InitStruct->SPI_DataSize));
	assert_param(IS_SPI_CPOL(SPI_InitStruct->SPI_CPOL));
	assert_param(IS_SPI_CPHA(SPI_InitStruct->SPI_CPHA));
	assert_param(IS_SPI_NSS(SPI_InitStruct->SPI_NSS));
	assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_InitStruct->SPI_BaudRatePrescaler));
	assert_param(IS_SPI_FIRST_BIT(SPI_InitStruct->SPI_FirstBit));

	/*---------------------------- SPI Clock gate control enable -----------------*/
	if(SPIx == SPIHS0)
	{
		CGC_PER2PeriphClockCmd(CGC_PER2Periph_SPIHS0, ENABLE);
	}
	else if(SPIx == SPIHS1)
	{
		CGC_PER2PeriphClockCmd(CGC_PER2Periph_SPIHS1, ENABLE);
	}
	/*---------------------------- SPI SPIM flag clear ---------------------------*/
	SPIx->SPIM &= ~(SPI_FLAG_RXNE);
	SPIx->SPIM &= ~(SPI_FLAG_RUNNING);

	/*---------------------------- SPI SPIC Configuration ------------------------*/
	/* Get the SPIC value */
	tmpreg = SPIx->SPIC;

	/* The SPI Master or Slave mode selected by clock setting */
	if (SPI_Mode_Master == SPI_InitStruct->SPI_Mode)
	{
		tmpreg |= SPI_InitStruct->SPI_BaudRatePrescaler;
	}
	else
	{
		/* When SPI mode is slave, select the ext clock */
		tmpreg |= SPI_BaudRatePrescaler_Ext;
	}

	/* SPI_Clock_Polarity setting */
	tmpreg |= SPI_InitStruct->SPI_CPOL;

	/* SPI_Clock_Phase setting */
	tmpreg |= SPI_InitStruct->SPI_CPHA;

	/* Set the SPIC value */
	SPIx->SPIC = tmpreg;

	/*---------------------------- SPI SPIM Configuration ------------------------*/
	/* Get the SPIM value */
	tmpreg = SPIx->SPIM;

	tmpreg |= SPI_InitStruct->SPI_DataSize;
	tmpreg |= SPI_InitStruct->SPI_NSS;
	tmpreg |= SPI_InitStruct->SPI_FirstBit;

	/* Set the SPIM value */
	SPIx->SPIM = tmpreg;
}

/**
  * @brief  Enables or disables the specified SPI peripheral.
  * @param  NewState: new state of the SPI peripheral. 
  *          This parameter can be: ENABLE or DISABLE.
  * @retval None
  */
void SPI_Cmd(SPI_Type* SPIx,FunctionalState NewState)
{
	/* Check the parameters */
    assert_param(IS_SPI_ALL_PERIPH(SPIx));
	assert_param(IS_FUNCTIONAL_STATE(NewState));
	if (NewState != DISABLE)
	{
		/* Enable the selected SPI peripheral */
		SPIx->SPIM |= (uint32_t)SPI_SPIM_SPIE_Msk;
		if(NSS.Active)
		{
			NSS.Active();
		}
	}
	else
	{
		/* Disable the selected SPI peripheral */
		SPIx->SPIM &= (uint32_t)~((uint32_t)SPI_SPIM_SPIE_Msk);
		if(NSS.Inactive)
		{
			NSS.Inactive();	
		}
	}
}

/**
  * @brief  Configures the data size for the selected SPI.
  * @param  SPI_DataSize: specifies the SPI data size.
  *          This parameter can be one of the following values:
  *            @arg SPI_DataSize_16b: Set data frame format to 16bit
  *            @arg SPI_DataSize_8b: Set data frame format to 8bit
  * @retval None
  */
void SPI_DataSizeConfig(SPI_Type* SPIx,uint8_t SPI_DataSize)
{
	/* Check the parameters */
    assert_param(IS_SPI_ALL_PERIPH(SPIx));
	assert_param(IS_SPI_DATASIZE(SPI_DataSize));
	/* Clear DLS bit */
	SPIx->SPIM &= (uint32_t)~((uint32_t)SPI_SPIM_DLS_Msk);
	/* Set new DLS bit value */
	SPIx->SPIM |= (uint32_t)SPI_DataSize;
}

/**
  * @brief  Selects the data transfer direction in bidirectional mode for the specified SPI.
  * @param  SPI_Direction: specifies the data transfer direction in bidirectional mode. 
  *          This parameter can be one of the following values:
  *            @arg SPI_Direction_Tx: Selects Tx transmission direction
  *            @arg SPI_Direction_Rx: Selects Rx receive direction
  * @retval None
  */
void SPI_BiDirectionalLineConfig(SPI_Type* SPIx,uint8_t SPI_Direction)
{
	/* Check the parameters */
    assert_param(IS_SPI_ALL_PERIPH(SPIx));
	assert_param(IS_SPI_DIRECTION(SPI_Direction));
	if (SPI_Direction == SPI_Direction_TxRx)
	{
		/* Set the Tx/Rx mode */
		SPIx->SPIM |= (uint32_t)SPI_Direction_TxRx;
	}
	else
	{
		/* Set the Rx only mode */
		SPIx->SPIM &= (uint32_t)SPI_Direction_Rx;
	}
}

/**
  * @}
  */

/** @defgroup SPI_Group2 Data transfers functions
 *  @brief   Data transfers functions
 *
@verbatim   
 ===============================================================================
                      ##### Data transfers functions #####
 ===============================================================================  

 [..] This section provides a set of functions allowing to manage the SPI data 
      transfers. In reception, data are received and then stored into an internal 
      Rx buffer while. In transmission, data are first stored into an internal Tx 
      buffer before being transmitted.

 [..] The read access of the SPI_SDRI register can be done using the SPI_I2S_ReceiveData()
      function and returns the Rx buffered value. Whereas a write access to the SPI_SDRO 
      can be done using SPI_I2S_SendData() function and stores the written data into 
      Tx buffer.

@endverbatim
  * @{
  */

/**
  * @brief  Returns the most recent received data by the SPI peripheral. 
  * @retval The value of the received data.
  */
uint16_t SPI_ReceiveData(SPI_Type* SPIx)
{
	/* Return the data in the DR register */
	return (uint16_t)SPIx->SDRI;
}

/**
  * @brief  Transmits a Data through the SPI peripheral. 
  * @param  Data: Data to be transmitted.
  * @retval None
  */
void SPI_SendData(SPI_Type* SPIx,uint16_t Data)
{
	/* Write in the DR register the data to be sent */
	SPIx->SDRO = Data;
}

/**
  * @brief  Transmits one Byte Data through the SPI peripheral. 
  * @param  Data: Data to be transmitted.
  * @retval tmp: Receive the data by transmit.
  */
uint8_t SPI_TransmitByte(SPI_Type* SPIx,uint8_t Data)
{
	uint8_t tmp;
	
	/* Write in the DR register the data to be sent */
	SPIx->SDRO = Data;
	
	/* Wait the Byte data transmit completed */
	while((SPIx->SPIM & ((uint16_t)SPI_SPIM_SPTF_Msk)) != RESET);
	
	/* Receive Byte data */
	tmp = (uint8_t)SPI_ReceiveData(SPIx);
	
	return tmp;
}


/**
  * @brief  Transmits one Byte Data through the SPI peripheral. 
  * @param  Data: Data to be transmitted.
  * @retval tmp: Receive the data by transmit.
  */
uint8_t SPI_ReceiveByte(SPI_Type* SPIx)
{
	uint8_t tmp;
	
	/* Write in the DR register the data to be sent */
	SPIx->SDRO = 0xFF;
	
	/* Wait the Byte data transmit completed */
	while((SPIx->SPIM & ((uint16_t)SPI_SPIM_SPTF_Msk)) != SET);
	
	/* Receive Byte data */
	tmp = (uint8_t)SPI_ReceiveData(SPIx);
	
	return tmp;
}

/**
  * @brief  Transmits one Word Data through the SPI peripheral. 
  * @param  Data: Data to be transmitted.
  * @retval tmp: Receive the data by transmit.
  */
uint16_t SPI_TransmitWord(SPI_Type* SPIx, uint16_t Data)
{
	uint16_t tmp;
	
	/* Write in the DR register the data to be sent */
	SPIx->SDRO = Data;
	
	/* Wait the Byte data transmit completed */
	while((SPIx->SPIM & ((uint16_t)SPI_SPIM_SPTF_Msk)) != RESET);
	
	/* Receive Byte data */
	tmp = (uint16_t)SPI_ReceiveData(SPIx);
	
	return tmp;
}

/**
  * @brief  Transmits one Word Data through the SPI peripheral. 
  * @param  Data: Data to be transmitted.
  * @retval tmp: Receive the data by transmit.
  */
uint16_t SPI_ReceiveWord(SPI_Type* SPIx)
{
	uint16_t tmp;
	
	/* Write in the DR register the data to be sent */
	SPIx->SDRO = 0xFFFF;
	
	/* Wait the Byte data transmit completed */
	while((SPIx->SPIM & ((uint16_t)SPI_SPIM_SPTF_Msk)) != SET);
	
	/* Receive Byte data */
	tmp = (uint16_t)SPI_ReceiveData(SPIx);
	
	return tmp;
}

/**
  * @brief  Checks whether the specified SPI flag is set or not.
  * @param  SPI_FLAG: specifies the SPI flag to check. 
  *          This parameter can be one of the following values:
  *            @arg SPI_FLAG_RXNE: Receive buffer not empty flag.
  * 		   @arg SPI_FLAG_RUNNING: Communication status flag.
  * @retval The new state of SPI_FLAG (SET or RESET).
  */
FlagStatus SPI_GetFlagStatus(SPI_Type* SPIx, uint8_t SPI_FLAG)
{
	FlagStatus bitstatus = RESET;
	/* Check the parameters */
    assert_param(IS_SPI_ALL_PERIPH(SPIx));
	assert_param(IS_SPI_GET_FLAG(SPI_FLAG));

	/* Check the status of the specified SPI flag */
	if ((SPIx->SPIS & SPI_FLAG) != (uint16_t)RESET)
	{
		/* SPI_I2S_FLAG is set */
		bitstatus = SET;
	}
	else
	{
		/* SPI_I2S_FLAG is reset */
		bitstatus = RESET;
	}
	/* Return the SPI_I2S_FLAG status */
	return  bitstatus;
}