spi.h

 
/******************************************************************************
 *
 * Copyright (C) 2022-2023 Maxim Integrated Products, Inc. (now owned by 
 * Analog Devices, Inc.),
 * Copyright (C) 2023-2024 Analog Devices, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 ******************************************************************************/
#ifndef LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_SPI_H_
#define LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_SPI_H_
 
/***** includes *******/
#include <stdbool.h>
#include "spi_regs.h"
#include "mxc_sys.h"
#include "mxc_assert.h"
#include "gpio.h"
#include "mxc_pins.h"
#include "mxc_lock.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
/***** Definitions *****/
 
typedef enum {
    SPI_WIDTH_3WIRE, 
    SPI_WIDTH_STANDARD, 
    SPI_WIDTH_DUAL, 
    SPI_WIDTH_QUAD, 
} mxc_spi_width_t;
 
typedef enum {
    SPI_MODE_0, 
    SPI_MODE_1, 
    SPI_MODE_2, 
    SPI_MODE_3, 
} mxc_spi_mode_t;
 
typedef struct _mxc_spi_pins_t mxc_spi_pins_t;
 
struct _mxc_spi_pins_t {
    bool clock; 
    bool ss0; 
    bool ss1; 
    bool ss2; 
    bool miso; 
    bool mosi; 
    bool sdio2; 
    bool sdio3; 
    bool vddioh; 
};
 
typedef struct _mxc_spi_req_t mxc_spi_req_t;
typedef void (*spi_complete_cb_t)(void *req, int result);
 
struct _mxc_spi_req_t {
    mxc_spi_regs_t *spi; 
    int ssIdx; 
    int ssDeassert; 
    uint8_t *txData; 
    uint8_t *rxData; 
    uint32_t txLen; 
    uint32_t rxLen; 
    uint32_t txCnt; 
    uint32_t rxCnt; 
 
    spi_complete_cb_t completeCB; 
};
 
/* ************************************************************************* */
/* Control/Configuration functions                                           */
/* ************************************************************************* */
 
int MXC_SPI_Init(mxc_spi_regs_t *spi, int masterMode, int quadModeUsed, int numSlaves,
                 unsigned ssPolarity, unsigned int hz, mxc_spi_pins_t pins);
 
int MXC_SPI_Shutdown(mxc_spi_regs_t *spi);
 
int MXC_SPI_ReadyForSleep(mxc_spi_regs_t *spi);
 
int MXC_SPI_GetPeripheralClock(mxc_spi_regs_t *spi);
 
int MXC_SPI_SetFrequency(mxc_spi_regs_t *spi, unsigned int hz);
 
unsigned int MXC_SPI_GetFrequency(mxc_spi_regs_t *spi);
 
int MXC_SPI_SetDataSize(mxc_spi_regs_t *spi, int dataSize);
 
int MXC_SPI_GetDataSize(mxc_spi_regs_t *spi);
 
/* ************************************************************************* */
/* Low-level functions                                                       */
/* ************************************************************************* */
 
int MXC_SPI_SetSlave(mxc_spi_regs_t *spi, int ssIdx);
 
int MXC_SPI_GetSlave(mxc_spi_regs_t *spi);
 
int MXC_SPI_SetWidth(mxc_spi_regs_t *spi, mxc_spi_width_t spiWidth);
 
mxc_spi_width_t MXC_SPI_GetWidth(mxc_spi_regs_t *spi);
 
int MXC_SPI_SetMode(mxc_spi_regs_t *spi, mxc_spi_mode_t spiMode);
 
mxc_spi_mode_t MXC_SPI_GetMode(mxc_spi_regs_t *spi);
 
int MXC_SPI_StartTransmission(mxc_spi_regs_t *spi);
 
int MXC_SPI_GetActive(mxc_spi_regs_t *spi);
 
int MXC_SPI_AbortTransmission(mxc_spi_regs_t *spi);
 
unsigned int MXC_SPI_ReadRXFIFO(mxc_spi_regs_t *spi, unsigned char *bytes, unsigned int len);
 
unsigned int MXC_SPI_GetRXFIFOAvailable(mxc_spi_regs_t *spi);
 
unsigned int MXC_SPI_WriteTXFIFO(mxc_spi_regs_t *spi, unsigned char *bytes, unsigned int len);
 
unsigned int MXC_SPI_GetTXFIFOAvailable(mxc_spi_regs_t *spi);
 
void MXC_SPI_ClearRXFIFO(mxc_spi_regs_t *spi);
 
void MXC_SPI_ClearTXFIFO(mxc_spi_regs_t *spi);
 
int MXC_SPI_SetRXThreshold(mxc_spi_regs_t *spi, unsigned int numBytes);
 
unsigned int MXC_SPI_GetRXThreshold(mxc_spi_regs_t *spi);
 
int MXC_SPI_SetTXThreshold(mxc_spi_regs_t *spi, unsigned int numBytes);
 
unsigned int MXC_SPI_GetTXThreshold(mxc_spi_regs_t *spi);
 
unsigned int MXC_SPI_GetFlags(mxc_spi_regs_t *spi);
 
void MXC_SPI_ClearFlags(mxc_spi_regs_t *spi);
 
void MXC_SPI_EnableInt(mxc_spi_regs_t *spi, unsigned int intEn);
 
void MXC_SPI_DisableInt(mxc_spi_regs_t *spi, unsigned int intDis);
 
/* ************************************************************************* */
/* Transaction level functions                                               */
/* ************************************************************************* */
 
int MXC_SPI_MasterTransaction(mxc_spi_req_t *req);
 
int MXC_SPI_MasterTransactionAsync(mxc_spi_req_t *req);
 
int MXC_SPI_MasterTransactionDMA(mxc_spi_req_t *req);
 
int MXC_SPI_SlaveTransaction(mxc_spi_req_t *req);
 
int MXC_SPI_SlaveTransactionAsync(mxc_spi_req_t *req);
 
int MXC_SPI_SlaveTransactionDMA(mxc_spi_req_t *req);
 
int MXC_SPI_SetDefaultTXData(mxc_spi_regs_t *spi, unsigned int defaultTXData);
 
void MXC_SPI_AbortAsync(mxc_spi_regs_t *spi);
 
void MXC_SPI_AsyncHandler(mxc_spi_regs_t *spi);
 
void MXC_SPI_HWSSControl(mxc_spi_regs_t *spi, int state);
 
#ifdef __cplusplus
}
#endif
 
#endif // LIBRARIES_PERIPHDRIVERS_INCLUDE_MAX32680_SPI_H_