include/spi/spi_mega_xmega.h

Go to the documentation of this file.

#ifndef SPI_SPI_MEGA_XMEGA_H_INCLUDED
#define SPI_SPI_MEGA_XMEGA_H_INCLUDED

#include <assert.h>
#include <stdbool.h>
#include <buffer.h>
#include <board/spi.h>

void spi_priv_master_init(spi_id_t spi_id, struct spi_master *master);

void spi_priv_master_setup_device(spi_id_t spi_id, struct spi_device *device,
                spi_flags_t flags, unsigned long baud_rate,
                board_spi_select_id_t sel_id);

void spi_priv_select_device(struct spi_master *master,
                struct spi_device *device);

void spi_priv_deselect_device(struct spi_master *master,
                struct spi_device *device);

#define spi_id_is_valid(spi_id) (spi_id <= SPI_ID_LAST)

#define SPI_MASTER_TYPE_NAME(spi_id)    spi_master_type##spi_id

#define DECLARE_SPI_MASTER(spi_id, varname) \
        struct SPI_MASTER_TYPE_NAME(spi_id) varname

#if SPI_ID_NATIVE_IS_ENABLED && !SPI_ID_UART_IS_ENABLED
# define SPI_MUX(spi_id, native, uart) native
#elif SPI_ID_UART_IS_ENABLED && !SPI_ID_NATIVE_IS_ENABLED
# define SPI_MUX(spi_id, native, uart) uart
#elif SPI_ID_NATIVE_IS_ENABLED && SPI_ID_UART_IS_ENABLED
# define SPI_MUX(spi_id, native, uart)  \
        if (spi_id < SPI_ID_UART_FIRST) \
                native;                 \
        else                            \
                uart
#else
# error No SPI ID enabled!
#endif

static inline struct spi_master *spi_master_get_base(spi_id_t spi_id,
                void *priv)
{
        assert(spi_id_is_valid(spi_id));

        SPI_MUX(spi_id,
                return SPI_MASTER_NATIVE_GET_BASE(priv),
                return NULL);
}

static inline size_t spi_master_get_size(spi_id_t spi_id)
{
        assert(spi_id_is_valid(spi_id));

        SPI_MUX(spi_id,
                return sizeof(struct SPI_MASTER_NATIVE_TYPE),
                return 0);
}

#define SPI_DEVICE_TYPE_NAME(spi_id)    spi_device_type##spi_id

#define DECLARE_SPI_DEVICE(spi_id, varname) \
        struct SPI_DEVICE_TYPE_NAME(spi_id) varname

static inline struct spi_device *spi_device_get_base(spi_id_t spi_id,
                void *priv)
{
        assert(spi_id_is_valid(spi_id));

        SPI_MUX(spi_id,
                return SPI_DEVICE_NATIVE_GET_BASE(priv),
                return NULL);
}

static inline size_t spi_device_get_size(spi_id_t spi_id)
{
        assert(spi_id_is_valid(spi_id));

        SPI_MUX(spi_id,
                return sizeof(struct SPI_DEVICE_NATIVE_TYPE),
                return 0);
}

static inline void spi_enable(spi_id_t spi_id)
{
        assert(spi_id_is_valid(spi_id));

        SPI_MUX(spi_id,
                spi_priv_enable(spi_id),
                do {} while (0));
}

static inline void spi_disable(spi_id_t spi_id)
{
        assert(spi_id_is_valid(spi_id));

        SPI_MUX(spi_id,
                spi_priv_disable(spi_id),
                do {} while (0));
}

static inline bool spi_is_enabled(spi_id_t spi_id)
{
        assert(spi_id_is_valid(spi_id));

        SPI_MUX(spi_id,
                return spi_priv_is_enabled(spi_id),
                return false);
}

static inline void spi_master_init(spi_id_t spi_id,
                struct spi_master *spi_master)
{
        SPI_MUX(spi_id,
                spi_priv_master_init(spi_id, spi_master),
                do {} while (0));
}

static inline void spi_master_setup_device(spi_id_t spi_id,
                struct spi_master *spi_master, struct spi_device *spi_device,
                spi_flags_t flags, unsigned long baud_rate,
                board_spi_select_id_t sel_id)
{
        SPI_MUX(spi_id,
                spi_priv_master_setup_device(spi_id, spi_device, flags,
                                baud_rate, sel_id),
                do {} while (0));
}

static inline void spi_select_device(spi_id_t spi_id,
                struct spi_master *master, struct spi_device *device)
{
        SPI_MUX(spi_id,
                spi_priv_select_device(master, device),
                do {} while (0));
}

static inline void spi_deselect_device(spi_id_t spi_id,
                struct spi_master *master, struct spi_device *device)
{
        SPI_MUX(spi_id,
                spi_priv_deselect_device(master, device),
                do {} while (0));
}

static inline void spi_write(spi_id_t spi_id, struct spi_master *master,
                const uint8_t *data, size_t len)
{
        spi_polled_write(master, data, len);
}

static inline void spi_read(spi_id_t spi_id, struct spi_master *master,
                uint8_t *data, size_t len)
{
        spi_polled_read(master, data, len);
}

static inline void spi_exchange(spi_id_t spi_id, struct spi_master *master,
                const uint8_t *write, uint8_t *read, size_t len)
{
        spi_polled_exchange(master, write, read, len);
}

static inline void spi_write_buf_list(spi_id_t spi_id,
                struct spi_master *master, struct slist *buf_list)
{
        spi_polled_write_buf_list(master, buf_list);
}

static inline void spi_read_buf_list(spi_id_t spi_id,
                struct spi_master *master, struct slist *buf_list)
{
        spi_polled_read_buf_list(master, buf_list);
}

static inline void spi_exchange_buf_list(spi_id_t spi_id,
                struct spi_master *master, struct slist *write_buf_list,
                struct slist *read_buf_list)
{
        spi_polled_exchange_buf_list(master, write_buf_list, read_buf_list);
}

#endif /* SPI_SPI_MEGA_XMEGA_H_INCLUDED */

---