mb/google/brya/var/orisa: Update Type C DisplayPort HPD Configuration

[coreboot2.git] / src / soc / nvidia / tegra124 / spi.c

/* SPDX-License-Identifier: GPL-2.0-only */
/* NVIDIA Tegra SPI controller (T114 and later) */

#include <arch/cache.h>
#include <device/mmio.h>
#include <assert.h>
#include <console/console.h>
#include <delay.h>
#include <soc/addressmap.h>
#include <soc/dma.h>
#include <soc/spi.h>
#include <spi-generic.h>
#include <spi_flash.h>
#include <timer.h>
#include <types.h>

#if defined(CONFIG_DEBUG_SPI) && CONFIG_DEBUG_SPI
# define DEBUG_SPI(x,...)       printk(BIOS_DEBUG, "TEGRA_SPI: " x)
#else
# define DEBUG_SPI(x,...)
#endif

/*
 * 64 packets in FIFO mode, BLOCK_SIZE packets in DMA mode. Packets can vary
 * in size from 4 to 32 bits. To keep things simple we'll use 8-bit packets.
 */
#define SPI_PACKET_SIZE_BYTES           1
#define SPI_MAX_TRANSFER_BYTES_FIFO     (64 * SPI_PACKET_SIZE_BYTES)
#define SPI_MAX_TRANSFER_BYTES_DMA      (65535 * SPI_PACKET_SIZE_BYTES)

/*
 * This is used to workaround an issue seen where it may take some time for
 * packets to show up in the FIFO after they have been received and the
 * BLOCK_COUNT has been incremented.
 */
#define SPI_FIFO_XFER_TIMEOUT_US        1000

/* COMMAND1 */
#define SPI_CMD1_GO                     (1 << 31)
#define SPI_CMD1_M_S                    (1 << 30)
#define SPI_CMD1_MODE_MASK              0x3
#define SPI_CMD1_MODE_SHIFT             28
#define SPI_CMD1_CS_SEL_MASK            0x3
#define SPI_CMD1_CS_SEL_SHIFT           26
#define SPI_CMD1_CS_POL_INACTIVE3       (1 << 25)
#define SPI_CMD1_CS_POL_INACTIVE2       (1 << 24)
#define SPI_CMD1_CS_POL_INACTIVE1       (1 << 23)
#define SPI_CMD1_CS_POL_INACTIVE0       (1 << 22)
#define SPI_CMD1_CS_SW_HW               (1 << 21)
#define SPI_CMD1_CS_SW_VAL              (1 << 20)
#define SPI_CMD1_IDLE_SDA_MASK          0x3
#define SPI_CMD1_IDLE_SDA_SHIFT         18
#define SPI_CMD1_BIDIR                  (1 << 17)
#define SPI_CMD1_LSBI_FE                (1 << 16)
#define SPI_CMD1_LSBY_FE                (1 << 15)
#define SPI_CMD1_BOTH_EN_BIT            (1 << 14)
#define SPI_CMD1_BOTH_EN_BYTE           (1 << 13)
#define SPI_CMD1_RX_EN                  (1 << 12)
#define SPI_CMD1_TX_EN                  (1 << 11)
#define SPI_CMD1_PACKED                 (1 << 5)
#define SPI_CMD1_BIT_LEN_MASK           0x1f
#define SPI_CMD1_BIT_LEN_SHIFT          0

/* COMMAND2 */
#define SPI_CMD2_TX_CLK_TAP_DELAY       (1 << 6)
#define SPI_CMD2_TX_CLK_TAP_DELAY_MASK  (0x3F << 6)
#define SPI_CMD2_RX_CLK_TAP_DELAY       (1 << 0)
#define SPI_CMD2_RX_CLK_TAP_DELAY_MASK  (0x3F << 0)

/* SPI_TRANS_STATUS */
#define SPI_STATUS_RDY                  (1 << 30)
#define SPI_STATUS_SLV_IDLE_COUNT_MASK  0xff
#define SPI_STATUS_SLV_IDLE_COUNT_SHIFT 16
#define SPI_STATUS_BLOCK_COUNT          0xffff
#define SPI_STATUS_BLOCK_COUNT_SHIFT    0

