Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 1 | /* |
| 2 | * (C) Copyright 2009 |
| 3 | * Marvell Semiconductor <www.marvell.com> |
| 4 | * Written-by: Prafulla Wadaskar <prafulla@marvell.com> |
| 5 | * |
| 6 | * Derived from drivers/spi/mpc8xxx_spi.c |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 7 | * |
| 8 | * SPDX-License-Identifier: GPL-2.0+ |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 9 | */ |
| 10 | |
| 11 | #include <common.h> |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 12 | #include <malloc.h> |
| 13 | #include <spi.h> |
| 14 | #include <asm/io.h> |
| 15 | #include <asm/arch/soc.h> |
| 16 | #ifdef CONFIG_KIRKWOOD |
| 17 | #include <asm/arch/mpp.h> |
| 18 | #endif |
| 19 | #include <asm/arch-mvebu/spi.h> |
| 20 | |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 21 | static struct kwspi_registers *spireg = |
| 22 | (struct kwspi_registers *)MVEBU_SPI_BASE; |
| 23 | |
| 24 | #ifdef CONFIG_KIRKWOOD |
| 25 | static u32 cs_spi_mpp_back[2]; |
| 26 | #endif |
| 27 | |
| 28 | struct spi_slave *spi_setup_slave(unsigned int bus, unsigned int cs, |
| 29 | unsigned int max_hz, unsigned int mode) |
| 30 | { |
| 31 | struct spi_slave *slave; |
| 32 | u32 data; |
| 33 | #ifdef CONFIG_KIRKWOOD |
| 34 | static const u32 kwspi_mpp_config[2][2] = { |
| 35 | { MPP0_SPI_SCn, 0 }, /* if cs == 0 */ |
| 36 | { MPP7_SPI_SCn, 0 } /* if cs != 0 */ |
| 37 | }; |
| 38 | #endif |
| 39 | |
| 40 | if (!spi_cs_is_valid(bus, cs)) |
| 41 | return NULL; |
| 42 | |
| 43 | slave = spi_alloc_slave_base(bus, cs); |
| 44 | if (!slave) |
| 45 | return NULL; |
| 46 | |
| 47 | writel(KWSPI_SMEMRDY, &spireg->ctrl); |
| 48 | |
| 49 | /* calculate spi clock prescaller using max_hz */ |
| 50 | data = ((CONFIG_SYS_TCLK / 2) / max_hz) + 0x10; |
| 51 | data = data < KWSPI_CLKPRESCL_MIN ? KWSPI_CLKPRESCL_MIN : data; |
| 52 | data = data > KWSPI_CLKPRESCL_MASK ? KWSPI_CLKPRESCL_MASK : data; |
| 53 | |
| 54 | /* program spi clock prescaller using max_hz */ |
| 55 | writel(KWSPI_ADRLEN_3BYTE | data, &spireg->cfg); |
| 56 | debug("data = 0x%08x\n", data); |
| 57 | |
| 58 | writel(KWSPI_SMEMRDIRQ, &spireg->irq_cause); |
| 59 | writel(KWSPI_IRQMASK, &spireg->irq_mask); |
| 60 | |
| 61 | #ifdef CONFIG_KIRKWOOD |
| 62 | /* program mpp registers to select SPI_CSn */ |
| 63 | kirkwood_mpp_conf(kwspi_mpp_config[cs ? 1 : 0], cs_spi_mpp_back); |
| 64 | #endif |
| 65 | |
| 66 | return slave; |
| 67 | } |
| 68 | |
| 69 | void spi_free_slave(struct spi_slave *slave) |
| 70 | { |
| 71 | #ifdef CONFIG_KIRKWOOD |
| 72 | kirkwood_mpp_conf(cs_spi_mpp_back, NULL); |
| 73 | #endif |
| 74 | free(slave); |
| 75 | } |
| 76 | |
| 77 | #if defined(CONFIG_SYS_KW_SPI_MPP) |
| 78 | u32 spi_mpp_backup[4]; |
| 79 | #endif |
| 80 | |
| 81 | __attribute__((weak)) int board_spi_claim_bus(struct spi_slave *slave) |
| 82 | { |
| 83 | return 0; |
| 84 | } |
| 85 | |
| 86 | int spi_claim_bus(struct spi_slave *slave) |
| 87 | { |
| 88 | #if defined(CONFIG_SYS_KW_SPI_MPP) |
| 89 | u32 config; |
| 90 | u32 spi_mpp_config[4]; |
| 91 | |
| 92 | config = CONFIG_SYS_KW_SPI_MPP; |
| 93 | |
| 94 | if (config & MOSI_MPP6) |
| 95 | spi_mpp_config[0] = MPP6_SPI_MOSI; |
| 96 | else |
| 97 | spi_mpp_config[0] = MPP1_SPI_MOSI; |
| 98 | |
| 99 | if (config & SCK_MPP10) |
| 100 | spi_mpp_config[1] = MPP10_SPI_SCK; |
| 101 | else |
| 102 | spi_mpp_config[1] = MPP2_SPI_SCK; |
| 103 | |
| 104 | if (config & MISO_MPP11) |
| 105 | spi_mpp_config[2] = MPP11_SPI_MISO; |
| 106 | else |
| 107 | spi_mpp_config[2] = MPP3_SPI_MISO; |
| 108 | |
| 109 | spi_mpp_config[3] = 0; |
| 110 | spi_mpp_backup[3] = 0; |
| 111 | |
| 112 | /* set new spi mpp and save current mpp config */ |
| 113 | kirkwood_mpp_conf(spi_mpp_config, spi_mpp_backup); |
| 114 | #endif |
| 115 | |
| 116 | return board_spi_claim_bus(slave); |
| 117 | } |
| 118 | |
| 119 | __attribute__((weak)) void board_spi_release_bus(struct spi_slave *slave) |
| 120 | { |
| 121 | } |
| 122 | |
| 123 | void spi_release_bus(struct spi_slave *slave) |
| 124 | { |
| 125 | #if defined(CONFIG_SYS_KW_SPI_MPP) |
| 126 | kirkwood_mpp_conf(spi_mpp_backup, NULL); |
| 127 | #endif |
| 128 | |
| 129 | board_spi_release_bus(slave); |
| 130 | } |
| 131 | |
| 132 | #ifndef CONFIG_SPI_CS_IS_VALID |
| 133 | /* |
| 134 | * you can define this function board specific |
| 135 | * define above CONFIG in board specific config file and |
| 136 | * provide the function in board specific src file |
| 137 | */ |
| 138 | int spi_cs_is_valid(unsigned int bus, unsigned int cs) |
| 139 | { |
| 140 | return bus == 0 && (cs == 0 || cs == 1); |
| 141 | } |
| 142 | #endif |
| 143 | |
| 144 | void spi_init(void) |
| 145 | { |
| 146 | } |
| 147 | |
| 148 | void spi_cs_activate(struct spi_slave *slave) |
| 149 | { |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 150 | setbits_le32(&spireg->ctrl, KWSPI_CSN_ACT); |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 151 | } |
| 152 | |
| 153 | void spi_cs_deactivate(struct spi_slave *slave) |
| 154 | { |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 155 | clrbits_le32(&spireg->ctrl, KWSPI_CSN_ACT); |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 156 | } |
| 157 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 158 | int spi_xfer(struct spi_slave *slave, unsigned int bitlen, const void *dout, |
| 159 | void *din, unsigned long flags) |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 160 | { |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 161 | unsigned int tmpdout, tmpdin; |
| 162 | int tm, isread = 0; |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 163 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 164 | debug("spi_xfer: slave %u:%u dout %p din %p bitlen %u\n", |
| 165 | slave->bus, slave->cs, dout, din, bitlen); |
Googler | e00b8eb | 2019-07-08 16:37:07 -0700 | [diff] [blame] | 166 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 167 | if (flags & SPI_XFER_BEGIN) |
| 168 | spi_cs_activate(slave); |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 169 | |
| 170 | /* |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 171 | * handle data in 8-bit chunks |
| 172 | * TBD: 2byte xfer mode to be enabled |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 173 | */ |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 174 | clrsetbits_le32(&spireg->cfg, KWSPI_XFERLEN_MASK, KWSPI_XFERLEN_1BYTE); |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 175 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 176 | while (bitlen > 4) { |
| 177 | debug("loopstart bitlen %d\n", bitlen); |
| 178 | tmpdout = 0; |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 179 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 180 | /* Shift data so it's msb-justified */ |
| 181 | if (dout) |
| 182 | tmpdout = *(u32 *)dout & 0xff; |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 183 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 184 | clrbits_le32(&spireg->irq_cause, KWSPI_SMEMRDIRQ); |
| 185 | writel(tmpdout, &spireg->dout); /* Write the data out */ |
| 186 | debug("*** spi_xfer: ... %08x written, bitlen %d\n", |
| 187 | tmpdout, bitlen); |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 188 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 189 | /* |
| 190 | * Wait for SPI transmit to get out |
| 191 | * or time out (1 second = 1000 ms) |
| 192 | * The NE event must be read and cleared first |
| 193 | */ |
| 194 | for (tm = 0, isread = 0; tm < KWSPI_TIMEOUT; ++tm) { |
| 195 | if (readl(&spireg->irq_cause) & KWSPI_SMEMRDIRQ) { |
| 196 | isread = 1; |
| 197 | tmpdin = readl(&spireg->din); |
| 198 | debug("spi_xfer: din %p..%08x read\n", |
| 199 | din, tmpdin); |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 200 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 201 | if (din) { |
| 202 | *((u8 *)din) = (u8)tmpdin; |
| 203 | din += 1; |
| 204 | } |
| 205 | if (dout) |
| 206 | dout += 1; |
| 207 | bitlen -= 8; |
| 208 | } |
| 209 | if (isread) |
| 210 | break; |
| 211 | } |
| 212 | if (tm >= KWSPI_TIMEOUT) |
| 213 | printf("*** spi_xfer: Time out during SPI transfer\n"); |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 214 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 215 | debug("loopend bitlen %d\n", bitlen); |
| 216 | } |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 217 | |
Googler | 695f9d9 | 2023-09-11 15:38:29 +0800 | [diff] [blame^] | 218 | if (flags & SPI_XFER_END) |
| 219 | spi_cs_deactivate(slave); |
Googler | 25e92cf | 2023-12-13 10:05:01 +0000 | [diff] [blame] | 220 | |
| 221 | return 0; |
| 222 | } |