1e3228ed9SCédric Le Goater // SPDX-License-Identifier: GPL-2.0-or-later 2e3228ed9SCédric Le Goater /* 3e3228ed9SCédric Le Goater * ASPEED FMC/SPI Memory Controller Driver 4e3228ed9SCédric Le Goater * 5e3228ed9SCédric Le Goater * Copyright (c) 2015-2022, IBM Corporation. 6e3228ed9SCédric Le Goater * Copyright (c) 2020, ASPEED Corporation. 7e3228ed9SCédric Le Goater */ 8e3228ed9SCédric Le Goater 9e3228ed9SCédric Le Goater #include <linux/clk.h> 10e3228ed9SCédric Le Goater #include <linux/module.h> 11e3228ed9SCédric Le Goater #include <linux/of.h> 12e3228ed9SCédric Le Goater #include <linux/of_platform.h> 13e3228ed9SCédric Le Goater #include <linux/platform_device.h> 14e3228ed9SCédric Le Goater #include <linux/spi/spi.h> 15e3228ed9SCédric Le Goater #include <linux/spi/spi-mem.h> 16e3228ed9SCédric Le Goater 17e3228ed9SCédric Le Goater #define DEVICE_NAME "spi-aspeed-smc" 18e3228ed9SCédric Le Goater 19e3228ed9SCédric Le Goater /* Type setting Register */ 20e3228ed9SCédric Le Goater #define CONFIG_REG 0x0 21e3228ed9SCédric Le Goater #define CONFIG_TYPE_SPI 0x2 22e3228ed9SCédric Le Goater 23e3228ed9SCédric Le Goater /* CE Control Register */ 24e3228ed9SCédric Le Goater #define CE_CTRL_REG 0x4 25e3228ed9SCédric Le Goater 26e3228ed9SCédric Le Goater /* CEx Control Register */ 27e3228ed9SCédric Le Goater #define CE0_CTRL_REG 0x10 28e3228ed9SCédric Le Goater #define CTRL_IO_MODE_MASK GENMASK(30, 28) 29e3228ed9SCédric Le Goater #define CTRL_IO_SINGLE_DATA 0x0 30e3228ed9SCédric Le Goater #define CTRL_IO_DUAL_DATA BIT(29) 31e3228ed9SCédric Le Goater #define CTRL_IO_QUAD_DATA BIT(30) 32e3228ed9SCédric Le Goater #define CTRL_COMMAND_SHIFT 16 33e3228ed9SCédric Le Goater #define CTRL_IO_DUMMY_SET(dummy) \ 34e3228ed9SCédric Le Goater (((((dummy) >> 2) & 0x1) << 14) | (((dummy) & 0x3) << 6)) 35e3228ed9SCédric Le Goater #define CTRL_CE_STOP_ACTIVE BIT(2) 36e3228ed9SCédric Le Goater #define CTRL_IO_MODE_CMD_MASK GENMASK(1, 0) 37e3228ed9SCédric Le Goater #define CTRL_IO_MODE_NORMAL 0x0 38e3228ed9SCédric Le Goater #define CTRL_IO_MODE_READ 0x1 39e3228ed9SCédric Le Goater #define CTRL_IO_MODE_WRITE 0x2 40e3228ed9SCédric Le Goater #define CTRL_IO_MODE_USER 0x3 41e3228ed9SCédric Le Goater 42e3228ed9SCédric Le Goater #define CTRL_IO_CMD_MASK 0xf0ff40c3 43e3228ed9SCédric Le Goater 44e3228ed9SCédric Le Goater /* CEx Address Decoding Range Register */ 45e3228ed9SCédric Le Goater #define CE0_SEGMENT_ADDR_REG 0x30 46e3228ed9SCédric Le Goater 47e3228ed9SCédric Le Goater enum aspeed_spi_ctl_reg_value { 48e3228ed9SCédric Le Goater ASPEED_SPI_BASE, 49e3228ed9SCédric Le Goater ASPEED_SPI_READ, 50e3228ed9SCédric Le Goater ASPEED_SPI_WRITE, 51e3228ed9SCédric Le Goater ASPEED_SPI_MAX, 52e3228ed9SCédric Le Goater }; 53e3228ed9SCédric Le Goater 54e3228ed9SCédric Le Goater struct aspeed_spi; 55e3228ed9SCédric Le Goater 56e3228ed9SCédric Le Goater struct aspeed_spi_chip { 57e3228ed9SCédric Le Goater struct aspeed_spi *aspi; 58e3228ed9SCédric Le Goater u32 cs; 59e3228ed9SCédric Le Goater void __iomem *ctl; 60e3228ed9SCédric Le Goater void __iomem *ahb_base; 61e3228ed9SCédric Le Goater u32 ahb_window_size; 62e3228ed9SCédric Le Goater u32 ctl_val[ASPEED_SPI_MAX]; 63e3228ed9SCédric Le Goater u32 clk_freq; 64e3228ed9SCédric Le Goater }; 65e3228ed9SCédric Le Goater 66e3228ed9SCédric Le Goater struct aspeed_spi_data { 67e3228ed9SCédric Le Goater u32 ctl0; 68e3228ed9SCédric Le Goater u32 max_cs; 69e3228ed9SCédric Le Goater bool hastype; 70e3228ed9SCédric Le Goater u32 mode_bits; 71e3228ed9SCédric Le Goater u32 we0; 72e3228ed9SCédric Le Goater 73e3228ed9SCédric Le Goater u32 (*segment_start)(struct aspeed_spi *aspi, u32 reg); 74e3228ed9SCédric Le Goater u32 (*segment_end)(struct aspeed_spi *aspi, u32 reg); 75e3228ed9SCédric Le Goater u32 (*segment_reg)(struct aspeed_spi *aspi, u32 start, u32 end); 76e3228ed9SCédric Le Goater }; 77e3228ed9SCédric Le Goater 78e3228ed9SCédric Le Goater #define ASPEED_SPI_MAX_NUM_CS 5 79e3228ed9SCédric Le Goater 80e3228ed9SCédric Le Goater struct aspeed_spi { 81e3228ed9SCédric Le Goater const struct aspeed_spi_data *data; 82e3228ed9SCédric Le Goater 83e3228ed9SCédric Le Goater void __iomem *regs; 84e3228ed9SCédric Le Goater void __iomem *ahb_base; 85e3228ed9SCédric Le Goater u32 ahb_base_phy; 86e3228ed9SCédric Le Goater u32 ahb_window_size; 87e3228ed9SCédric Le Goater struct device *dev; 88e3228ed9SCédric Le Goater 89e3228ed9SCédric Le Goater struct clk *clk; 90e3228ed9SCédric Le Goater u32 clk_freq; 91e3228ed9SCédric Le Goater 92e3228ed9SCédric Le Goater struct aspeed_spi_chip chips[ASPEED_SPI_MAX_NUM_CS]; 93e3228ed9SCédric Le Goater }; 94e3228ed9SCédric Le Goater 95e3228ed9SCédric Le Goater static u32 aspeed_spi_get_io_mode(const struct spi_mem_op *op) 96e3228ed9SCédric Le Goater { 97e3228ed9SCédric Le Goater switch (op->data.buswidth) { 98e3228ed9SCédric Le Goater case 1: 99e3228ed9SCédric Le Goater return CTRL_IO_SINGLE_DATA; 100e3228ed9SCédric Le Goater case 2: 101e3228ed9SCédric Le Goater return CTRL_IO_DUAL_DATA; 102e3228ed9SCédric Le Goater case 4: 103e3228ed9SCédric Le Goater return CTRL_IO_QUAD_DATA; 104e3228ed9SCédric Le Goater default: 105e3228ed9SCédric Le Goater return CTRL_IO_SINGLE_DATA; 106e3228ed9SCédric Le Goater } 107e3228ed9SCédric Le Goater } 108e3228ed9SCédric Le Goater 109e3228ed9SCédric Le Goater static void aspeed_spi_set_io_mode(struct aspeed_spi_chip *chip, u32 io_mode) 110e3228ed9SCédric Le Goater { 111e3228ed9SCédric Le Goater u32 ctl; 112e3228ed9SCédric Le Goater 113e3228ed9SCédric Le Goater if (io_mode > 0) { 114e3228ed9SCédric Le Goater ctl = readl(chip->ctl) & ~CTRL_IO_MODE_MASK; 115e3228ed9SCédric Le Goater ctl |= io_mode; 116e3228ed9SCédric Le Goater writel(ctl, chip->ctl); 117e3228ed9SCédric Le Goater } 118e3228ed9SCédric Le Goater } 119e3228ed9SCédric Le Goater 120e3228ed9SCédric Le Goater static void aspeed_spi_start_user(struct aspeed_spi_chip *chip) 121e3228ed9SCédric Le Goater { 122e3228ed9SCédric Le Goater u32 ctl = chip->ctl_val[ASPEED_SPI_BASE]; 123e3228ed9SCédric Le Goater 124e3228ed9SCédric Le Goater ctl |= CTRL_IO_MODE_USER | CTRL_CE_STOP_ACTIVE; 125e3228ed9SCédric Le Goater writel(ctl, chip->ctl); 126e3228ed9SCédric Le Goater 127e3228ed9SCédric Le Goater ctl &= ~CTRL_CE_STOP_ACTIVE; 128e3228ed9SCédric Le Goater writel(ctl, chip->ctl); 129e3228ed9SCédric Le Goater } 130e3228ed9SCédric Le Goater 131e3228ed9SCédric Le Goater static void aspeed_spi_stop_user(struct aspeed_spi_chip *chip) 132e3228ed9SCédric Le Goater { 133e3228ed9SCédric Le Goater u32 ctl = chip->ctl_val[ASPEED_SPI_READ] | 134e3228ed9SCédric Le Goater CTRL_IO_MODE_USER | CTRL_CE_STOP_ACTIVE; 135e3228ed9SCédric Le Goater 136e3228ed9SCédric Le Goater writel(ctl, chip->ctl); 137e3228ed9SCédric Le Goater 138e3228ed9SCédric Le Goater /* Restore defaults */ 139e3228ed9SCédric Le Goater writel(chip->ctl_val[ASPEED_SPI_READ], chip->ctl); 140e3228ed9SCédric Le Goater } 141e3228ed9SCédric Le Goater 142e3228ed9SCédric Le Goater static int aspeed_spi_read_from_ahb(void *buf, void __iomem *src, size_t len) 143e3228ed9SCédric Le Goater { 144e3228ed9SCédric Le Goater size_t offset = 0; 145e3228ed9SCédric Le Goater 146e3228ed9SCédric Le Goater if (IS_ALIGNED((uintptr_t)src, sizeof(uintptr_t)) && 147e3228ed9SCédric Le Goater IS_ALIGNED((uintptr_t)buf, sizeof(uintptr_t))) { 148e3228ed9SCédric Le Goater ioread32_rep(src, buf, len >> 2); 149e3228ed9SCédric Le Goater offset = len & ~0x3; 150e3228ed9SCédric Le Goater len -= offset; 151e3228ed9SCédric Le Goater } 152e3228ed9SCédric Le Goater ioread8_rep(src, (u8 *)buf + offset, len); 153e3228ed9SCédric Le Goater return 0; 154e3228ed9SCédric Le Goater } 155e3228ed9SCédric Le Goater 156e3228ed9SCédric Le Goater static int aspeed_spi_write_to_ahb(void __iomem *dst, const void *buf, size_t len) 157e3228ed9SCédric Le Goater { 158e3228ed9SCédric Le Goater size_t offset = 0; 159e3228ed9SCédric Le Goater 160e3228ed9SCédric Le Goater if (IS_ALIGNED((uintptr_t)dst, sizeof(uintptr_t)) && 161e3228ed9SCédric Le Goater IS_ALIGNED((uintptr_t)buf, sizeof(uintptr_t))) { 162e3228ed9SCédric Le Goater iowrite32_rep(dst, buf, len >> 2); 163e3228ed9SCédric Le Goater offset = len & ~0x3; 164e3228ed9SCédric Le Goater len -= offset; 165e3228ed9SCédric Le Goater } 166e3228ed9SCédric Le Goater iowrite8_rep(dst, (const u8 *)buf + offset, len); 167e3228ed9SCédric Le Goater return 0; 168e3228ed9SCédric Le Goater } 169e3228ed9SCédric Le Goater 170e3228ed9SCédric Le Goater static int aspeed_spi_send_cmd_addr(struct aspeed_spi_chip *chip, u8 addr_nbytes, 171e3228ed9SCédric Le Goater u64 offset, u32 opcode) 172e3228ed9SCédric Le Goater { 173e3228ed9SCédric Le Goater __be32 temp; 174e3228ed9SCédric Le Goater u32 cmdaddr; 175e3228ed9SCédric Le Goater 176e3228ed9SCédric Le Goater switch (addr_nbytes) { 177e3228ed9SCédric Le Goater case 3: 178e3228ed9SCédric Le Goater cmdaddr = offset & 0xFFFFFF; 179e3228ed9SCédric Le Goater cmdaddr |= opcode << 24; 180e3228ed9SCédric Le Goater 181e3228ed9SCédric Le Goater temp = cpu_to_be32(cmdaddr); 182e3228ed9SCédric Le Goater aspeed_spi_write_to_ahb(chip->ahb_base, &temp, 4); 183e3228ed9SCédric Le Goater break; 184e3228ed9SCédric Le Goater case 4: 185e3228ed9SCédric Le Goater temp = cpu_to_be32(offset); 186e3228ed9SCédric Le Goater aspeed_spi_write_to_ahb(chip->ahb_base, &opcode, 1); 187e3228ed9SCédric Le Goater aspeed_spi_write_to_ahb(chip->ahb_base, &temp, 4); 188e3228ed9SCédric Le Goater break; 189e3228ed9SCédric Le Goater default: 190e3228ed9SCédric Le Goater WARN_ONCE(1, "Unexpected address width %u", addr_nbytes); 191e3228ed9SCédric Le Goater return -EOPNOTSUPP; 192e3228ed9SCédric Le Goater } 193e3228ed9SCédric Le Goater return 0; 194e3228ed9SCédric Le Goater } 195e3228ed9SCédric Le Goater 196e3228ed9SCédric Le Goater static int aspeed_spi_read_reg(struct aspeed_spi_chip *chip, 197e3228ed9SCédric Le Goater const struct spi_mem_op *op) 198e3228ed9SCédric Le Goater { 199e3228ed9SCédric Le Goater aspeed_spi_start_user(chip); 200e3228ed9SCédric Le Goater aspeed_spi_write_to_ahb(chip->ahb_base, &op->cmd.opcode, 1); 201e3228ed9SCédric Le Goater aspeed_spi_read_from_ahb(op->data.buf.in, 202e3228ed9SCédric Le Goater chip->ahb_base, op->data.nbytes); 203e3228ed9SCédric Le Goater aspeed_spi_stop_user(chip); 204e3228ed9SCédric Le Goater return 0; 205e3228ed9SCédric Le Goater } 206e3228ed9SCédric Le Goater 207e3228ed9SCédric Le Goater static int aspeed_spi_write_reg(struct aspeed_spi_chip *chip, 208e3228ed9SCédric Le Goater const struct spi_mem_op *op) 209e3228ed9SCédric Le Goater { 210e3228ed9SCédric Le Goater aspeed_spi_start_user(chip); 211e3228ed9SCédric Le Goater aspeed_spi_write_to_ahb(chip->ahb_base, &op->cmd.opcode, 1); 212e3228ed9SCédric Le Goater aspeed_spi_write_to_ahb(chip->ahb_base, op->data.buf.out, 213e3228ed9SCédric Le Goater op->data.nbytes); 214e3228ed9SCédric Le Goater aspeed_spi_stop_user(chip); 215e3228ed9SCédric Le Goater return 0; 216e3228ed9SCédric Le Goater } 217e3228ed9SCédric Le Goater 218e3228ed9SCédric Le Goater static ssize_t aspeed_spi_read_user(struct aspeed_spi_chip *chip, 219e3228ed9SCédric Le Goater const struct spi_mem_op *op, 220e3228ed9SCédric Le Goater u64 offset, size_t len, void *buf) 221e3228ed9SCédric Le Goater { 222e3228ed9SCédric Le Goater int io_mode = aspeed_spi_get_io_mode(op); 223e3228ed9SCédric Le Goater u8 dummy = 0xFF; 224e3228ed9SCédric Le Goater int i; 225e3228ed9SCédric Le Goater int ret; 226e3228ed9SCédric Le Goater 227e3228ed9SCédric Le Goater aspeed_spi_start_user(chip); 228e3228ed9SCédric Le Goater 229e3228ed9SCédric Le Goater ret = aspeed_spi_send_cmd_addr(chip, op->addr.nbytes, offset, op->cmd.opcode); 230e3228ed9SCédric Le Goater if (ret < 0) 231e3228ed9SCédric Le Goater return ret; 232e3228ed9SCédric Le Goater 233e3228ed9SCédric Le Goater if (op->dummy.buswidth && op->dummy.nbytes) { 234e3228ed9SCédric Le Goater for (i = 0; i < op->dummy.nbytes / op->dummy.buswidth; i++) 235e3228ed9SCédric Le Goater aspeed_spi_write_to_ahb(chip->ahb_base, &dummy, sizeof(dummy)); 236e3228ed9SCédric Le Goater } 237e3228ed9SCédric Le Goater 238e3228ed9SCédric Le Goater aspeed_spi_set_io_mode(chip, io_mode); 239e3228ed9SCédric Le Goater 240e3228ed9SCédric Le Goater aspeed_spi_read_from_ahb(buf, chip->ahb_base, len); 241e3228ed9SCédric Le Goater aspeed_spi_stop_user(chip); 242e3228ed9SCédric Le Goater return 0; 243e3228ed9SCédric Le Goater } 244e3228ed9SCédric Le Goater 245e3228ed9SCédric Le Goater static ssize_t aspeed_spi_write_user(struct aspeed_spi_chip *chip, 246e3228ed9SCédric Le Goater const struct spi_mem_op *op) 247e3228ed9SCédric Le Goater { 248e3228ed9SCédric Le Goater int ret; 249e3228ed9SCédric Le Goater 250e3228ed9SCédric Le Goater aspeed_spi_start_user(chip); 251e3228ed9SCédric Le Goater ret = aspeed_spi_send_cmd_addr(chip, op->addr.nbytes, op->addr.val, op->cmd.opcode); 252e3228ed9SCédric Le Goater if (ret < 0) 253e3228ed9SCédric Le Goater return ret; 254e3228ed9SCédric Le Goater aspeed_spi_write_to_ahb(chip->ahb_base, op->data.buf.out, op->data.nbytes); 255e3228ed9SCédric Le Goater aspeed_spi_stop_user(chip); 256e3228ed9SCédric Le Goater return 0; 257e3228ed9SCédric Le Goater } 258e3228ed9SCédric Le Goater 259e3228ed9SCédric Le Goater /* support for 1-1-1, 1-1-2 or 1-1-4 */ 260e3228ed9SCédric Le Goater static bool aspeed_spi_supports_op(struct spi_mem *mem, const struct spi_mem_op *op) 261e3228ed9SCédric Le Goater { 262e3228ed9SCédric Le Goater if (op->cmd.buswidth > 1) 263e3228ed9SCédric Le Goater return false; 264e3228ed9SCédric Le Goater 265e3228ed9SCédric Le Goater if (op->addr.nbytes != 0) { 266e3228ed9SCédric Le Goater if (op->addr.buswidth > 1) 267e3228ed9SCédric Le Goater return false; 268e3228ed9SCédric Le Goater if (op->addr.nbytes < 3 || op->addr.nbytes > 4) 269e3228ed9SCédric Le Goater return false; 270e3228ed9SCédric Le Goater } 271e3228ed9SCédric Le Goater 272e3228ed9SCédric Le Goater if (op->dummy.nbytes != 0) { 273e3228ed9SCédric Le Goater if (op->dummy.buswidth > 1 || op->dummy.nbytes > 7) 274e3228ed9SCédric Le Goater return false; 275e3228ed9SCédric Le Goater } 276e3228ed9SCédric Le Goater 277e3228ed9SCédric Le Goater if (op->data.nbytes != 0 && op->data.buswidth > 4) 278e3228ed9SCédric Le Goater return false; 279e3228ed9SCédric Le Goater 280e3228ed9SCédric Le Goater return spi_mem_default_supports_op(mem, op); 281e3228ed9SCédric Le Goater } 282e3228ed9SCédric Le Goater 283e3228ed9SCédric Le Goater static int do_aspeed_spi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op) 284e3228ed9SCédric Le Goater { 285e3228ed9SCédric Le Goater struct aspeed_spi *aspi = spi_controller_get_devdata(mem->spi->master); 286e3228ed9SCédric Le Goater struct aspeed_spi_chip *chip = &aspi->chips[mem->spi->chip_select]; 287e3228ed9SCédric Le Goater u32 addr_mode, addr_mode_backup; 288e3228ed9SCédric Le Goater u32 ctl_val; 289e3228ed9SCédric Le Goater int ret = 0; 290e3228ed9SCédric Le Goater 291e3228ed9SCédric Le Goater dev_dbg(aspi->dev, 292e3228ed9SCédric Le Goater "CE%d %s OP %#x mode:%d.%d.%d.%d naddr:%#x ndummies:%#x len:%#x", 293e3228ed9SCédric Le Goater chip->cs, op->data.dir == SPI_MEM_DATA_IN ? "read" : "write", 294e3228ed9SCédric Le Goater op->cmd.opcode, op->cmd.buswidth, op->addr.buswidth, 295e3228ed9SCédric Le Goater op->dummy.buswidth, op->data.buswidth, 296e3228ed9SCédric Le Goater op->addr.nbytes, op->dummy.nbytes, op->data.nbytes); 297e3228ed9SCédric Le Goater 298e3228ed9SCédric Le Goater addr_mode = readl(aspi->regs + CE_CTRL_REG); 299e3228ed9SCédric Le Goater addr_mode_backup = addr_mode; 300e3228ed9SCédric Le Goater 301e3228ed9SCédric Le Goater ctl_val = chip->ctl_val[ASPEED_SPI_BASE]; 302e3228ed9SCédric Le Goater ctl_val &= ~CTRL_IO_CMD_MASK; 303e3228ed9SCédric Le Goater 304e3228ed9SCédric Le Goater ctl_val |= op->cmd.opcode << CTRL_COMMAND_SHIFT; 305e3228ed9SCédric Le Goater 306e3228ed9SCédric Le Goater /* 4BYTE address mode */ 307e3228ed9SCédric Le Goater if (op->addr.nbytes) { 308e3228ed9SCédric Le Goater if (op->addr.nbytes == 4) 309e3228ed9SCédric Le Goater addr_mode |= (0x11 << chip->cs); 310e3228ed9SCédric Le Goater else 311e3228ed9SCédric Le Goater addr_mode &= ~(0x11 << chip->cs); 312e3228ed9SCédric Le Goater } 313e3228ed9SCédric Le Goater 314e3228ed9SCédric Le Goater if (op->dummy.nbytes) 315e3228ed9SCédric Le Goater ctl_val |= CTRL_IO_DUMMY_SET(op->dummy.nbytes / op->dummy.buswidth); 316e3228ed9SCédric Le Goater 317e3228ed9SCédric Le Goater if (op->data.nbytes) 318e3228ed9SCédric Le Goater ctl_val |= aspeed_spi_get_io_mode(op); 319e3228ed9SCédric Le Goater 320e3228ed9SCédric Le Goater if (op->data.dir == SPI_MEM_DATA_OUT) 321e3228ed9SCédric Le Goater ctl_val |= CTRL_IO_MODE_WRITE; 322e3228ed9SCédric Le Goater else 323e3228ed9SCédric Le Goater ctl_val |= CTRL_IO_MODE_READ; 324e3228ed9SCédric Le Goater 325e3228ed9SCédric Le Goater if (addr_mode != addr_mode_backup) 326e3228ed9SCédric Le Goater writel(addr_mode, aspi->regs + CE_CTRL_REG); 327e3228ed9SCédric Le Goater writel(ctl_val, chip->ctl); 328e3228ed9SCédric Le Goater 329e3228ed9SCédric Le Goater if (op->data.dir == SPI_MEM_DATA_IN) { 330e3228ed9SCédric Le Goater if (!op->addr.nbytes) 331e3228ed9SCédric Le Goater ret = aspeed_spi_read_reg(chip, op); 332e3228ed9SCédric Le Goater else 333e3228ed9SCédric Le Goater ret = aspeed_spi_read_user(chip, op, op->addr.val, 334e3228ed9SCédric Le Goater op->data.nbytes, op->data.buf.in); 335e3228ed9SCédric Le Goater } else { 336e3228ed9SCédric Le Goater if (!op->addr.nbytes) 337e3228ed9SCédric Le Goater ret = aspeed_spi_write_reg(chip, op); 338e3228ed9SCédric Le Goater else 339e3228ed9SCédric Le Goater ret = aspeed_spi_write_user(chip, op); 340e3228ed9SCédric Le Goater } 341e3228ed9SCédric Le Goater 342e3228ed9SCédric Le Goater /* Restore defaults */ 343e3228ed9SCédric Le Goater if (addr_mode != addr_mode_backup) 344e3228ed9SCédric Le Goater writel(addr_mode_backup, aspi->regs + CE_CTRL_REG); 345e3228ed9SCédric Le Goater writel(chip->ctl_val[ASPEED_SPI_READ], chip->ctl); 346e3228ed9SCédric Le Goater return ret; 347e3228ed9SCédric Le Goater } 348e3228ed9SCédric Le Goater 349e3228ed9SCédric Le Goater static int aspeed_spi_exec_op(struct spi_mem *mem, const struct spi_mem_op *op) 350e3228ed9SCédric Le Goater { 351e3228ed9SCédric Le Goater int ret; 352e3228ed9SCédric Le Goater 353e3228ed9SCédric Le Goater ret = do_aspeed_spi_exec_op(mem, op); 354e3228ed9SCédric Le Goater if (ret) 355e3228ed9SCédric Le Goater dev_err(&mem->spi->dev, "operation failed: %d\n", ret); 356e3228ed9SCédric Le Goater return ret; 357e3228ed9SCédric Le Goater } 358e3228ed9SCédric Le Goater 359e3228ed9SCédric Le Goater static const char *aspeed_spi_get_name(struct spi_mem *mem) 360e3228ed9SCédric Le Goater { 361e3228ed9SCédric Le Goater struct aspeed_spi *aspi = spi_controller_get_devdata(mem->spi->master); 362e3228ed9SCédric Le Goater struct device *dev = aspi->dev; 363e3228ed9SCédric Le Goater 364e3228ed9SCédric Le Goater return devm_kasprintf(dev, GFP_KERNEL, "%s.%d", dev_name(dev), mem->spi->chip_select); 365e3228ed9SCédric Le Goater } 366e3228ed9SCédric Le Goater 367e3228ed9SCédric Le Goater struct aspeed_spi_window { 368e3228ed9SCédric Le Goater u32 cs; 369e3228ed9SCédric Le Goater u32 offset; 370e3228ed9SCédric Le Goater u32 size; 371e3228ed9SCédric Le Goater }; 372e3228ed9SCédric Le Goater 373e3228ed9SCédric Le Goater static void aspeed_spi_get_windows(struct aspeed_spi *aspi, 374e3228ed9SCédric Le Goater struct aspeed_spi_window windows[ASPEED_SPI_MAX_NUM_CS]) 375e3228ed9SCédric Le Goater { 376e3228ed9SCédric Le Goater const struct aspeed_spi_data *data = aspi->data; 377e3228ed9SCédric Le Goater u32 reg_val; 378e3228ed9SCédric Le Goater u32 cs; 379e3228ed9SCédric Le Goater 380e3228ed9SCédric Le Goater for (cs = 0; cs < aspi->data->max_cs; cs++) { 381e3228ed9SCédric Le Goater reg_val = readl(aspi->regs + CE0_SEGMENT_ADDR_REG + cs * 4); 382e3228ed9SCédric Le Goater windows[cs].cs = cs; 383e3228ed9SCédric Le Goater windows[cs].size = data->segment_end(aspi, reg_val) - 384e3228ed9SCédric Le Goater data->segment_start(aspi, reg_val); 385e3228ed9SCédric Le Goater windows[cs].offset = cs ? windows[cs - 1].offset + windows[cs - 1].size : 0; 386e3228ed9SCédric Le Goater dev_vdbg(aspi->dev, "CE%d offset=0x%.8x size=0x%x\n", cs, 387e3228ed9SCédric Le Goater windows[cs].offset, windows[cs].size); 388e3228ed9SCédric Le Goater } 389e3228ed9SCédric Le Goater } 390e3228ed9SCédric Le Goater 391e3228ed9SCédric Le Goater /* 392e3228ed9SCédric Le Goater * On the AST2600, some CE windows are closed by default at reset but 393e3228ed9SCédric Le Goater * U-Boot should open all. 394e3228ed9SCédric Le Goater */ 395e3228ed9SCédric Le Goater static int aspeed_spi_chip_set_default_window(struct aspeed_spi_chip *chip) 396e3228ed9SCédric Le Goater { 397e3228ed9SCédric Le Goater struct aspeed_spi *aspi = chip->aspi; 398e3228ed9SCédric Le Goater struct aspeed_spi_window windows[ASPEED_SPI_MAX_NUM_CS] = { 0 }; 399e3228ed9SCédric Le Goater struct aspeed_spi_window *win = &windows[chip->cs]; 400e3228ed9SCédric Le Goater 401e3228ed9SCédric Le Goater aspeed_spi_get_windows(aspi, windows); 402e3228ed9SCédric Le Goater 403e3228ed9SCédric Le Goater chip->ahb_base = aspi->ahb_base + win->offset; 404e3228ed9SCédric Le Goater chip->ahb_window_size = win->size; 405e3228ed9SCédric Le Goater 406e3228ed9SCédric Le Goater dev_dbg(aspi->dev, "CE%d default window [ 0x%.8x - 0x%.8x ] %dMB", 407e3228ed9SCédric Le Goater chip->cs, aspi->ahb_base_phy + win->offset, 408e3228ed9SCédric Le Goater aspi->ahb_base_phy + win->offset + win->size - 1, 409e3228ed9SCédric Le Goater win->size >> 20); 410e3228ed9SCédric Le Goater 411e3228ed9SCédric Le Goater return chip->ahb_window_size ? 0 : -1; 412e3228ed9SCédric Le Goater } 413e3228ed9SCédric Le Goater 414*bb084f94SCédric Le Goater static int aspeed_spi_set_window(struct aspeed_spi *aspi, 415*bb084f94SCédric Le Goater const struct aspeed_spi_window *win) 416*bb084f94SCédric Le Goater { 417*bb084f94SCédric Le Goater u32 start = aspi->ahb_base_phy + win->offset; 418*bb084f94SCédric Le Goater u32 end = start + win->size; 419*bb084f94SCédric Le Goater void __iomem *seg_reg = aspi->regs + CE0_SEGMENT_ADDR_REG + win->cs * 4; 420*bb084f94SCédric Le Goater u32 seg_val_backup = readl(seg_reg); 421*bb084f94SCédric Le Goater u32 seg_val = aspi->data->segment_reg(aspi, start, end); 422*bb084f94SCédric Le Goater 423*bb084f94SCédric Le Goater if (seg_val == seg_val_backup) 424*bb084f94SCédric Le Goater return 0; 425*bb084f94SCédric Le Goater 426*bb084f94SCédric Le Goater writel(seg_val, seg_reg); 427*bb084f94SCédric Le Goater 428*bb084f94SCédric Le Goater /* 429*bb084f94SCédric Le Goater * Restore initial value if something goes wrong else we could 430*bb084f94SCédric Le Goater * loose access to the chip. 431*bb084f94SCédric Le Goater */ 432*bb084f94SCédric Le Goater if (seg_val != readl(seg_reg)) { 433*bb084f94SCédric Le Goater dev_err(aspi->dev, "CE%d invalid window [ 0x%.8x - 0x%.8x ] %dMB", 434*bb084f94SCédric Le Goater win->cs, start, end - 1, win->size >> 20); 435*bb084f94SCédric Le Goater writel(seg_val_backup, seg_reg); 436*bb084f94SCédric Le Goater return -EIO; 437*bb084f94SCédric Le Goater } 438*bb084f94SCédric Le Goater 439*bb084f94SCédric Le Goater if (win->size) 440*bb084f94SCédric Le Goater dev_dbg(aspi->dev, "CE%d new window [ 0x%.8x - 0x%.8x ] %dMB", 441*bb084f94SCédric Le Goater win->cs, start, end - 1, win->size >> 20); 442*bb084f94SCédric Le Goater else 443*bb084f94SCédric Le Goater dev_dbg(aspi->dev, "CE%d window closed", win->cs); 444*bb084f94SCédric Le Goater 445*bb084f94SCédric Le Goater return 0; 446*bb084f94SCédric Le Goater } 447*bb084f94SCédric Le Goater 448*bb084f94SCédric Le Goater /* 449*bb084f94SCédric Le Goater * Yet to be done when possible : 450*bb084f94SCédric Le Goater * - Align mappings on flash size (we don't have the info) 451*bb084f94SCédric Le Goater * - ioremap each window, not strictly necessary since the overall window 452*bb084f94SCédric Le Goater * is correct. 453*bb084f94SCédric Le Goater */ 454*bb084f94SCédric Le Goater static int aspeed_spi_chip_adjust_window(struct aspeed_spi_chip *chip, 455*bb084f94SCédric Le Goater u32 local_offset, u32 size) 456*bb084f94SCédric Le Goater { 457*bb084f94SCédric Le Goater struct aspeed_spi *aspi = chip->aspi; 458*bb084f94SCédric Le Goater struct aspeed_spi_window windows[ASPEED_SPI_MAX_NUM_CS] = { 0 }; 459*bb084f94SCédric Le Goater struct aspeed_spi_window *win = &windows[chip->cs]; 460*bb084f94SCédric Le Goater int ret; 461*bb084f94SCédric Le Goater 462*bb084f94SCédric Le Goater aspeed_spi_get_windows(aspi, windows); 463*bb084f94SCédric Le Goater 464*bb084f94SCédric Le Goater /* Adjust this chip window */ 465*bb084f94SCédric Le Goater win->offset += local_offset; 466*bb084f94SCédric Le Goater win->size = size; 467*bb084f94SCédric Le Goater 468*bb084f94SCédric Le Goater if (win->offset + win->size > aspi->ahb_window_size) { 469*bb084f94SCédric Le Goater win->size = aspi->ahb_window_size - win->offset; 470*bb084f94SCédric Le Goater dev_warn(aspi->dev, "CE%d window resized to %dMB", chip->cs, win->size >> 20); 471*bb084f94SCédric Le Goater } 472*bb084f94SCédric Le Goater 473*bb084f94SCédric Le Goater ret = aspeed_spi_set_window(aspi, win); 474*bb084f94SCédric Le Goater if (ret) 475*bb084f94SCédric Le Goater return ret; 476*bb084f94SCédric Le Goater 477*bb084f94SCédric Le Goater /* Update chip mapping info */ 478*bb084f94SCédric Le Goater chip->ahb_base = aspi->ahb_base + win->offset; 479*bb084f94SCédric Le Goater chip->ahb_window_size = win->size; 480*bb084f94SCédric Le Goater 481*bb084f94SCédric Le Goater /* 482*bb084f94SCédric Le Goater * Also adjust next chip window to make sure that it does not 483*bb084f94SCédric Le Goater * overlap with the current window. 484*bb084f94SCédric Le Goater */ 485*bb084f94SCédric Le Goater if (chip->cs < aspi->data->max_cs - 1) { 486*bb084f94SCédric Le Goater struct aspeed_spi_window *next = &windows[chip->cs + 1]; 487*bb084f94SCédric Le Goater 488*bb084f94SCédric Le Goater /* Change offset and size to keep the same end address */ 489*bb084f94SCédric Le Goater if ((next->offset + next->size) > (win->offset + win->size)) 490*bb084f94SCédric Le Goater next->size = (next->offset + next->size) - (win->offset + win->size); 491*bb084f94SCédric Le Goater else 492*bb084f94SCédric Le Goater next->size = 0; 493*bb084f94SCédric Le Goater next->offset = win->offset + win->size; 494*bb084f94SCédric Le Goater 495*bb084f94SCédric Le Goater aspeed_spi_set_window(aspi, next); 496*bb084f94SCédric Le Goater } 497*bb084f94SCédric Le Goater return 0; 498*bb084f94SCédric Le Goater } 499*bb084f94SCédric Le Goater 5009da06d7bSCédric Le Goater static int aspeed_spi_dirmap_create(struct spi_mem_dirmap_desc *desc) 5019da06d7bSCédric Le Goater { 5029da06d7bSCédric Le Goater struct aspeed_spi *aspi = spi_controller_get_devdata(desc->mem->spi->master); 5039da06d7bSCédric Le Goater struct aspeed_spi_chip *chip = &aspi->chips[desc->mem->spi->chip_select]; 5049da06d7bSCédric Le Goater struct spi_mem_op *op = &desc->info.op_tmpl; 5059da06d7bSCédric Le Goater u32 ctl_val; 5069da06d7bSCédric Le Goater int ret = 0; 5079da06d7bSCédric Le Goater 5089da06d7bSCédric Le Goater chip->clk_freq = desc->mem->spi->max_speed_hz; 5099da06d7bSCédric Le Goater 5109da06d7bSCédric Le Goater /* Only for reads */ 5119da06d7bSCédric Le Goater if (op->data.dir != SPI_MEM_DATA_IN) 5129da06d7bSCédric Le Goater return -EOPNOTSUPP; 5139da06d7bSCédric Le Goater 514*bb084f94SCédric Le Goater aspeed_spi_chip_adjust_window(chip, desc->info.offset, desc->info.length); 515*bb084f94SCédric Le Goater 5169da06d7bSCédric Le Goater if (desc->info.length > chip->ahb_window_size) 5179da06d7bSCédric Le Goater dev_warn(aspi->dev, "CE%d window (%dMB) too small for mapping", 5189da06d7bSCédric Le Goater chip->cs, chip->ahb_window_size >> 20); 5199da06d7bSCédric Le Goater 5209da06d7bSCédric Le Goater /* Define the default IO read settings */ 5219da06d7bSCédric Le Goater ctl_val = readl(chip->ctl) & ~CTRL_IO_CMD_MASK; 5229da06d7bSCédric Le Goater ctl_val |= aspeed_spi_get_io_mode(op) | 5239da06d7bSCédric Le Goater op->cmd.opcode << CTRL_COMMAND_SHIFT | 5249da06d7bSCédric Le Goater CTRL_IO_DUMMY_SET(op->dummy.nbytes / op->dummy.buswidth) | 5259da06d7bSCédric Le Goater CTRL_IO_MODE_READ; 5269da06d7bSCédric Le Goater 5279da06d7bSCédric Le Goater /* Tune 4BYTE address mode */ 5289da06d7bSCédric Le Goater if (op->addr.nbytes) { 5299da06d7bSCédric Le Goater u32 addr_mode = readl(aspi->regs + CE_CTRL_REG); 5309da06d7bSCédric Le Goater 5319da06d7bSCédric Le Goater if (op->addr.nbytes == 4) 5329da06d7bSCédric Le Goater addr_mode |= (0x11 << chip->cs); 5339da06d7bSCédric Le Goater else 5349da06d7bSCédric Le Goater addr_mode &= ~(0x11 << chip->cs); 5359da06d7bSCédric Le Goater writel(addr_mode, aspi->regs + CE_CTRL_REG); 5369da06d7bSCédric Le Goater } 5379da06d7bSCédric Le Goater 5389da06d7bSCédric Le Goater /* READ mode is the controller default setting */ 5399da06d7bSCédric Le Goater chip->ctl_val[ASPEED_SPI_READ] = ctl_val; 5409da06d7bSCédric Le Goater writel(chip->ctl_val[ASPEED_SPI_READ], chip->ctl); 5419da06d7bSCédric Le Goater 5429da06d7bSCédric Le Goater dev_info(aspi->dev, "CE%d read buswidth:%d [0x%08x]\n", 5439da06d7bSCédric Le Goater chip->cs, op->data.buswidth, chip->ctl_val[ASPEED_SPI_READ]); 5449da06d7bSCédric Le Goater 5459da06d7bSCédric Le Goater return ret; 5469da06d7bSCédric Le Goater } 5479da06d7bSCédric Le Goater 5489da06d7bSCédric Le Goater static ssize_t aspeed_spi_dirmap_read(struct spi_mem_dirmap_desc *desc, 5499da06d7bSCédric Le Goater u64 offset, size_t len, void *buf) 5509da06d7bSCédric Le Goater { 5519da06d7bSCédric Le Goater struct aspeed_spi *aspi = spi_controller_get_devdata(desc->mem->spi->master); 5529da06d7bSCédric Le Goater struct aspeed_spi_chip *chip = &aspi->chips[desc->mem->spi->chip_select]; 5539da06d7bSCédric Le Goater 5549da06d7bSCédric Le Goater /* Switch to USER command mode if mapping window is too small */ 5559da06d7bSCédric Le Goater if (chip->ahb_window_size < offset + len) { 5569da06d7bSCédric Le Goater int ret; 5579da06d7bSCédric Le Goater 5589da06d7bSCédric Le Goater ret = aspeed_spi_read_user(chip, &desc->info.op_tmpl, offset, len, buf); 5599da06d7bSCédric Le Goater if (ret < 0) 5609da06d7bSCédric Le Goater return ret; 5619da06d7bSCédric Le Goater } else { 5629da06d7bSCédric Le Goater memcpy_fromio(buf, chip->ahb_base + offset, len); 5639da06d7bSCédric Le Goater } 5649da06d7bSCédric Le Goater 5659da06d7bSCédric Le Goater return len; 5669da06d7bSCédric Le Goater } 5679da06d7bSCédric Le Goater 568e3228ed9SCédric Le Goater static const struct spi_controller_mem_ops aspeed_spi_mem_ops = { 569e3228ed9SCédric Le Goater .supports_op = aspeed_spi_supports_op, 570e3228ed9SCédric Le Goater .exec_op = aspeed_spi_exec_op, 571e3228ed9SCédric Le Goater .get_name = aspeed_spi_get_name, 5729da06d7bSCédric Le Goater .dirmap_create = aspeed_spi_dirmap_create, 5739da06d7bSCédric Le Goater .dirmap_read = aspeed_spi_dirmap_read, 574e3228ed9SCédric Le Goater }; 575e3228ed9SCédric Le Goater 576e3228ed9SCédric Le Goater static void aspeed_spi_chip_set_type(struct aspeed_spi *aspi, unsigned int cs, int type) 577e3228ed9SCédric Le Goater { 578e3228ed9SCédric Le Goater u32 reg; 579e3228ed9SCédric Le Goater 580e3228ed9SCédric Le Goater reg = readl(aspi->regs + CONFIG_REG); 581e3228ed9SCédric Le Goater reg &= ~(0x3 << (cs * 2)); 582e3228ed9SCédric Le Goater reg |= type << (cs * 2); 583e3228ed9SCédric Le Goater writel(reg, aspi->regs + CONFIG_REG); 584e3228ed9SCédric Le Goater } 585e3228ed9SCédric Le Goater 586e3228ed9SCédric Le Goater static void aspeed_spi_chip_enable(struct aspeed_spi *aspi, unsigned int cs, bool enable) 587e3228ed9SCédric Le Goater { 588e3228ed9SCédric Le Goater u32 we_bit = BIT(aspi->data->we0 + cs); 589e3228ed9SCédric Le Goater u32 reg = readl(aspi->regs + CONFIG_REG); 590e3228ed9SCédric Le Goater 591e3228ed9SCédric Le Goater if (enable) 592e3228ed9SCédric Le Goater reg |= we_bit; 593e3228ed9SCédric Le Goater else 594e3228ed9SCédric Le Goater reg &= ~we_bit; 595e3228ed9SCédric Le Goater writel(reg, aspi->regs + CONFIG_REG); 596e3228ed9SCédric Le Goater } 597e3228ed9SCédric Le Goater 598e3228ed9SCédric Le Goater static int aspeed_spi_setup(struct spi_device *spi) 599e3228ed9SCédric Le Goater { 600e3228ed9SCédric Le Goater struct aspeed_spi *aspi = spi_controller_get_devdata(spi->master); 601e3228ed9SCédric Le Goater const struct aspeed_spi_data *data = aspi->data; 602e3228ed9SCédric Le Goater unsigned int cs = spi->chip_select; 603e3228ed9SCédric Le Goater struct aspeed_spi_chip *chip = &aspi->chips[cs]; 604e3228ed9SCédric Le Goater 605e3228ed9SCédric Le Goater chip->aspi = aspi; 606e3228ed9SCédric Le Goater chip->cs = cs; 607e3228ed9SCédric Le Goater chip->ctl = aspi->regs + data->ctl0 + cs * 4; 608e3228ed9SCédric Le Goater 609e3228ed9SCédric Le Goater /* The driver only supports SPI type flash */ 610e3228ed9SCédric Le Goater if (data->hastype) 611e3228ed9SCédric Le Goater aspeed_spi_chip_set_type(aspi, cs, CONFIG_TYPE_SPI); 612e3228ed9SCédric Le Goater 613e3228ed9SCédric Le Goater if (aspeed_spi_chip_set_default_window(chip) < 0) { 614e3228ed9SCédric Le Goater dev_warn(aspi->dev, "CE%d window invalid", cs); 615e3228ed9SCédric Le Goater return -EINVAL; 616e3228ed9SCédric Le Goater } 617e3228ed9SCédric Le Goater 618e3228ed9SCédric Le Goater aspeed_spi_chip_enable(aspi, cs, true); 619e3228ed9SCédric Le Goater 620e3228ed9SCédric Le Goater chip->ctl_val[ASPEED_SPI_BASE] = CTRL_CE_STOP_ACTIVE | CTRL_IO_MODE_USER; 621e3228ed9SCédric Le Goater 622e3228ed9SCédric Le Goater dev_dbg(aspi->dev, "CE%d setup done\n", cs); 623e3228ed9SCédric Le Goater return 0; 624e3228ed9SCédric Le Goater } 625e3228ed9SCédric Le Goater 626e3228ed9SCédric Le Goater static void aspeed_spi_cleanup(struct spi_device *spi) 627e3228ed9SCédric Le Goater { 628e3228ed9SCédric Le Goater struct aspeed_spi *aspi = spi_controller_get_devdata(spi->master); 629e3228ed9SCédric Le Goater unsigned int cs = spi->chip_select; 630e3228ed9SCédric Le Goater 631e3228ed9SCédric Le Goater aspeed_spi_chip_enable(aspi, cs, false); 632e3228ed9SCédric Le Goater 633e3228ed9SCédric Le Goater dev_dbg(aspi->dev, "CE%d cleanup done\n", cs); 634e3228ed9SCédric Le Goater } 635e3228ed9SCédric Le Goater 636e3228ed9SCédric Le Goater static void aspeed_spi_enable(struct aspeed_spi *aspi, bool enable) 637e3228ed9SCédric Le Goater { 638e3228ed9SCédric Le Goater int cs; 639e3228ed9SCédric Le Goater 640e3228ed9SCédric Le Goater for (cs = 0; cs < aspi->data->max_cs; cs++) 641e3228ed9SCédric Le Goater aspeed_spi_chip_enable(aspi, cs, enable); 642e3228ed9SCédric Le Goater } 643e3228ed9SCédric Le Goater 644e3228ed9SCédric Le Goater static int aspeed_spi_probe(struct platform_device *pdev) 645e3228ed9SCédric Le Goater { 646e3228ed9SCédric Le Goater struct device *dev = &pdev->dev; 647e3228ed9SCédric Le Goater const struct aspeed_spi_data *data; 648e3228ed9SCédric Le Goater struct spi_controller *ctlr; 649e3228ed9SCédric Le Goater struct aspeed_spi *aspi; 650e3228ed9SCédric Le Goater struct resource *res; 651e3228ed9SCédric Le Goater int ret; 652e3228ed9SCédric Le Goater 653e3228ed9SCédric Le Goater data = of_device_get_match_data(&pdev->dev); 654e3228ed9SCédric Le Goater if (!data) 655e3228ed9SCédric Le Goater return -ENODEV; 656e3228ed9SCédric Le Goater 657e3228ed9SCédric Le Goater ctlr = devm_spi_alloc_master(dev, sizeof(*aspi)); 658e3228ed9SCédric Le Goater if (!ctlr) 659e3228ed9SCédric Le Goater return -ENOMEM; 660e3228ed9SCédric Le Goater 661e3228ed9SCédric Le Goater aspi = spi_controller_get_devdata(ctlr); 662e3228ed9SCédric Le Goater platform_set_drvdata(pdev, aspi); 663e3228ed9SCédric Le Goater aspi->data = data; 664e3228ed9SCédric Le Goater aspi->dev = dev; 665e3228ed9SCédric Le Goater 666e3228ed9SCédric Le Goater res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 667e3228ed9SCédric Le Goater aspi->regs = devm_ioremap_resource(dev, res); 668e3228ed9SCédric Le Goater if (IS_ERR(aspi->regs)) { 669e3228ed9SCédric Le Goater dev_err(dev, "missing AHB register window\n"); 670e3228ed9SCédric Le Goater return PTR_ERR(aspi->regs); 671e3228ed9SCédric Le Goater } 672e3228ed9SCédric Le Goater 673e3228ed9SCédric Le Goater res = platform_get_resource(pdev, IORESOURCE_MEM, 1); 674e3228ed9SCédric Le Goater aspi->ahb_base = devm_ioremap_resource(dev, res); 675e3228ed9SCédric Le Goater if (IS_ERR(aspi->ahb_base)) { 676e3228ed9SCédric Le Goater dev_err(dev, "missing AHB mapping window\n"); 677e3228ed9SCédric Le Goater return PTR_ERR(aspi->ahb_base); 678e3228ed9SCédric Le Goater } 679e3228ed9SCédric Le Goater 680e3228ed9SCédric Le Goater aspi->ahb_window_size = resource_size(res); 681e3228ed9SCédric Le Goater aspi->ahb_base_phy = res->start; 682e3228ed9SCédric Le Goater 683e3228ed9SCédric Le Goater aspi->clk = devm_clk_get(&pdev->dev, NULL); 684e3228ed9SCédric Le Goater if (IS_ERR(aspi->clk)) { 685e3228ed9SCédric Le Goater dev_err(dev, "missing clock\n"); 686e3228ed9SCédric Le Goater return PTR_ERR(aspi->clk); 687e3228ed9SCédric Le Goater } 688e3228ed9SCédric Le Goater 689e3228ed9SCédric Le Goater aspi->clk_freq = clk_get_rate(aspi->clk); 690e3228ed9SCédric Le Goater if (!aspi->clk_freq) { 691e3228ed9SCédric Le Goater dev_err(dev, "invalid clock\n"); 692e3228ed9SCédric Le Goater return -EINVAL; 693e3228ed9SCédric Le Goater } 694e3228ed9SCédric Le Goater 695e3228ed9SCédric Le Goater ret = clk_prepare_enable(aspi->clk); 696e3228ed9SCédric Le Goater if (ret) { 697e3228ed9SCédric Le Goater dev_err(dev, "can not enable the clock\n"); 698e3228ed9SCédric Le Goater return ret; 699e3228ed9SCédric Le Goater } 700e3228ed9SCédric Le Goater 701e3228ed9SCédric Le Goater /* IRQ is for DMA, which the driver doesn't support yet */ 702e3228ed9SCédric Le Goater 703e3228ed9SCédric Le Goater ctlr->mode_bits = SPI_RX_DUAL | SPI_TX_DUAL | data->mode_bits; 704e3228ed9SCédric Le Goater ctlr->bus_num = pdev->id; 705e3228ed9SCédric Le Goater ctlr->mem_ops = &aspeed_spi_mem_ops; 706e3228ed9SCédric Le Goater ctlr->setup = aspeed_spi_setup; 707e3228ed9SCédric Le Goater ctlr->cleanup = aspeed_spi_cleanup; 708e3228ed9SCédric Le Goater ctlr->num_chipselect = data->max_cs; 709e3228ed9SCédric Le Goater ctlr->dev.of_node = dev->of_node; 710e3228ed9SCédric Le Goater 711e3228ed9SCédric Le Goater ret = devm_spi_register_controller(dev, ctlr); 712e3228ed9SCédric Le Goater if (ret) { 713e3228ed9SCédric Le Goater dev_err(&pdev->dev, "spi_register_controller failed\n"); 714e3228ed9SCédric Le Goater goto disable_clk; 715e3228ed9SCédric Le Goater } 716e3228ed9SCédric Le Goater return 0; 717e3228ed9SCédric Le Goater 718e3228ed9SCédric Le Goater disable_clk: 719e3228ed9SCédric Le Goater clk_disable_unprepare(aspi->clk); 720e3228ed9SCédric Le Goater return ret; 721e3228ed9SCédric Le Goater } 722e3228ed9SCédric Le Goater 723e3228ed9SCédric Le Goater static int aspeed_spi_remove(struct platform_device *pdev) 724e3228ed9SCédric Le Goater { 725e3228ed9SCédric Le Goater struct aspeed_spi *aspi = platform_get_drvdata(pdev); 726e3228ed9SCédric Le Goater 727e3228ed9SCédric Le Goater aspeed_spi_enable(aspi, false); 728e3228ed9SCédric Le Goater clk_disable_unprepare(aspi->clk); 729e3228ed9SCédric Le Goater return 0; 730e3228ed9SCédric Le Goater } 731e3228ed9SCédric Le Goater 732e3228ed9SCédric Le Goater /* 733e3228ed9SCédric Le Goater * AHB mappings 734e3228ed9SCédric Le Goater */ 735e3228ed9SCédric Le Goater 736e3228ed9SCédric Le Goater /* 737e3228ed9SCédric Le Goater * The Segment Registers of the AST2400 and AST2500 use a 8MB unit. 738e3228ed9SCédric Le Goater * The address range is encoded with absolute addresses in the overall 739e3228ed9SCédric Le Goater * mapping window. 740e3228ed9SCédric Le Goater */ 741e3228ed9SCédric Le Goater static u32 aspeed_spi_segment_start(struct aspeed_spi *aspi, u32 reg) 742e3228ed9SCédric Le Goater { 743e3228ed9SCédric Le Goater return ((reg >> 16) & 0xFF) << 23; 744e3228ed9SCédric Le Goater } 745e3228ed9SCédric Le Goater 746e3228ed9SCédric Le Goater static u32 aspeed_spi_segment_end(struct aspeed_spi *aspi, u32 reg) 747e3228ed9SCédric Le Goater { 748e3228ed9SCédric Le Goater return ((reg >> 24) & 0xFF) << 23; 749e3228ed9SCédric Le Goater } 750e3228ed9SCédric Le Goater 751e3228ed9SCédric Le Goater static u32 aspeed_spi_segment_reg(struct aspeed_spi *aspi, u32 start, u32 end) 752e3228ed9SCédric Le Goater { 753e3228ed9SCédric Le Goater return (((start >> 23) & 0xFF) << 16) | (((end >> 23) & 0xFF) << 24); 754e3228ed9SCédric Le Goater } 755e3228ed9SCédric Le Goater 756e3228ed9SCédric Le Goater /* 757e3228ed9SCédric Le Goater * The Segment Registers of the AST2600 use a 1MB unit. The address 758e3228ed9SCédric Le Goater * range is encoded with offsets in the overall mapping window. 759e3228ed9SCédric Le Goater */ 760e3228ed9SCédric Le Goater 761e3228ed9SCédric Le Goater #define AST2600_SEG_ADDR_MASK 0x0ff00000 762e3228ed9SCédric Le Goater 763e3228ed9SCédric Le Goater static u32 aspeed_spi_segment_ast2600_start(struct aspeed_spi *aspi, 764e3228ed9SCédric Le Goater u32 reg) 765e3228ed9SCédric Le Goater { 766e3228ed9SCédric Le Goater u32 start_offset = (reg << 16) & AST2600_SEG_ADDR_MASK; 767e3228ed9SCédric Le Goater 768e3228ed9SCédric Le Goater return aspi->ahb_base_phy + start_offset; 769e3228ed9SCédric Le Goater } 770e3228ed9SCédric Le Goater 771e3228ed9SCédric Le Goater static u32 aspeed_spi_segment_ast2600_end(struct aspeed_spi *aspi, 772e3228ed9SCédric Le Goater u32 reg) 773e3228ed9SCédric Le Goater { 774e3228ed9SCédric Le Goater u32 end_offset = reg & AST2600_SEG_ADDR_MASK; 775e3228ed9SCédric Le Goater 776e3228ed9SCédric Le Goater /* segment is disabled */ 777e3228ed9SCédric Le Goater if (!end_offset) 778e3228ed9SCédric Le Goater return aspi->ahb_base_phy; 779e3228ed9SCédric Le Goater 780e3228ed9SCédric Le Goater return aspi->ahb_base_phy + end_offset + 0x100000; 781e3228ed9SCédric Le Goater } 782e3228ed9SCédric Le Goater 783e3228ed9SCédric Le Goater static u32 aspeed_spi_segment_ast2600_reg(struct aspeed_spi *aspi, 784e3228ed9SCédric Le Goater u32 start, u32 end) 785e3228ed9SCédric Le Goater { 786e3228ed9SCédric Le Goater /* disable zero size segments */ 787e3228ed9SCédric Le Goater if (start == end) 788e3228ed9SCédric Le Goater return 0; 789e3228ed9SCédric Le Goater 790e3228ed9SCédric Le Goater return ((start & AST2600_SEG_ADDR_MASK) >> 16) | 791e3228ed9SCédric Le Goater ((end - 1) & AST2600_SEG_ADDR_MASK); 792e3228ed9SCédric Le Goater } 793e3228ed9SCédric Le Goater 794e3228ed9SCédric Le Goater /* 795e3228ed9SCédric Le Goater * Platform definitions 796e3228ed9SCédric Le Goater */ 797e3228ed9SCédric Le Goater static const struct aspeed_spi_data ast2400_fmc_data = { 798e3228ed9SCédric Le Goater .max_cs = 5, 799e3228ed9SCédric Le Goater .hastype = true, 800e3228ed9SCédric Le Goater .we0 = 16, 801e3228ed9SCédric Le Goater .ctl0 = CE0_CTRL_REG, 802e3228ed9SCédric Le Goater .segment_start = aspeed_spi_segment_start, 803e3228ed9SCédric Le Goater .segment_end = aspeed_spi_segment_end, 804e3228ed9SCédric Le Goater .segment_reg = aspeed_spi_segment_reg, 805e3228ed9SCédric Le Goater }; 806e3228ed9SCédric Le Goater 807e3228ed9SCédric Le Goater static const struct aspeed_spi_data ast2500_fmc_data = { 808e3228ed9SCédric Le Goater .max_cs = 3, 809e3228ed9SCédric Le Goater .hastype = true, 810e3228ed9SCédric Le Goater .we0 = 16, 811e3228ed9SCédric Le Goater .ctl0 = CE0_CTRL_REG, 812e3228ed9SCédric Le Goater .segment_start = aspeed_spi_segment_start, 813e3228ed9SCédric Le Goater .segment_end = aspeed_spi_segment_end, 814e3228ed9SCédric Le Goater .segment_reg = aspeed_spi_segment_reg, 815e3228ed9SCédric Le Goater }; 816e3228ed9SCédric Le Goater 817e3228ed9SCédric Le Goater static const struct aspeed_spi_data ast2500_spi_data = { 818e3228ed9SCédric Le Goater .max_cs = 2, 819e3228ed9SCédric Le Goater .hastype = false, 820e3228ed9SCédric Le Goater .we0 = 16, 821e3228ed9SCédric Le Goater .ctl0 = CE0_CTRL_REG, 822e3228ed9SCédric Le Goater .segment_start = aspeed_spi_segment_start, 823e3228ed9SCédric Le Goater .segment_end = aspeed_spi_segment_end, 824e3228ed9SCédric Le Goater .segment_reg = aspeed_spi_segment_reg, 825e3228ed9SCédric Le Goater }; 826e3228ed9SCédric Le Goater 827e3228ed9SCédric Le Goater static const struct aspeed_spi_data ast2600_fmc_data = { 828e3228ed9SCédric Le Goater .max_cs = 3, 829e3228ed9SCédric Le Goater .hastype = false, 830e3228ed9SCédric Le Goater .mode_bits = SPI_RX_QUAD | SPI_RX_QUAD, 831e3228ed9SCédric Le Goater .we0 = 16, 832e3228ed9SCédric Le Goater .ctl0 = CE0_CTRL_REG, 833e3228ed9SCédric Le Goater .segment_start = aspeed_spi_segment_ast2600_start, 834e3228ed9SCédric Le Goater .segment_end = aspeed_spi_segment_ast2600_end, 835e3228ed9SCédric Le Goater .segment_reg = aspeed_spi_segment_ast2600_reg, 836e3228ed9SCédric Le Goater }; 837e3228ed9SCédric Le Goater 838e3228ed9SCédric Le Goater static const struct aspeed_spi_data ast2600_spi_data = { 839e3228ed9SCédric Le Goater .max_cs = 2, 840e3228ed9SCédric Le Goater .hastype = false, 841e3228ed9SCédric Le Goater .mode_bits = SPI_RX_QUAD | SPI_RX_QUAD, 842e3228ed9SCédric Le Goater .we0 = 16, 843e3228ed9SCédric Le Goater .ctl0 = CE0_CTRL_REG, 844e3228ed9SCédric Le Goater .segment_start = aspeed_spi_segment_ast2600_start, 845e3228ed9SCédric Le Goater .segment_end = aspeed_spi_segment_ast2600_end, 846e3228ed9SCédric Le Goater .segment_reg = aspeed_spi_segment_ast2600_reg, 847e3228ed9SCédric Le Goater }; 848e3228ed9SCédric Le Goater 849e3228ed9SCédric Le Goater static const struct of_device_id aspeed_spi_matches[] = { 850e3228ed9SCédric Le Goater { .compatible = "aspeed,ast2400-fmc", .data = &ast2400_fmc_data }, 851e3228ed9SCédric Le Goater { .compatible = "aspeed,ast2500-fmc", .data = &ast2500_fmc_data }, 852e3228ed9SCédric Le Goater { .compatible = "aspeed,ast2500-spi", .data = &ast2500_spi_data }, 853e3228ed9SCédric Le Goater { .compatible = "aspeed,ast2600-fmc", .data = &ast2600_fmc_data }, 854e3228ed9SCédric Le Goater { .compatible = "aspeed,ast2600-spi", .data = &ast2600_spi_data }, 855e3228ed9SCédric Le Goater { } 856e3228ed9SCédric Le Goater }; 857e3228ed9SCédric Le Goater MODULE_DEVICE_TABLE(of, aspeed_spi_matches); 858e3228ed9SCédric Le Goater 859e3228ed9SCédric Le Goater static struct platform_driver aspeed_spi_driver = { 860e3228ed9SCédric Le Goater .probe = aspeed_spi_probe, 861e3228ed9SCédric Le Goater .remove = aspeed_spi_remove, 862e3228ed9SCédric Le Goater .driver = { 863e3228ed9SCédric Le Goater .name = DEVICE_NAME, 864e3228ed9SCédric Le Goater .of_match_table = aspeed_spi_matches, 865e3228ed9SCédric Le Goater } 866e3228ed9SCédric Le Goater }; 867e3228ed9SCédric Le Goater 868e3228ed9SCédric Le Goater module_platform_driver(aspeed_spi_driver); 869e3228ed9SCédric Le Goater 870e3228ed9SCédric Le Goater MODULE_DESCRIPTION("ASPEED Static Memory Controller Driver"); 871e3228ed9SCédric Le Goater MODULE_AUTHOR("Chin-Ting Kuo <chin-ting_kuo@aspeedtech.com>"); 872e3228ed9SCédric Le Goater MODULE_AUTHOR("Cedric Le Goater <clg@kaod.org>"); 873e3228ed9SCédric Le Goater MODULE_LICENSE("GPL v2"); 874