/* SPI_FIFO_STATUS */
#define SPI_FIFO_STATUS_CS_INACTIVE                     (1 << 31)
#define SPI_FIFO_STATUS_FRAME_END                       (1 << 30)
#define SPI_FIFO_STATUS_RX_FIFO_FULL_COUNT_MASK         0x7f
#define SPI_FIFO_STATUS_RX_FIFO_FULL_COUNT_SHIFT        23
#define SPI_FIFO_STATUS_TX_FIFO_EMPTY_COUNT_MASK        0x7f
#define SPI_FIFO_STATUS_TX_FIFO_EMPTY_COUNT_SHIFT       16
#define SPI_FIFO_STATUS_RX_FIFO_FLUSH                   (1 << 15)
#define SPI_FIFO_STATUS_TX_FIFO_FLUSH                   (1 << 14)
#define SPI_FIFO_STATUS_ERR                             (1 << 8)
#define SPI_FIFO_STATUS_TX_FIFO_OVF                     (1 << 7)
#define SPI_FIFO_STATUS_TX_FIFO_UNR                     (1 << 6)
#define SPI_FIFO_STATUS_RX_FIFO_OVF                     (1 << 5)
#define SPI_FIFO_STATUS_RX_FIFO_UNR                     (1 << 4)
#define SPI_FIFO_STATUS_TX_FIFO_FULL                    (1 << 3)
#define SPI_FIFO_STATUS_TX_FIFO_EMPTY                   (1 << 2)
#define SPI_FIFO_STATUS_RX_FIFO_FULL                    (1 << 1)
#define SPI_FIFO_STATUS_RX_FIFO_EMPTY                   (1 << 0)

/* SPI_DMA_CTL */
#define SPI_DMA_CTL_DMA                 (1 << 31)
#define SPI_DMA_CTL_CONT                (1 << 30)
#define SPI_DMA_CTL_IE_RX               (1 << 29)
#define SPI_DMA_CTL_IE_TX               (1 << 28)
#define SPI_DMA_CTL_RX_TRIG_MASK        0x3
#define SPI_DMA_CTL_RX_TRIG_SHIFT       19
#define SPI_DMA_CTL_TX_TRIG_MASK        0x3
#define SPI_DMA_CTL_TX_TRIG_SHIFT       15

/* SPI_DMA_BLK */
#define SPI_DMA_CTL_BLOCK_SIZE_MASK     0xffff
#define SPI_DMA_CTL_BLOCK_SIZE_SHIFT    0

static struct tegra_spi_channel tegra_spi_channels[] = {
        /*
         * Note: Tegra pinmux must be setup for corresponding SPI channel in
         * order for its registers to be accessible. If pinmux has not been
         * set up, access to the channel's registers will simply hang.
         *
         * TODO(dhendrix): Clarify or remove this comment (is clock setup
         * necessary first, or just pinmux, or both?)
         */
        {
                .slave = { .bus = 1, },
                .regs = (struct tegra_spi_regs *)TEGRA_SPI1_BASE,
                .req_sel = APBDMA_SLAVE_SL2B1,
        },
        {
                .slave = { .bus = 2, },
                .regs = (struct tegra_spi_regs *)TEGRA_SPI2_BASE,
                .req_sel = APBDMA_SLAVE_SL2B2,
        },
        {
                .slave = { .bus = 3, },
                .regs = (struct tegra_spi_regs *)TEGRA_SPI3_BASE,
                .req_sel = APBDMA_SLAVE_SL2B3,
        },
        {
                .slave = { .bus = 4, },
                .regs = (struct tegra_spi_regs *)TEGRA_SPI4_BASE,
                .req_sel = APBDMA_SLAVE_SL2B4,
        },
        {
                .slave = { .bus = 5, },
                .regs = (struct tegra_spi_regs *)TEGRA_SPI5_BASE,
                .req_sel = APBDMA_SLAVE_SL2B5,
        },
        {
                .slave = { .bus = 6, },
                .regs = (struct tegra_spi_regs *)TEGRA_SPI6_BASE,
                .req_sel = APBDMA_SLAVE_SL2B6,
        },
};

