spi_master.c

Go to the documentation of this file.

/*
 * Support and FAQ: visit <a href="https://www.microchip.com/support/">Microchip Support</a>
 */

#include "spi_master.h"
#if SAMG55
#include "flexcom.h"
#include "conf_board.h"
#endif

#define MAX_NUM_WITH_DECODER 0x10

#define MAX_NUM_WITHOUT_DECODER 0x04

#define NONE_CHIP_SELECT_ID 0x0f

#define DEFAULT_CHIP_ID 0

void spi_master_init(Spi *p_spi)
{
#if SAMG55
        flexcom_enable(BOARD_FLEXCOM_SPI);
        flexcom_set_opmode(BOARD_FLEXCOM_SPI, FLEXCOM_SPI);
#else
        spi_enable_clock(p_spi);
#endif
        spi_reset(p_spi);
        spi_set_master_mode(p_spi);
        spi_disable_mode_fault_detect(p_spi);
        spi_disable_loopback(p_spi);
        spi_set_peripheral_chip_select_value(p_spi, DEFAULT_CHIP_ID);
        spi_set_fixed_peripheral_select(p_spi);
        spi_disable_peripheral_select_decode(p_spi);
        spi_set_delay_between_chip_select(p_spi, CONFIG_SPI_MASTER_DELAY_BCS);
}

void spi_master_setup_device(Spi *p_spi, struct spi_device *device,
                spi_flags_t flags, uint32_t baud_rate, board_spi_select_id_t sel_id)
{
#if (SAM4L)
    int16_t baud_div = spi_calc_baudrate_div(baud_rate, sysclk_get_pba_hz());
#else
        int16_t baud_div = spi_calc_baudrate_div(baud_rate, sysclk_get_peripheral_hz());
#endif
        /* avoid Cppcheck Warning */
        UNUSED(sel_id);
        if (-1 == baud_div) {
                Assert(0 == "Failed to find baudrate divider");
        }
        spi_set_transfer_delay(p_spi, device->id, CONFIG_SPI_MASTER_DELAY_BS,
                        CONFIG_SPI_MASTER_DELAY_BCT);
        spi_set_bits_per_transfer(p_spi, device->id,
                        CONFIG_SPI_MASTER_BITS_PER_TRANSFER);
        spi_set_baudrate_div(p_spi, device->id, baud_div);
        spi_configure_cs_behavior(p_spi, device->id, SPI_CS_KEEP_LOW);
        spi_set_clock_polarity(p_spi, device->id, flags >> 1);
        spi_set_clock_phase(p_spi, device->id, ((flags & 0x1) ^ 0x1));
}

void spi_select_device(Spi *p_spi, struct spi_device *device)
{
        if (spi_get_peripheral_select_decode_setting(p_spi)) {
                if (device->id < MAX_NUM_WITH_DECODER) {
                        spi_set_peripheral_chip_select_value(p_spi, device->id);
                }
        } else {
                if (device->id < MAX_NUM_WITHOUT_DECODER) {
                        spi_set_peripheral_chip_select_value(p_spi, (~(1 << device->id)));
                }
        }
}

void spi_deselect_device(Spi *p_spi, struct spi_device *device)
{
        /* avoid Cppcheck Warning */
        UNUSED(device);
        while (!spi_is_tx_empty(p_spi)) {
        }

        // Assert all lines; no peripheral is selected.
        spi_set_peripheral_chip_select_value(p_spi, NONE_CHIP_SELECT_ID);

        // Last transfer, so de-assert the current NPCS if CSAAT is set.
        spi_set_lastxfer(p_spi);

}

status_code_t spi_write_packet(Spi *p_spi, const uint8_t *data,
                size_t len)
{
        uint32_t timeout = SPI_TIMEOUT;
        uint32_t i = 0;
        uint8_t val;

        while (len) {
                timeout = SPI_TIMEOUT;
                while (!spi_is_tx_ready(p_spi)) {
                        if (!timeout--) {
                                return ERR_TIMEOUT;
                        }
                }
                val = data[i];
                spi_write_single(p_spi, val);
                i++;
                len--;
        }

        return STATUS_OK;
}

status_code_t spi_read_packet(Spi *p_spi, uint8_t *data, size_t len)
{
        uint32_t timeout = SPI_TIMEOUT;
        uint8_t val;
        uint32_t i = 0;

        while (len) {
                timeout = SPI_TIMEOUT;
                while (!spi_is_tx_ready(p_spi)) {
                        if (!timeout--) {
                                return ERR_TIMEOUT;
                        }
                }
                spi_write_single(p_spi, CONFIG_SPI_MASTER_DUMMY);

                timeout = SPI_TIMEOUT;
                while (!spi_is_rx_ready(p_spi)) {
                        if (!timeout--) {
                                return ERR_TIMEOUT;
                        }
                }
                spi_read_single(p_spi, &val);

                data[i] = val;
                i++;
                len--;
        }

        return STATUS_OK;
}

status_code_t spi_transceive_packet(Spi *p_spi, uint8_t *tx_data, uint8_t *rx_data, size_t len)
{
        uint32_t timeout = SPI_TIMEOUT;
        uint8_t val;
        uint32_t i = 0;

        while (len) {
                timeout = SPI_TIMEOUT;
                while (!spi_is_tx_ready(p_spi)) {
                        if (!timeout--) {
                                return ERR_TIMEOUT;
                        }
                }
                spi_write_single(p_spi, tx_data[i]);

                timeout = SPI_TIMEOUT;
                while (!spi_is_rx_ready(p_spi)) {
                        if (!timeout--) {
                                return ERR_TIMEOUT;
                        }
                }
                spi_read_single(p_spi, &val);

                rx_data[i] = val;
                i++;
                len--;
        }

        return STATUS_OK;
}