fsl_flexio_spi.h

/*
 * Copyright (c) 2015, Freescale Semiconductor, Inc.
 * Copyright 2016-2020, 2022 NXP
 * All rights reserved.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */
 
#ifndef _FSL_FLEXIO_SPI_H_
#define _FSL_FLEXIO_SPI_H_
 
#include "fsl_common.h"
#include "fsl_flexio.h"
 
/*******************************************************************************
 * Definitions
 ******************************************************************************/
 
#define FSL_FLEXIO_SPI_DRIVER_VERSION (MAKE_VERSION(2, 3, 0))
#ifndef FLEXIO_SPI_DUMMYDATA
#define FLEXIO_SPI_DUMMYDATA (0xFFFFFFFFU)
#endif
 
#ifndef SPI_RETRY_TIMES
#define SPI_RETRY_TIMES 0U /* Define to zero means keep waiting until the flag is assert/deassert. */
#endif
 
#define FLEXIO_SPI_XFER_DATA_FORMAT(flag) ((flag) & (0x7U))
 
enum
{
    kStatus_FLEXIO_SPI_Busy  = MAKE_STATUS(kStatusGroup_FLEXIO_SPI, 1), 
    kStatus_FLEXIO_SPI_Idle  = MAKE_STATUS(kStatusGroup_FLEXIO_SPI, 2), 
    kStatus_FLEXIO_SPI_Error = MAKE_STATUS(kStatusGroup_FLEXIO_SPI, 3), 
    kStatus_FLEXIO_SPI_Timeout =
        MAKE_STATUS(kStatusGroup_FLEXIO_SPI, 4), 
};
 
typedef enum _flexio_spi_clock_phase
{
    kFLEXIO_SPI_ClockPhaseFirstEdge = 0x0U,  
    kFLEXIO_SPI_ClockPhaseSecondEdge = 0x1U, 
} flexio_spi_clock_phase_t;
 
typedef enum _flexio_spi_shift_direction
{
    kFLEXIO_SPI_MsbFirst = 0, 
    kFLEXIO_SPI_LsbFirst = 1, 
} flexio_spi_shift_direction_t;
 
typedef enum _flexio_spi_data_bitcount_mode
{
    kFLEXIO_SPI_8BitMode  = 0x08U, 
    kFLEXIO_SPI_16BitMode = 0x10U, 
    kFLEXIO_SPI_32BitMode = 0x20U, 
} flexio_spi_data_bitcount_mode_t;
 
enum _flexio_spi_interrupt_enable
{
    kFLEXIO_SPI_TxEmptyInterruptEnable = 0x1U, 
    kFLEXIO_SPI_RxFullInterruptEnable  = 0x2U, 
};
 
enum _flexio_spi_status_flags
{
    kFLEXIO_SPI_TxBufferEmptyFlag = 0x1U, 
    kFLEXIO_SPI_RxBufferFullFlag  = 0x2U, 
};
 
enum _flexio_spi_dma_enable
{
    kFLEXIO_SPI_TxDmaEnable  = 0x1U, 
    kFLEXIO_SPI_RxDmaEnable  = 0x2U, 
    kFLEXIO_SPI_DmaAllEnable = 0x3U, 
};
 
enum _flexio_spi_transfer_flags
{
    kFLEXIO_SPI_8bitMsb      = 0x0U, 
    kFLEXIO_SPI_8bitLsb      = 0x1U, 
    kFLEXIO_SPI_16bitMsb     = 0x2U, 
    kFLEXIO_SPI_16bitLsb     = 0x3U, 
    kFLEXIO_SPI_32bitMsb     = 0x4U, 
    kFLEXIO_SPI_32bitLsb     = 0x5U, 
    kFLEXIO_SPI_csContinuous = 0x8U, 
};
 
typedef struct _flexio_spi_type
{
    FLEXIO_Type *flexioBase; 
    uint8_t SDOPinIndex;     
    uint8_t SDIPinIndex;     
    uint8_t SCKPinIndex;     
    uint8_t CSnPinIndex;     
    uint8_t shifterIndex[2]; 
    uint8_t timerIndex[2];   
} FLEXIO_SPI_Type;
 
typedef struct _flexio_spi_master_config
{
    bool enableMaster;                        
    bool enableInDoze;                        
    bool enableInDebug;                       
    bool enableFastAccess;                    
    uint32_t baudRate_Bps;                    
    flexio_spi_clock_phase_t phase;           
    flexio_spi_data_bitcount_mode_t dataMode; 
} flexio_spi_master_config_t;
 