enum spi_direction {
        SPI_SEND,
        SPI_RECEIVE,
};

struct tegra_spi_channel *tegra_spi_init(unsigned int bus)
{
        int i;
        struct tegra_spi_channel *spi = NULL;

        for (i = 0; i < ARRAY_SIZE(tegra_spi_channels); i++) {
                if (tegra_spi_channels[i].slave.bus == bus) {
                        spi = &tegra_spi_channels[i];
                        break;
                }
        }
        if (!spi)
                return NULL;

        /* software drives chip-select, set value to high */
        setbits32(&spi->regs->command1,
                        SPI_CMD1_CS_SW_HW | SPI_CMD1_CS_SW_VAL);

        /* 8-bit transfers, unpacked mode, most significant bit first */
        clrbits32(&spi->regs->command1,
                        SPI_CMD1_BIT_LEN_MASK | SPI_CMD1_PACKED);
        setbits32(&spi->regs->command1, 7 << SPI_CMD1_BIT_LEN_SHIFT);

        return spi;
}

static struct tegra_spi_channel * const to_tegra_spi(int bus) {
        return &tegra_spi_channels[bus - 1];
}

static unsigned int tegra_spi_speed(unsigned int bus)
{
        /* FIXME: implement this properly, for now use max value (50MHz) */
        return 50000000;
}

static int spi_ctrlr_claim_bus(const struct spi_slave *slave)
{
        struct tegra_spi_regs *regs = to_tegra_spi(slave->bus)->regs;
        u32 val;

        tegra_spi_init(slave->bus);

        val = read32(&regs->command1);

        /* select appropriate chip-select line */
        val &= ~(SPI_CMD1_CS_SEL_MASK << SPI_CMD1_CS_SEL_SHIFT);
        val |= (slave->cs << SPI_CMD1_CS_SEL_SHIFT);

        /* drive chip-select with the inverse of the "inactive" value */
        if (val & (SPI_CMD1_CS_POL_INACTIVE0 << slave->cs))
                val &= ~SPI_CMD1_CS_SW_VAL;
        else
                val |= SPI_CMD1_CS_SW_VAL;

        write32(&regs->command1, val);
        return 0;
}

static void spi_ctrlr_release_bus(const struct spi_slave *slave)
{
        struct tegra_spi_regs *regs = to_tegra_spi(slave->bus)->regs;
        u32 val;

        val = read32(&regs->command1);

        if (val & (SPI_CMD1_CS_POL_INACTIVE0 << slave->cs))
                val |= SPI_CMD1_CS_SW_VAL;
        else
                val &= ~SPI_CMD1_CS_SW_VAL;

        write32(&regs->command1, val);
}

static void dump_fifo_status(struct tegra_spi_channel *spi)
{
        u32 status = read32(&spi->regs->fifo_status);

        printk(BIOS_INFO, "Raw FIFO status: 0x%08x\n", status);
        if (status & SPI_FIFO_STATUS_TX_FIFO_OVF)
                printk(BIOS_INFO, "\tTx overflow detected\n");
        if (status & SPI_FIFO_STATUS_TX_FIFO_UNR)
                printk(BIOS_INFO, "\tTx underrun detected\n");
        if (status & SPI_FIFO_STATUS_RX_FIFO_OVF)
                printk(BIOS_INFO, "\tRx overflow detected\n");
        if (status & SPI_FIFO_STATUS_RX_FIFO_UNR)
                printk(BIOS_INFO, "\tRx underrun detected\n");

        printk(BIOS_INFO, "TX_FIFO: 0x%08x, TX_DATA: 0x%08x\n",
                read32(&spi->regs->tx_fifo), read32(&spi->regs->tx_data));
        printk(BIOS_INFO, "RX_FIFO: 0x%08x, RX_DATA: 0x%08x\n",
                read32(&spi->regs->rx_fifo), read32(&spi->regs->rx_data));
}

