rt-thread/bsp/CME_M7/StdPeriph_Driver/inc/cmem7_spi.h

/**
    *****************************************************************************
    * @file     cmem7_spi.h
    *
    * @brief    CMEM7 SPI header file
    *
    *
    * @version  V1.0
    * @date     3. September 2013
    *
    * @note
    *
    *****************************************************************************
    * @attention
    *
    * THE PRESENT FIRMWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS
    * WITH CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE
    * TIME. AS A RESULT, CAPITAL-MICRO SHALL NOT BE HELD LIABLE FOR ANY DIRECT,
    * INDIRECT OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING
    * FROM THE CONTENT OF SUCH FIRMWARE AND/OR THE USE MADE BY CUSTOMERS OF THE
    * CODING INFORMATION CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS.
    *
    * <h2><center>&copy; COPYRIGHT 2013 Capital-micro </center></h2>
    *****************************************************************************
    */

#ifndef __CMEM7_SPI_H
#define __CMEM7_SPI_H

#ifdef __cplusplus
 extern "C" {
#endif

/* Includes ------------------------------------------------------------------*/
#include "cmem7.h"
#include "cmem7_conf.h"


#define IS_SPI_ALL_PERIPH(PERIPH) (((PERIPH) == SPI0) || \
                                   ((PERIPH) == SPI1))


/** @defgroup SPI_MODE
  * @{
  */
#define SPI_MODE_CPOL_0_CPHA_0         0    /*!< CPOL : Idle clock level is low level.
                                                                                                 CPHA : Capture data at the first edge */
#define SPI_MODE_CPOL_0_CPHA_1         1        /*!< CPOL : Idle clock level is low level.
                                                                                                 CPHA : Capture data at the second edge */
#define SPI_MODE_CPOL_1_CPHA_0         2        /*!< CPOL : Idle clock level is high level.
                                                                                                 CPHA : Capture data at the first edge */
#define SPI_MODE_CPOL_1_CPHA_1         3        /*!< CPOL : Idle clock level is high level.
                                                                                                 CPHA : Capture data at the first edge */
#define IS_SPI_MODE(MODE)              (((MODE) == SPI_MODE_CPOL_0_CPHA_0) || \
                                        ((MODE) == SPI_MODE_CPOL_0_CPHA_1) || \
                                        ((MODE) == SPI_MODE_CPOL_1_CPHA_0) || \
                                                                                ((MODE) == SPI_MODE_CPOL_1_CPHA_1))
/**
  * @}
  */

/** @defgroup SPI_INT
  * @{
  */
#define SPI_INT_RX_FIFO_UNDERFLOW      0x00000001
#define SPI_INT_RX_FIFO_OVERFLOW       0x00000002
#define SPI_INT_RX_FIFO_ALMOST_FULL    0x00000004
#define SPI_INT_TX_FIFO_UNDERFLOW      0x00000008
#define SPI_INT_TX_FIFO_OVERFLOW       0x00000010
#define SPI_INT_TX_FIFO_ALMOST_FULL    0x00000020
#define SPI_INT_DONE                   0x00000040
#define SPI_INT_ALL                    0x0000007F

#define IS_SPI_INT(INT)                (((INT) != 0) && (((INT) & ~SPI_INT_ALL) == 0))
/**
  * @}
  */

/**
  * @brief  SPI initialization structure
    */
typedef struct
{
  uint8_t SPI_Mode;                 /*!< indicates SPI's CPOL and CPHA, ref as @ref SPI_MODE */
  BOOL SPI_RxEn;                    /*!< indicates if SPI receiver is enabled or not */
  uint8_t SPI_BitLength;            /*!< bit length while transmitting and receiving */
  uint8_t SPI_Gap;                  /*!< cycle number between continuous data frame */
    uint8_t SPI_ClockDividor;         /*!< SPI clock dividor, 1 / ((1 + DIV) * 2) */
} SPI_InitTypeDef;
/**
  * @}
  */

/**
  * @brief  SPI initialization
  * @note   This function should be called at first before any other interfaces.
    * @param[in] SPIx SPI peripheral, which is SPI0 or SPI1
    * @param[in] init A pointer to structure SPI_InitTypeDef
  * @retval None
    */
void SPI_Init(SPI0_Type* SPIx, SPI_InitTypeDef *init);

/**
  * @brief  Enable or disable SPI.
    * @param[in] SPIx SPI peripheral, which is SPI0 or SPI1
    * @param[in] Enable The bit indicates if the specific SPI is enable or not
  * @retval None
    */
void SPI_Enable(SPI0_Type* SPIx, BOOL enable);

/**
  * @brief  Enable or disable SPI interrupt.
    * @param[in] SPIx SPI peripheral, which is SPI0 or SPI1
    * @param[in] Int interrupt mask bits, which can be the combination of @ref SPI_Int
    * @param[in] Enable The bit indicates if specific interrupts are enable or not
  * @retval None
    */
void SPI_EnableInt(SPI0_Type* SPIx, uint32_t Int, BOOL enable);

/**
  * @brief  Check specific interrupts are set or not
    * @param[in] SPIx SPI peripheral, which is SPI0 or SPI1
    * @param[in] Int interrupt mask bits, which can be the combination of @ref SPI_Int
  * @retval BOOL The bit indicates if specific interrupts are set or not
    */
BOOL SPI_GetIntStatus(SPI0_Type* SPIx, uint32_t Int);

/**
  * @brief  Clear specific interrupts
    * @param[in] SPIx SPI peripheral, which is SPI0 or SPI1
    * @param[in] Int interrupt mask bits, which can be the combination of @ref SPI_Int
  * @retval None
    */
void SPI_ClearInt(SPI0_Type* SPIx, uint32_t Int);

/**
  * @brief  Read data from SPI FIFO
    * @param[in] SPIx SPI peripheral, which is SPI0 or SPI1
    * @param[in] size Expected data size to be read
    * @param[out] data A user-allocated buffer to fetch data to be read
  * @retval uint8_t Actual read data size
    */
uint8_t SPI_ReadFifo(SPI0_Type* SPIx, uint8_t size, uint32_t* data);

/**
  * @brief  Write data to SPI FIFO
    * @param[in] SPIx SPI peripheral, which is SPI0 or SPI1
    * @param[in] size Expected data size to be written
    * @param[in] data A pointer to the data to be written
  * @retval uint8_t Actual written data size
    */
uint8_t SPI_WriteFifo(SPI0_Type* SPIx, uint8_t Size, uint32_t* data);

/**
  * @brief  send a SPI transcation request
    * @param[in] SPIx SPI peripheral, which is SPI0 or SPI1
    * @param[in] size Expected data size to be written and read
    * @retval BOOL The bit indicates if the request is sent
    */
BOOL SPI_Transcation(SPI0_Type* SPIx, uint8_t size);

#ifdef __cplusplus
}
#endif

#endif /*__CMEM7_SPI_H */