typedef struct _flexio_spi_slave_config
{
    bool enableSlave;                         
    bool enableInDoze;                        
    bool enableInDebug;                       
    bool enableFastAccess;                    
    flexio_spi_clock_phase_t phase;           
    flexio_spi_data_bitcount_mode_t dataMode; 
} flexio_spi_slave_config_t;
 
typedef struct _flexio_spi_transfer
{
    uint8_t *txData; 
    uint8_t *rxData; 
    size_t dataSize; 
    uint8_t flags;   
} flexio_spi_transfer_t;
 
typedef struct _flexio_spi_master_handle flexio_spi_master_handle_t;
 
typedef flexio_spi_master_handle_t flexio_spi_slave_handle_t;
 
typedef void (*flexio_spi_master_transfer_callback_t)(FLEXIO_SPI_Type *base,
                                                      flexio_spi_master_handle_t *handle,
                                                      status_t status,
                                                      void *userData);
 
typedef void (*flexio_spi_slave_transfer_callback_t)(FLEXIO_SPI_Type *base,
                                                     flexio_spi_slave_handle_t *handle,
                                                     status_t status,
                                                     void *userData);
 
struct _flexio_spi_master_handle
{
    uint8_t *txData;                                
    uint8_t *rxData;                                
    size_t transferSize;                            
    volatile size_t txRemainingBytes;               
    volatile size_t rxRemainingBytes;               
    volatile uint32_t state;                        
    uint8_t bytePerFrame;                           
    flexio_spi_shift_direction_t direction;         
    flexio_spi_master_transfer_callback_t callback; 
    void *userData;                                 
};
 
/*******************************************************************************
 * API
 ******************************************************************************/
 