static void clear_fifo_status(struct tegra_spi_channel *spi)
{
        clrbits32(&spi->regs->fifo_status,
                                SPI_FIFO_STATUS_ERR |
                                SPI_FIFO_STATUS_TX_FIFO_OVF |
                                SPI_FIFO_STATUS_TX_FIFO_UNR |
                                SPI_FIFO_STATUS_RX_FIFO_OVF |
                                SPI_FIFO_STATUS_RX_FIFO_UNR);
}

static void dump_spi_regs(struct tegra_spi_channel *spi)
{
        printk(BIOS_INFO, "SPI regs:\n"
                        "\tdma_blk: 0x%08x\n"
                        "\tcommand1: 0x%08x\n"
                        "\tdma_ctl: 0x%08x\n"
                        "\ttrans_status: 0x%08x\n",
                        read32(&spi->regs->dma_blk),
                        read32(&spi->regs->command1),
                        read32(&spi->regs->dma_ctl),
                        read32(&spi->regs->trans_status));
}

static void dump_dma_regs(struct apb_dma_channel *dma)
{
        if (dma == NULL)
                return;

        printk(BIOS_INFO, "DMA regs:\n"
                        "\tahb_ptr: 0x%08x\n"
                        "\tapb_ptr: 0x%08x\n"
                        "\tahb_seq: 0x%08x\n"
                        "\tapb_seq: 0x%08x\n"
                        "\tcsr: 0x%08x\n"
                        "\tcsre: 0x%08x\n"
                        "\twcount: 0x%08x\n"
                        "\tdma_byte_sta: 0x%08x\n"
                        "\tword_transfer: 0x%08x\n",
                        read32(&dma->regs->ahb_ptr),
                        read32(&dma->regs->apb_ptr),
                        read32(&dma->regs->ahb_seq),
                        read32(&dma->regs->apb_seq),
                        read32(&dma->regs->csr),
                        read32(&dma->regs->csre),
                        read32(&dma->regs->wcount),
                        read32(&dma->regs->dma_byte_sta),
                        read32(&dma->regs->word_transfer));
}

static inline unsigned int spi_byte_count(struct tegra_spi_channel *spi)
{
        /* FIXME: Make this take total packet size into account */
        return read32(&spi->regs->trans_status) &
                (SPI_STATUS_BLOCK_COUNT << SPI_STATUS_BLOCK_COUNT_SHIFT);
}

/*
 * This calls udelay() with a calculated value based on the SPI speed and
 * number of bytes remaining to be transferred. It assumes that if the
 * calculated delay period is less than MIN_DELAY_US then it is probably
 * not worth the overhead of yielding.
 */
#define MIN_DELAY_US 250
static void spi_delay(struct tegra_spi_channel *spi,
                                unsigned int bytes_remaining)
{
        unsigned int ns_per_byte, delay_us;

        ns_per_byte = 1000000000 / (tegra_spi_speed(spi->slave.bus) / 8);
        delay_us = (ns_per_byte * bytes_remaining) / 1000;

        if (delay_us < MIN_DELAY_US)
                return;

        udelay(delay_us);
}

static void tegra_spi_wait(struct tegra_spi_channel *spi)
{
        unsigned int count, dma_blk;

        dma_blk = 1 + (read32(&spi->regs->dma_blk) &
                (SPI_DMA_CTL_BLOCK_SIZE_MASK << SPI_DMA_CTL_BLOCK_SIZE_SHIFT));

        while ((count = spi_byte_count(spi)) != dma_blk)
                spi_delay(spi, dma_blk - count);
}

static int fifo_error(struct tegra_spi_channel *spi)
{
        return read32(&spi->regs->fifo_status) & SPI_FIFO_STATUS_ERR ? 1 : 0;
}

