drivers/serial/spi/spi_polled_buf_list.c

Go to the documentation of this file.

#include <assert.h>
#include <bitops.h>
#include <spi.h>
#include <board/spi.h>

void spi_polled_next_buffer(struct workqueue_task *task)
{
        struct spi_master_polled *spim_poll =
                container_of(task, struct spi_master_polled, poll_next_buffer);
        struct spi_master        *spim = &spim_poll->base;
        size_t                   len = 0;
        uint8_t                  tx_byte = 0;

        if (test_bit(SPI_OP_READ, &spim_poll->op)) {
                if (slist_node_is_last(spim_poll->read_buf_list,
                                        &spim_poll->read_buffer->node))
                        goto done;
                spim_poll->read_buffer =
                        buf_list_peek_next(spim_poll->read_buffer);
                spim_poll->read_data = spim_poll->read_buffer->addr.ptr;
                len = spim_poll->read_buffer->len;
        }
        if (test_bit(SPI_OP_WRITE, &spim_poll->op)) {
                if (slist_node_is_last(spim_poll->write_buf_list,
                                        &spim_poll->write_buffer->node))
                        goto done;
                spim_poll->write_buffer =
                        buf_list_peek_next(spim_poll->write_buffer);
                tx_byte = *(uint8_t *)spim_poll->write_buffer->addr.ptr;
                spim_poll->write_data =
                        (uint8_t *)spim_poll->write_buffer->addr.ptr + 1;
                len = spim_poll->write_buffer->len;
        }
        spi_polled_start(spim, tx_byte, len);
        return;

done:
        spim->residue = 0;
        spim->status = STATUS_OK;
        workqueue_add_task(&main_workqueue, spim->nwq.current);
}

void spi_polled_write_buf_list(struct spi_master *spim, struct slist *buf_list)
{
        struct spi_master_polled *spim_poll = spi_master_polled_of(spim);
        struct buffer            *buffer;
        const uint8_t            *write;

        buffer = buf_list_peek_head(buf_list);
        write = buffer->addr.ptr;
        spim_poll->op = (1 << SPI_OP_WRITE) | (1 << SPI_OP_BUFFER);
        spim_poll->write_data = write + 1;
        spim_poll->write_buffer = buffer;
        spim_poll->write_buf_list = buf_list;
        spi_polled_start(spim, *write, buffer->len);
}

void spi_polled_read_buf_list(struct spi_master *spim, struct slist *buf_list)
{
        struct spi_master_polled *spim_poll = spi_master_polled_of(spim);
        struct buffer            *buffer;

        buffer = buf_list_peek_head(buf_list);
        spim_poll->op = (1 << SPI_OP_READ) | (1 << SPI_OP_BUFFER);
        spim_poll->read_data = buffer->addr.ptr;
        spim_poll->read_buffer = buffer;
        spim_poll->read_buf_list = buf_list;
        spi_polled_start(spim, 0, buffer->len);
}

void spi_polled_exchange_buf_list(struct spi_master *spim,
                struct slist *write_buf_list,
                struct slist *read_buf_list)
{
        struct spi_master_polled *spim_poll = spi_master_polled_of(spim);
        struct buffer            *write_buffer;
        struct buffer            *read_buffer;
        const uint8_t            *write;

        assert(!slist_is_empty(write_buf_list));
        assert(!slist_is_empty(read_buf_list));

        write_buffer = buf_list_peek_head(write_buf_list);
        read_buffer = buf_list_peek_head(read_buf_list);

        assert(write_buffer->len == read_buffer->len);

        write = write_buffer->addr.ptr;
        spim_poll->op = (1 << SPI_OP_WRITE) | (1 << SPI_OP_READ) |
                (1 << SPI_OP_BUFFER);
        spim_poll->write_data = write + 1;
        spim_poll->read_data = read_buffer->addr.ptr;
        spim_poll->write_buffer = write_buffer;
        spim_poll->write_buf_list = write_buf_list;
        spim_poll->read_buffer = write_buffer;
        spim_poll->read_buf_list = write_buf_list;
        spi_polled_start(spim, *write, write_buffer->len);
}

---