#if defined(__cplusplus)
extern "C" {
#endif /*_cplusplus*/
 
void FLEXIO_SPI_MasterInit(FLEXIO_SPI_Type *base, flexio_spi_master_config_t *masterConfig, uint32_t srcClock_Hz);
 
void FLEXIO_SPI_MasterDeinit(FLEXIO_SPI_Type *base);
 
void FLEXIO_SPI_MasterGetDefaultConfig(flexio_spi_master_config_t *masterConfig);
 
void FLEXIO_SPI_SlaveInit(FLEXIO_SPI_Type *base, flexio_spi_slave_config_t *slaveConfig);
 
void FLEXIO_SPI_SlaveDeinit(FLEXIO_SPI_Type *base);
 
void FLEXIO_SPI_SlaveGetDefaultConfig(flexio_spi_slave_config_t *slaveConfig);
 
uint32_t FLEXIO_SPI_GetStatusFlags(FLEXIO_SPI_Type *base);
 
void FLEXIO_SPI_ClearStatusFlags(FLEXIO_SPI_Type *base, uint32_t mask);
 
void FLEXIO_SPI_EnableInterrupts(FLEXIO_SPI_Type *base, uint32_t mask);
 
void FLEXIO_SPI_DisableInterrupts(FLEXIO_SPI_Type *base, uint32_t mask);
 
void FLEXIO_SPI_EnableDMA(FLEXIO_SPI_Type *base, uint32_t mask, bool enable);
 
static inline uint32_t FLEXIO_SPI_GetTxDataRegisterAddress(FLEXIO_SPI_Type *base,
                                                           flexio_spi_shift_direction_t direction)
{
    if (direction == kFLEXIO_SPI_MsbFirst)
    {
        return FLEXIO_GetShifterBufferAddress(base->flexioBase, kFLEXIO_ShifterBufferBitSwapped,
                                              base->shifterIndex[0]) +
               3U;
    }
    else
    {
        return FLEXIO_GetShifterBufferAddress(base->flexioBase, kFLEXIO_ShifterBuffer, base->shifterIndex[0]);
    }
}
 
static inline uint32_t FLEXIO_SPI_GetRxDataRegisterAddress(FLEXIO_SPI_Type *base,
                                                           flexio_spi_shift_direction_t direction)
{
    if (direction == kFLEXIO_SPI_MsbFirst)
    {
        return FLEXIO_GetShifterBufferAddress(base->flexioBase, kFLEXIO_ShifterBufferBitSwapped, base->shifterIndex[1]);
    }
    else
    {
        return FLEXIO_GetShifterBufferAddress(base->flexioBase, kFLEXIO_ShifterBuffer, base->shifterIndex[1]) + 3U;
    }
}
 
static inline void FLEXIO_SPI_Enable(FLEXIO_SPI_Type *base, bool enable)
{
    if (enable)
    {
        base->flexioBase->CTRL |= FLEXIO_CTRL_FLEXEN_MASK;
    }
}
 
void FLEXIO_SPI_MasterSetBaudRate(FLEXIO_SPI_Type *base, uint32_t baudRate_Bps, uint32_t srcClockHz);
 
static inline void FLEXIO_SPI_WriteData(FLEXIO_SPI_Type *base, flexio_spi_shift_direction_t direction, uint32_t data)
{
    if (direction == kFLEXIO_SPI_MsbFirst)
    {
        base->flexioBase->SHIFTBUFBBS[base->shifterIndex[0]] = data;
    }
    else
    {
        base->flexioBase->SHIFTBUF[base->shifterIndex[0]] = data;
    }
}
 
static inline uint32_t FLEXIO_SPI_ReadData(FLEXIO_SPI_Type *base, flexio_spi_shift_direction_t direction)
{
    if (direction == kFLEXIO_SPI_MsbFirst)
    {
        return (uint32_t)(base->flexioBase->SHIFTBUFBIS[base->shifterIndex[1]]);
    }
    else
    {
        return (uint32_t)(base->flexioBase->SHIFTBUFBYS[base->shifterIndex[1]]);
    }
}
 
status_t FLEXIO_SPI_WriteBlocking(FLEXIO_SPI_Type *base,
                                  flexio_spi_shift_direction_t direction,
                                  const uint8_t *buffer,
                                  size_t size);
 
status_t FLEXIO_SPI_ReadBlocking(FLEXIO_SPI_Type *base,
                                 flexio_spi_shift_direction_t direction,
                                 uint8_t *buffer,
                                 size_t size);
 
status_t FLEXIO_SPI_MasterTransferBlocking(FLEXIO_SPI_Type *base, flexio_spi_transfer_t *xfer);
 
void FLEXIO_SPI_FlushShifters(FLEXIO_SPI_Type *base);
/*Transactional APIs*/
 
status_t FLEXIO_SPI_MasterTransferCreateHandle(FLEXIO_SPI_Type *base,
                                               flexio_spi_master_handle_t *handle,
                                               flexio_spi_master_transfer_callback_t callback,
                                               void *userData);
 
status_t FLEXIO_SPI_MasterTransferNonBlocking(FLEXIO_SPI_Type *base,
                                              flexio_spi_master_handle_t *handle,
                                              flexio_spi_transfer_t *xfer);
 
void FLEXIO_SPI_MasterTransferAbort(FLEXIO_SPI_Type *base, flexio_spi_master_handle_t *handle);
 
status_t FLEXIO_SPI_MasterTransferGetCount(FLEXIO_SPI_Type *base, flexio_spi_master_handle_t *handle, size_t *count);
 
void FLEXIO_SPI_MasterTransferHandleIRQ(void *spiType, void *spiHandle);
 
status_t FLEXIO_SPI_SlaveTransferCreateHandle(FLEXIO_SPI_Type *base,
                                              flexio_spi_slave_handle_t *handle,
                                              flexio_spi_slave_transfer_callback_t callback,
                                              void *userData);
 
status_t FLEXIO_SPI_SlaveTransferNonBlocking(FLEXIO_SPI_Type *base,
                                             flexio_spi_slave_handle_t *handle,
                                             flexio_spi_transfer_t *xfer);
 
static inline void FLEXIO_SPI_SlaveTransferAbort(FLEXIO_SPI_Type *base, flexio_spi_slave_handle_t *handle)
{
    FLEXIO_SPI_MasterTransferAbort(base, handle);
}
static inline status_t FLEXIO_SPI_SlaveTransferGetCount(FLEXIO_SPI_Type *base,
                                                        flexio_spi_slave_handle_t *handle,
                                                        size_t *count)
{
    return FLEXIO_SPI_MasterTransferGetCount(base, handle, count);
}
 
void FLEXIO_SPI_SlaveTransferHandleIRQ(void *spiType, void *spiHandle);
 
#if defined(__cplusplus)
}
#endif /*_cplusplus*/
#endif /*_FSL_FLEXIO_SPI_H_*/