static int tegra_spi_pio_prepare(struct tegra_spi_channel *spi,
                        unsigned int bytes, enum spi_direction dir)
{
        u8 *p = spi->out_buf;
        unsigned int todo = MIN(bytes, SPI_MAX_TRANSFER_BYTES_FIFO);
        u32 flush_mask, enable_mask;

        if (dir == SPI_SEND) {
                flush_mask = SPI_FIFO_STATUS_TX_FIFO_FLUSH;
                enable_mask = SPI_CMD1_TX_EN;
        } else {
                flush_mask = SPI_FIFO_STATUS_RX_FIFO_FLUSH;
                enable_mask = SPI_CMD1_RX_EN;
        }

        setbits32(&spi->regs->fifo_status, flush_mask);
        while (read32(&spi->regs->fifo_status) & flush_mask)
                ;

        setbits32(&spi->regs->command1, enable_mask);

        /* BLOCK_SIZE in SPI_DMA_BLK register applies to both DMA and
         * PIO transfers */
        write32(&spi->regs->dma_blk, todo - 1);

        if (dir == SPI_SEND) {
                unsigned int to_fifo = bytes;
                while (to_fifo) {
                        write32(&spi->regs->tx_fifo, *p);
                        p++;
                        to_fifo--;
                }
        }

        return todo;
}

static void tegra_spi_pio_start(struct tegra_spi_channel *spi)
{
        setbits32(&spi->regs->trans_status, SPI_STATUS_RDY);
        setbits32(&spi->regs->command1, SPI_CMD1_GO);
        /* Make sure the write to command1 completes. */
        read32(&spi->regs->command1);
}

static inline u32 rx_fifo_count(struct tegra_spi_channel *spi)
{
        return (read32(&spi->regs->fifo_status) >>
                SPI_FIFO_STATUS_RX_FIFO_FULL_COUNT_SHIFT) &
                SPI_FIFO_STATUS_RX_FIFO_FULL_COUNT_MASK;
}

static int tegra_spi_pio_finish(struct tegra_spi_channel *spi)
{
        u8 *p = spi->in_buf;
        struct stopwatch sw;

        clrbits32(&spi->regs->command1, SPI_CMD1_RX_EN | SPI_CMD1_TX_EN);

        /*
         * Allow some time in case the Rx FIFO does not yet have
         * all packets pushed into it. See chrome-os-partner:24215.
         */
        stopwatch_init_usecs_expire(&sw, SPI_FIFO_XFER_TIMEOUT_US);
        do {
                if (rx_fifo_count(spi) == spi_byte_count(spi))
                        break;
        } while (!stopwatch_expired(&sw));

        while (!(read32(&spi->regs->fifo_status) &
                                SPI_FIFO_STATUS_RX_FIFO_EMPTY)) {
                *p = read8(&spi->regs->rx_fifo);
                p++;
        }

        if (fifo_error(spi)) {
                printk(BIOS_ERR, "%s: ERROR:\n", __func__);
                dump_spi_regs(spi);
                dump_fifo_status(spi);
                return -1;
        }

        return 0;
}

static void setup_dma_params(struct tegra_spi_channel *spi,
                                struct apb_dma_channel *dma)
{
        /* APB bus width = 8-bits, address wrap for each word */
        clrbits32(&dma->regs->apb_seq,
                        APB_BUS_WIDTH_MASK << APB_BUS_WIDTH_SHIFT);
        /* AHB 1 word burst, bus width = 32 bits (fixed in hardware),
         * no address wrapping */
        clrsetbits32(&dma->regs->ahb_seq,
                        (AHB_BURST_MASK << AHB_BURST_SHIFT),
                        4 << AHB_BURST_SHIFT);

        /* Set ONCE mode to transfer one "block" at a time (64KB) and enable
         * flow control. */
        clrbits32(&dma->regs->csr,
                        APB_CSR_REQ_SEL_MASK << APB_CSR_REQ_SEL_SHIFT);
        setbits32(&dma->regs->csr, APB_CSR_ONCE | APB_CSR_FLOW |
                        (spi->req_sel << APB_CSR_REQ_SEL_SHIFT));
}

static int tegra_spi_dma_prepare(struct tegra_spi_channel *spi,
                unsigned int bytes, enum spi_direction dir)
{
        unsigned int todo, wcount;

        /*
         * For DMA we need to think of things in terms of word count.
         * AHB width is fixed at 32-bits. To avoid overrunning
         * the in/out buffers we must align down. (Note: lowest 2-bits
         * in WCOUNT register are ignored, and WCOUNT seems to count
         * words starting at n-1)
         *
         * Example: If "bytes" is 7 and we are transferring 1-byte at a time,
         * WCOUNT should be 4. The remaining 3 bytes must be transferred
         * using PIO.
         */
        todo = MIN(bytes, SPI_MAX_TRANSFER_BYTES_DMA - TEGRA_DMA_ALIGN_BYTES);
        todo = ALIGN_DOWN(todo, TEGRA_DMA_ALIGN_BYTES);
        wcount = ALIGN_DOWN(todo - TEGRA_DMA_ALIGN_BYTES, TEGRA_DMA_ALIGN_BYTES);

        if (dir == SPI_SEND) {
                spi->dma_out = dma_claim();
                if (!spi->dma_out)
                        return -1;

                /* ensure bytes to send will be visible to DMA controller */
                dcache_clean_by_mva(spi->out_buf, bytes);

                write32(&spi->dma_out->regs->apb_ptr,
                        (u32)&spi->regs->tx_fifo);
                write32(&spi->dma_out->regs->ahb_ptr, (u32)spi->out_buf);
                setbits32(&spi->dma_out->regs->csr, APB_CSR_DIR);
                setup_dma_params(spi, spi->dma_out);
                write32(&spi->dma_out->regs->wcount, wcount);
        } else {
                spi->dma_in = dma_claim();
                if (!spi->dma_in)
                        return -1;

                /* avoid data collisions */
                dcache_clean_invalidate_by_mva(spi->in_buf, bytes);

                write32(&spi->dma_in->regs->apb_ptr, (u32)&spi->regs->rx_fifo);
                write32(&spi->dma_in->regs->ahb_ptr, (u32)spi->in_buf);
                clrbits32(&spi->dma_in->regs->csr, APB_CSR_DIR);
                setup_dma_params(spi, spi->dma_in);
                write32(&spi->dma_in->regs->wcount, wcount);
        }

        /* BLOCK_SIZE starts at n-1 */
        write32(&spi->regs->dma_blk, todo - 1);
        return todo;
}

static void tegra_spi_dma_start(struct tegra_spi_channel *spi)
{
        /*
         * The RDY bit in SPI_TRANS_STATUS needs to be cleared manually
         * (set bit to clear) between each transaction. Otherwise the next
         * transaction does not start.
         */
        setbits32(&spi->regs->trans_status, SPI_STATUS_RDY);

        if (spi->dma_out)
                setbits32(&spi->regs->command1, SPI_CMD1_TX_EN);
        if (spi->dma_in)
                setbits32(&spi->regs->command1, SPI_CMD1_RX_EN);

        /*
         * To avoid underrun conditions, enable APB DMA before SPI DMA for
         * Tx and enable SPI DMA before APB DMA before Rx.
         */
        if (spi->dma_out)
                dma_start(spi->dma_out);
        setbits32(&spi->regs->dma_ctl, SPI_DMA_CTL_DMA);
        if (spi->dma_in)
                dma_start(spi->dma_in);
}

static int tegra_spi_dma_finish(struct tegra_spi_channel *spi)
{
        int ret;
        unsigned int todo;

        if (spi->dma_in) {
                todo = read32(&spi->dma_in->regs->wcount);

                while ((read32(&spi->dma_in->regs->dma_byte_sta) < todo) ||
                                dma_busy(spi->dma_in))
                        ;       /* this shouldn't take long, no udelay */
                dma_stop(spi->dma_in);
                clrbits32(&spi->regs->command1, SPI_CMD1_RX_EN);
                dma_release(spi->dma_in);
        }

        if (spi->dma_out) {
                todo = read32(&spi->dma_out->regs->wcount);

                while ((read32(&spi->dma_out->regs->dma_byte_sta) < todo) ||
                                dma_busy(spi->dma_out)) {
                        spi_delay(spi, todo - spi_byte_count(spi));
                }
                clrbits32(&spi->regs->command1, SPI_CMD1_TX_EN);
                dma_stop(spi->dma_out);
                dma_release(spi->dma_out);
        }

        if (fifo_error(spi)) {
                printk(BIOS_ERR, "%s: ERROR:\n", __func__);
                dump_dma_regs(spi->dma_out);
                dump_dma_regs(spi->dma_in);
                dump_spi_regs(spi);
                dump_fifo_status(spi);
                ret = -1;
                goto done;
        }

        ret = 0;
done:
        spi->dma_in = NULL;
        spi->dma_out = NULL;
        return ret;
}

/*
 * xfer_setup() prepares a transfer. It does sanity checking, alignment, and
 * sets transfer mode used by this channel (if not set already).
 *
 * A few caveats to watch out for:
 * - The number of bytes which can be transferred may be smaller than the
 *   number of bytes the caller specifies. The number of bytes ready for
 *   a transfer will be returned (unless an error occurs).
 *
 * - Only one mode can be used for both RX and TX. The transfer mode of the
 *   SPI channel (spi->xfer_mode) is checked each time this function is called.
 *   If conflicting modes are detected, spi->xfer_mode will be set to
 *   XFER_MODE_NONE and an error will be returned.
 *
 * Returns bytes ready for transfer if successful, <0 to indicate error.
 */
static int xfer_setup(struct tegra_spi_channel *spi, void *buf,
                unsigned int bytes, enum spi_direction dir)
{
        unsigned int line_size = dcache_line_bytes();
        unsigned int align;
        int ret = -1;

        if (!bytes)
                return 0;

        if (dir == SPI_SEND)
                spi->out_buf = buf;
        else if (dir == SPI_RECEIVE)
                spi->in_buf = buf;

        /*
         * Alignment consideratons:
         * When we enable caching we'll need to clean/invalidate portions of
         * memory. So we need to be careful about memory alignment. Also, DMA
         * likes to operate on 4-bytes at a time on the AHB side. So for
         * example, if we only want to receive 1 byte, 4 bytes will be
         * written in memory even if those extra 3 bytes are beyond the length
         * we want.
         *
         * For now we'll use PIO to send/receive unaligned bytes. We may
         * consider setting aside some space for a kind of bounce buffer to
         * stay in DMA mode once we have a chance to benchmark the two
         * approaches.
         */

        if (bytes < line_size) {
                if (spi->xfer_mode == XFER_MODE_DMA) {
                        spi->xfer_mode = XFER_MODE_NONE;
                        ret = -1;
                } else {
                        spi->xfer_mode = XFER_MODE_PIO;
                        ret = tegra_spi_pio_prepare(spi, bytes, dir);
                }
                goto done;
        }

        /* transfer bytes before the aligned boundary */
        align = line_size - ((uintptr_t)buf % line_size);
        if ((align != 0) && (align != line_size)) {
                if (spi->xfer_mode == XFER_MODE_DMA) {
                        spi->xfer_mode = XFER_MODE_NONE;
                        ret = -1;
                } else {
                        spi->xfer_mode = XFER_MODE_PIO;
                        ret = tegra_spi_pio_prepare(spi, align, dir);
                }
                goto done;
        }

        /* do aligned DMA transfer */
        align = (((uintptr_t)buf + bytes) % line_size);
        if (bytes - align > 0) {
                unsigned int dma_bytes = bytes - align;

                if (spi->xfer_mode == XFER_MODE_PIO) {
                        spi->xfer_mode = XFER_MODE_NONE;
                        ret = -1;
                } else {
                        spi->xfer_mode = XFER_MODE_DMA;
                        ret = tegra_spi_dma_prepare(spi, dma_bytes, dir);
                }

                goto done;
        }

        /* transfer any remaining unaligned bytes */
        if (align) {
                if (spi->xfer_mode == XFER_MODE_DMA) {
                        spi->xfer_mode = XFER_MODE_NONE;
                        ret = -1;
                } else {
                        spi->xfer_mode = XFER_MODE_PIO;
                        ret = tegra_spi_pio_prepare(spi, align, dir);
                }
                goto done;
        }

done:
        return ret;
}

static void xfer_start(struct tegra_spi_channel *spi)
{
        if (spi->xfer_mode == XFER_MODE_DMA)
                tegra_spi_dma_start(spi);
        else
                tegra_spi_pio_start(spi);
}

static void xfer_wait(struct tegra_spi_channel *spi)
{
        tegra_spi_wait(spi);
}

static int xfer_finish(struct tegra_spi_channel *spi)
{
        int ret;

        if (spi->xfer_mode == XFER_MODE_DMA)
                ret = tegra_spi_dma_finish(spi);
        else
                ret = tegra_spi_pio_finish(spi);

        spi->xfer_mode = XFER_MODE_NONE;
        return ret;
}

static int spi_ctrlr_xfer(const struct spi_slave *slave, const void *dout,
                          size_t out_bytes, void *din, size_t in_bytes)
{
        struct tegra_spi_channel *spi = to_tegra_spi(slave->bus);
        u8 *out_buf = (u8 *)dout;
        u8 *in_buf = (u8 *)din;
        size_t todo;
        int ret = 0;

        /* tegra bus numbers start at 1 */
        ASSERT(slave->bus >= 1 && slave->bus <= ARRAY_SIZE(tegra_spi_channels));

        while (out_bytes || in_bytes) {
                int x = 0;

                if (out_bytes == 0)
                        todo = in_bytes;
                else if (in_bytes == 0)
                        todo = out_bytes;
                else
                        todo = MIN(out_bytes, in_bytes);

                if (out_bytes) {
                        x = xfer_setup(spi, out_buf, todo, SPI_SEND);
                        if (x < 0) {
                                if (spi->xfer_mode == XFER_MODE_NONE) {
                                        spi->xfer_mode = XFER_MODE_PIO;
                                        continue;
                                } else {
                                        ret = -1;
                                        break;
                                }
                        }
                }
                if (in_bytes) {
                        x = xfer_setup(spi, in_buf, todo, SPI_RECEIVE);
                        if (x < 0) {
                                if (spi->xfer_mode == XFER_MODE_NONE) {
                                        spi->xfer_mode = XFER_MODE_PIO;
                                        continue;
                                } else {
                                        ret = -1;
                                        break;
                                }
                        }
                }

                /*
                 * Note: Some devices (such as Chrome EC) are sensitive to
                 * delays, so be careful when adding debug prints not to
                 * cause timeouts between transfers.
                 */
                xfer_start(spi);
                xfer_wait(spi);
                if (xfer_finish(spi)) {
                        ret = -1;
                        break;
                }

                /* Post-processing. */
                if (out_bytes) {
                        out_bytes -= x;
                        out_buf += x;
                }
                if (in_bytes) {
                        in_bytes -= x;
                        in_buf += x;
                }
        }

        if (ret < 0) {
                printk(BIOS_ERR, "%s: Error detected\n", __func__);
                printk(BIOS_ERR, "Transaction size: %u, bytes remaining: "
                                "%u out / %u in\n", todo, out_bytes, in_bytes);
                clear_fifo_status(spi);
        }
        return ret;
}

static const struct spi_ctrlr spi_ctrlr = {
        .claim_bus = spi_ctrlr_claim_bus,
        .release_bus = spi_ctrlr_release_bus,
        .xfer = spi_ctrlr_xfer,
        .max_xfer_size = SPI_CTRLR_DEFAULT_MAX_XFER_SIZE,
};

const struct spi_ctrlr_buses spi_ctrlr_bus_map[] = {
        {
                .ctrlr = &spi_ctrlr,
                .bus_start = 1,
                .bus_end = ARRAY_SIZE(tegra_spi_channels)
        },
};

const size_t spi_ctrlr_bus_map_count = ARRAY_SIZE(spi_ctrlr_bus_map);