drivers/spi/bcmstb_spi.c - uboot-imx - Git at Google

 // SPDX-License-Identifier: GPL-2.0+
 /*
  * (C) Copyright 2018  Cisco Systems, Inc.
  *
  * Author: Thomas Fitzsimmons <fitzsim@fitzsim.org>
  */

 #include <asm/io.h>
 #include <command.h>
 #include <config.h>
 #include <dm.h>
 #include <errno.h>
 #include <fdtdec.h>
 #include <linux/bitops.h>
 #include <linux/delay.h>
 #include <log.h>
 #include <malloc.h>
 #include <spi.h>
 #include <time.h>

 DECLARE_GLOBAL_DATA_PTR;

 #define SPBR_MIN		8
 #define BITS_PER_WORD		8

 #define NUM_TXRAM		32
 #define NUM_RXRAM		32
 #define NUM_CDRAM		16

 /* hif_mspi register structure. */
 struct bcmstb_hif_mspi_regs {
 	u32 spcr0_lsb;		/* 0x000 */
 	u32 spcr0_msb;		/* 0x004 */
 	u32 spcr1_lsb;		/* 0x008 */
 	u32 spcr1_msb;		/* 0x00c */
 	u32 newqp;		/* 0x010 */
 	u32 endqp;		/* 0x014 */
 	u32 spcr2;		/* 0x018 */
 	u32 reserved0;		/* 0x01c */
 	u32 mspi_status;	/* 0x020 */
 	u32 cptqp;		/* 0x024 */
 	u32 spcr3;		/* 0x028 */
 	u32 revision;		/* 0x02c */
 	u32 reserved1[4];	/* 0x030 */
 	u32 txram[NUM_TXRAM];	/* 0x040 */
 	u32 rxram[NUM_RXRAM];	/* 0x0c0 */
 	u32 cdram[NUM_CDRAM];	/* 0x140 */
 	u32 write_lock;		/* 0x180 */
 };

 /* hif_mspi masks. */
 #define HIF_MSPI_SPCR2_CONT_AFTER_CMD_MASK	0x00000080
 #define HIF_MSPI_SPCR2_SPE_MASK			0x00000040
 #define HIF_MSPI_SPCR2_SPIFIE_MASK		0x00000020
 #define HIF_MSPI_WRITE_LOCK_WRITE_LOCK_MASK	0x00000001

 /* bspi offsets. */
 #define BSPI_MAST_N_BOOT_CTRL			0x008

 /* bspi_raf is not used in this driver. */

 /* hif_spi_intr2 offsets and masks. */
 #define HIF_SPI_INTR2_CPU_CLEAR			0x08
 #define HIF_SPI_INTR2_CPU_MASK_SET		0x10
 #define HIF_SPI_INTR2_CPU_MASK_CLEAR		0x14
 #define HIF_SPI_INTR2_CPU_SET_MSPI_DONE_MASK	0x00000020

 /* SPI transfer timeout in milliseconds. */
 #define HIF_MSPI_WAIT				10

 enum bcmstb_base_type {
 	HIF_MSPI,
 	BSPI,
 	HIF_SPI_INTR2,
 	CS_REG,
 	BASE_LAST,
 };

 struct bcmstb_spi_platdata {
 	void *base[4];
 };

 struct bcmstb_spi_priv {
 	struct bcmstb_hif_mspi_regs *regs;
 	void *bspi;
 	void *hif_spi_intr2;
 	void *cs_reg;
 	int default_cs;
 	int curr_cs;
 	uint tx_slot;
 	uint rx_slot;
 	u8 saved_cmd[NUM_CDRAM];
 	uint saved_cmd_len;
 	void *saved_din_addr;
 };

 static int bcmstb_spi_ofdata_to_platdata(struct udevice *bus)
 {
 	struct bcmstb_spi_platdata *plat = dev_get_platdata(bus);
 	const void *fdt = gd->fdt_blob;
 	int node = dev_of_offset(bus);
 	int ret = 0;
 	int i = 0;
 	struct fdt_resource resource = { 0 };
 	char *names[BASE_LAST] = { "hif_mspi", "bspi", "hif_spi_intr2",
 				   "cs_reg" };
 	const phys_addr_t defaults[BASE_LAST] = { BCMSTB_HIF_MSPI_BASE,
 						  BCMSTB_BSPI_BASE,
 						  BCMSTB_HIF_SPI_INTR2,
 						  BCMSTB_CS_REG };

 	for (i = 0; i < BASE_LAST; i++) {
 		plat->base[i] = (void *)defaults[i];

 		ret = fdt_get_named_resource(fdt, node, "reg", "reg-names",
 					     names[i], &resource);
 		if (ret) {
 			printf("%s: Assuming BCMSTB SPI %s address 0x0x%p\n",
 			       __func__, names[i], (void *)defaults[i]);
 		} else {
 			plat->base[i] = (void *)resource.start;
 			debug("BCMSTB SPI %s address: 0x0x%p\n",
 			      names[i], (void *)plat->base[i]);
 		}
 	}

 	return 0;
 }

 static void bcmstb_spi_hw_set_parms(struct bcmstb_spi_priv *priv)
 {
 	writel(SPBR_MIN, &priv->regs->spcr0_lsb);
 	writel(BITS_PER_WORD << 2 | SPI_MODE_3, &priv->regs->spcr0_msb);
 }

 static void bcmstb_spi_enable_interrupt(void *base, u32 mask)
 {
 	void *reg = base + HIF_SPI_INTR2_CPU_MASK_CLEAR;

 	writel(readl(reg) | mask, reg);
 	readl(reg);
 }

 static void bcmstb_spi_disable_interrupt(void *base, u32 mask)
 {
 	void *reg = base + HIF_SPI_INTR2_CPU_MASK_SET;

 	writel(readl(reg) | mask, reg);
 	readl(reg);
 }

 static void bcmstb_spi_clear_interrupt(void *base, u32 mask)
 {
 	void *reg = base + HIF_SPI_INTR2_CPU_CLEAR;

 	writel(readl(reg) | mask, reg);
 	readl(reg);
 }

 static int bcmstb_spi_probe(struct udevice *bus)
 {
 	struct bcmstb_spi_platdata *plat = dev_get_platdata(bus);
 	struct bcmstb_spi_priv *priv = dev_get_priv(bus);

 	priv->regs = plat->base[HIF_MSPI];
 	priv->bspi = plat->base[BSPI];
 	priv->hif_spi_intr2 = plat->base[HIF_SPI_INTR2];
 	priv->cs_reg = plat->base[CS_REG];
 	priv->default_cs = 0;
 	priv->curr_cs = -1;
 	priv->tx_slot = 0;
 	priv->rx_slot = 0;
 	memset(priv->saved_cmd, 0, NUM_CDRAM);
 	priv->saved_cmd_len = 0;
 	priv->saved_din_addr = NULL;

 	debug("spi_xfer: tx regs: 0x%p\n", &priv->regs->txram[0]);
 	debug("spi_xfer: rx regs: 0x%p\n", &priv->regs->rxram[0]);

 	/* Disable BSPI. */
 	writel(1, priv->bspi + BSPI_MAST_N_BOOT_CTRL);
 	readl(priv->bspi + BSPI_MAST_N_BOOT_CTRL);

 	/* Set up interrupts. */
 	bcmstb_spi_disable_interrupt(priv->hif_spi_intr2, 0xffffffff);
 	bcmstb_spi_clear_interrupt(priv->hif_spi_intr2, 0xffffffff);
 	bcmstb_spi_enable_interrupt(priv->hif_spi_intr2,
 				    HIF_SPI_INTR2_CPU_SET_MSPI_DONE_MASK);

 	/* Set up control registers. */
 	writel(0, &priv->regs->spcr1_lsb);
 	writel(0, &priv->regs->spcr1_msb);
 	writel(0, &priv->regs->newqp);
 	writel(0, &priv->regs->endqp);
 	writel(HIF_MSPI_SPCR2_SPIFIE_MASK, &priv->regs->spcr2);
 	writel(0, &priv->regs->spcr3);

 	bcmstb_spi_hw_set_parms(priv);

 	return 0;
 }

 static void bcmstb_spi_submit(struct bcmstb_spi_priv *priv, bool done)
 {
 	debug("WR NEWQP: %d\n", 0);
 	writel(0, &priv->regs->newqp);

 	debug("WR ENDQP: %d\n", priv->tx_slot - 1);
 	writel(priv->tx_slot - 1, &priv->regs->endqp);

 	if (done) {
 		debug("WR CDRAM[%d]: %02x\n", priv->tx_slot - 1,
 		      readl(&priv->regs->cdram[priv->tx_slot - 1]) & ~0x80);
 		writel(readl(&priv->regs->cdram[priv->tx_slot - 1]) & ~0x80,
 		       &priv->regs->cdram[priv->tx_slot - 1]);
 	}

 	/* Force chip select first time. */
 	if (priv->curr_cs != priv->default_cs) {
 		debug("spi_xfer: switching chip select to %d\n",
 		      priv->default_cs);
 		writel((readl(priv->cs_reg) & ~0xff) | (1 << priv->default_cs),
 		       priv->cs_reg);
 		readl(priv->cs_reg);
 		udelay(10);
 		priv->curr_cs = priv->default_cs;
 	}

 	debug("WR WRITE_LOCK: %02x\n", 1);
 	writel((readl(&priv->regs->write_lock) &
 		~HIF_MSPI_WRITE_LOCK_WRITE_LOCK_MASK) | 1,
 	       &priv->regs->write_lock);
 	readl(&priv->regs->write_lock);

 	debug("WR SPCR2: %02x\n",
 	      HIF_MSPI_SPCR2_SPIFIE_MASK |
 	      HIF_MSPI_SPCR2_SPE_MASK |
 	      HIF_MSPI_SPCR2_CONT_AFTER_CMD_MASK);
 	writel(HIF_MSPI_SPCR2_SPIFIE_MASK |
 	       HIF_MSPI_SPCR2_SPE_MASK |
 	       HIF_MSPI_SPCR2_CONT_AFTER_CMD_MASK,
 	       &priv->regs->spcr2);
 }

 static int bcmstb_spi_wait(struct bcmstb_spi_priv *priv)
 {
 	u32 start_time = get_timer(0);
 	u32 status = readl(&priv->regs->mspi_status);

 	while (!(status & 1)) {
 		if (get_timer(start_time) > HIF_MSPI_WAIT)
 			return -ETIMEDOUT;
 		status = readl(&priv->regs->mspi_status);
 	}

 	writel(readl(&priv->regs->mspi_status) & ~1, &priv->regs->mspi_status);
 	bcmstb_spi_clear_interrupt(priv->hif_spi_intr2,
 				   HIF_SPI_INTR2_CPU_SET_MSPI_DONE_MASK);

 	return 0;
 }

 static int bcmstb_spi_xfer(struct udevice *dev, unsigned int bitlen,
 			   const void *dout, void *din, unsigned long flags)
 {
 	uint len = bitlen / 8;
 	uint tx_len = len;
 	uint rx_len = len;
 	const u8 *out_bytes = (u8 *)dout;
 	u8 *in_bytes = (u8 *)din;
 	struct udevice *bus = dev_get_parent(dev);
 	struct bcmstb_spi_priv *priv = dev_get_priv(bus);
 	struct bcmstb_hif_mspi_regs *regs = priv->regs;

 	debug("spi_xfer: %d, t: 0x%p, r: 0x%p, f: %lx\n",
 	      len, dout, din, flags);
 	debug("spi_xfer: chip select: %x\n", readl(priv->cs_reg) & 0xff);
 	debug("spi_xfer: tx addr: 0x%p\n", &regs->txram[0]);
 	debug("spi_xfer: rx addr: 0x%p\n", &regs->rxram[0]);
 	debug("spi_xfer: cd addr: 0x%p\n", &regs->cdram[0]);

 	if (flags & SPI_XFER_END) {
 		debug("spi_xfer: clearing saved din address: 0x%p\n",
 		      priv->saved_din_addr);
 		priv->saved_din_addr = NULL;
 		priv->saved_cmd_len = 0;
 		memset(priv->saved_cmd, 0, NUM_CDRAM);
 	}

 	if (bitlen == 0)
 		return 0;

 	if (bitlen % 8) {
 		printf("%s: Non-byte-aligned transfer\n", __func__);
 		return -EOPNOTSUPP;
 	}

 	if (flags & ~(SPI_XFER_BEGIN | SPI_XFER_END)) {
 		printf("%s: Unsupported flags: %lx\n", __func__, flags);
 		return -EOPNOTSUPP;
 	}

 	if (flags & SPI_XFER_BEGIN) {
 		priv->tx_slot = 0;
 		priv->rx_slot = 0;

 		if (out_bytes && len > NUM_CDRAM) {
 			printf("%s: Unable to save transfer\n", __func__);
 			return -EOPNOTSUPP;
 		}

 		if (out_bytes && !(flags & SPI_XFER_END)) {
 			/*
 			 * This is the start of a transmit operation
 			 * that will need repeating if the calling
 			 * code polls for the result.  Save it for
 			 * subsequent transmission.
 			 */
 			debug("spi_xfer: saving command: %x, %d\n",
 			      out_bytes[0], len);
 			priv->saved_cmd_len = len;
 			memcpy(priv->saved_cmd, out_bytes, priv->saved_cmd_len);
 		}
 	}

 	if (!(flags & (SPI_XFER_BEGIN | SPI_XFER_END))) {
 		if (priv->saved_din_addr == din) {
 			/*
 			 * The caller is polling for status.  Repeat
 			 * the last transmission.
 			 */
 			int ret = 0;

 			debug("spi_xfer: Making recursive call\n");
 			ret = bcmstb_spi_xfer(dev, priv->saved_cmd_len * 8,
 					      priv->saved_cmd, NULL,
 					      SPI_XFER_BEGIN);
 			if (ret) {
 				printf("%s: Recursive call failed\n", __func__);
 				return ret;
 			}
 		} else {
 			debug("spi_xfer: saving din address: 0x%p\n", din);
 			priv->saved_din_addr = din;
 		}
 	}

 	while (rx_len > 0) {
 		priv->rx_slot = priv->tx_slot;

 		while (priv->tx_slot < NUM_CDRAM && tx_len > 0) {
 			bcmstb_spi_hw_set_parms(priv);
 			debug("WR TXRAM[%d]: %02x\n", priv->tx_slot,
 			      out_bytes ? out_bytes[len - tx_len] : 0xff);
 			writel(out_bytes ? out_bytes[len - tx_len] : 0xff,
 			       &regs->txram[priv->tx_slot << 1]);
 			debug("WR CDRAM[%d]: %02x\n", priv->tx_slot, 0x8e);
 			writel(0x8e, &regs->cdram[priv->tx_slot]);
 			priv->tx_slot++;
 			tx_len--;
 			if (!in_bytes)
 				rx_len--;
 		}

 		debug("spi_xfer: early return clauses: %d, %d, %d\n",
 		      len <= NUM_CDRAM,
 		      !in_bytes,
 		      (flags & (SPI_XFER_BEGIN |
 				SPI_XFER_END)) == SPI_XFER_BEGIN);
 		if (len <= NUM_CDRAM &&
 		    !in_bytes &&
 		    (flags & (SPI_XFER_BEGIN | SPI_XFER_END)) == SPI_XFER_BEGIN)
 			return 0;

 		bcmstb_spi_submit(priv, tx_len == 0);

 		if (bcmstb_spi_wait(priv) == -ETIMEDOUT) {
 			printf("%s: Timed out\n", __func__);
 			return -ETIMEDOUT;
 		}

 		priv->tx_slot %= NUM_CDRAM;

 		if (in_bytes) {
 			while (priv->rx_slot < NUM_CDRAM && rx_len > 0) {
 				in_bytes[len - rx_len] =
 					readl(&regs->rxram[(priv->rx_slot << 1)
 							   + 1])
 					& 0xff;
 				debug("RD RXRAM[%d]: %02x\n",
 				      priv->rx_slot, in_bytes[len - rx_len]);
 				priv->rx_slot++;
 				rx_len--;
 			}
 		}
 	}

 	if (flags & SPI_XFER_END) {
 		debug("WR WRITE_LOCK: %02x\n", 0);
 		writel((readl(&priv->regs->write_lock) &
 			~HIF_MSPI_WRITE_LOCK_WRITE_LOCK_MASK) | 0,
 		       &priv->regs->write_lock);
 		readl(&priv->regs->write_lock);
 	}

 	return 0;
 }

 static int bcmstb_spi_set_speed(struct udevice *dev, uint speed)
 {
 	return 0;
 }

 static int bcmstb_spi_set_mode(struct udevice *dev, uint mode)
 {
 	return 0;
 }

 static const struct dm_spi_ops bcmstb_spi_ops = {
 	.xfer		= bcmstb_spi_xfer,
 	.set_speed	= bcmstb_spi_set_speed,
 	.set_mode	= bcmstb_spi_set_mode,
 };

 static const struct udevice_id bcmstb_spi_id[] = {
 	{ .compatible = "brcm,spi-brcmstb" },
 	{ }
 };

 U_BOOT_DRIVER(bcmstb_spi) = {
 	.name				= "bcmstb_spi",
 	.id				= UCLASS_SPI,
 	.of_match			= bcmstb_spi_id,
 	.ops				= &bcmstb_spi_ops,
 	.ofdata_to_platdata		= bcmstb_spi_ofdata_to_platdata,
 	.probe				= bcmstb_spi_probe,
 	.platdata_auto_alloc_size	= sizeof(struct bcmstb_spi_platdata),
 	.priv_auto_alloc_size		= sizeof(struct bcmstb_spi_priv),
 };
	// SPDX-License-Identifier: GPL-2.0+
	/*
	* (C) Copyright 2018 Cisco Systems, Inc.
	*
	* Author: Thomas Fitzsimmons <fitzsim@fitzsim.org>
	*/

	#include <asm/io.h>
	#include <command.h>
	#include <config.h>
	#include <dm.h>
	#include <errno.h>
	#include <fdtdec.h>
	#include <linux/bitops.h>
	#include <linux/delay.h>
	#include <log.h>
	#include <malloc.h>
	#include <spi.h>
	#include <time.h>

	DECLARE_GLOBAL_DATA_PTR;

	#define SPBR_MIN 8
	#define BITS_PER_WORD 8

	#define NUM_TXRAM 32
	#define NUM_RXRAM 32
	#define NUM_CDRAM 16

	/* hif_mspi register structure. */
	struct bcmstb_hif_mspi_regs {
	u32 spcr0_lsb; /* 0x000 */
	u32 spcr0_msb; /* 0x004 */
	u32 spcr1_lsb; /* 0x008 */
	u32 spcr1_msb; /* 0x00c */
	u32 newqp; /* 0x010 */
	u32 endqp; /* 0x014 */
	u32 spcr2; /* 0x018 */
	u32 reserved0; /* 0x01c */
	u32 mspi_status; /* 0x020 */
	u32 cptqp; /* 0x024 */
	u32 spcr3; /* 0x028 */
	u32 revision; /* 0x02c */
	u32 reserved1[4]; /* 0x030 */
	u32 txram[NUM_TXRAM]; /* 0x040 */
	u32 rxram[NUM_RXRAM]; /* 0x0c0 */
	u32 cdram[NUM_CDRAM]; /* 0x140 */
	u32 write_lock; /* 0x180 */
	};

	/* hif_mspi masks. */
	#define HIF_MSPI_SPCR2_CONT_AFTER_CMD_MASK 0x00000080
	#define HIF_MSPI_SPCR2_SPE_MASK 0x00000040
	#define HIF_MSPI_SPCR2_SPIFIE_MASK 0x00000020
	#define HIF_MSPI_WRITE_LOCK_WRITE_LOCK_MASK 0x00000001

	/* bspi offsets. */
	#define BSPI_MAST_N_BOOT_CTRL 0x008

	/* bspi_raf is not used in this driver. */

	/* hif_spi_intr2 offsets and masks. */
	#define HIF_SPI_INTR2_CPU_CLEAR 0x08
	#define HIF_SPI_INTR2_CPU_MASK_SET 0x10
	#define HIF_SPI_INTR2_CPU_MASK_CLEAR 0x14
	#define HIF_SPI_INTR2_CPU_SET_MSPI_DONE_MASK 0x00000020

	/* SPI transfer timeout in milliseconds. */
	#define HIF_MSPI_WAIT 10

	enum bcmstb_base_type {
	HIF_MSPI,
	BSPI,
	HIF_SPI_INTR2,
	CS_REG,
	BASE_LAST,
	};

	struct bcmstb_spi_platdata {
	void *base[4];
	};

	struct bcmstb_spi_priv {
	struct bcmstb_hif_mspi_regs *regs;
	void *bspi;
	void *hif_spi_intr2;
	void *cs_reg;
	int default_cs;
	int curr_cs;
	uint tx_slot;
	uint rx_slot;
	u8 saved_cmd[NUM_CDRAM];
	uint saved_cmd_len;
	void *saved_din_addr;
	};

	static int bcmstb_spi_ofdata_to_platdata(struct udevice *bus)
	{
	struct bcmstb_spi_platdata *plat = dev_get_platdata(bus);
	const void *fdt = gd->fdt_blob;
	int node = dev_of_offset(bus);
	int ret = 0;
	int i = 0;
	struct fdt_resource resource = { 0 };
	char *names[BASE_LAST] = { "hif_mspi", "bspi", "hif_spi_intr2",
	"cs_reg" };
	const phys_addr_t defaults[BASE_LAST] = { BCMSTB_HIF_MSPI_BASE,
	BCMSTB_BSPI_BASE,
	BCMSTB_HIF_SPI_INTR2,
	BCMSTB_CS_REG };

	for (i = 0; i < BASE_LAST; i++) {
	plat->base[i] = (void *)defaults[i];

	ret = fdt_get_named_resource(fdt, node, "reg", "reg-names",
	names[i], &resource);
	if (ret) {
	printf("%s: Assuming BCMSTB SPI %s address 0x0x%p\n",
	__func__, names[i], (void *)defaults[i]);
	} else {
	plat->base[i] = (void *)resource.start;
	debug("BCMSTB SPI %s address: 0x0x%p\n",
	names[i], (void *)plat->base[i]);
	}
	}

	return 0;
	}

	static void bcmstb_spi_hw_set_parms(struct bcmstb_spi_priv *priv)
	{
	writel(SPBR_MIN, &priv->regs->spcr0_lsb);
	writel(BITS_PER_WORD << 2 \| SPI_MODE_3, &priv->regs->spcr0_msb);
	}

	static void bcmstb_spi_enable_interrupt(void *base, u32 mask)
	{
	void *reg = base + HIF_SPI_INTR2_CPU_MASK_CLEAR;

	writel(readl(reg) \| mask, reg);
	readl(reg);
	}

	static void bcmstb_spi_disable_interrupt(void *base, u32 mask)
	{
	void *reg = base + HIF_SPI_INTR2_CPU_MASK_SET;

	writel(readl(reg) \| mask, reg);
	readl(reg);
	}

	static void bcmstb_spi_clear_interrupt(void *base, u32 mask)
	{
	void *reg = base + HIF_SPI_INTR2_CPU_CLEAR;

	writel(readl(reg) \| mask, reg);
	readl(reg);
	}

	static int bcmstb_spi_probe(struct udevice *bus)
	{
	struct bcmstb_spi_platdata *plat = dev_get_platdata(bus);
	struct bcmstb_spi_priv *priv = dev_get_priv(bus);

	priv->regs = plat->base[HIF_MSPI];
	priv->bspi = plat->base[BSPI];
	priv->hif_spi_intr2 = plat->base[HIF_SPI_INTR2];
	priv->cs_reg = plat->base[CS_REG];
	priv->default_cs = 0;
	priv->curr_cs = -1;
	priv->tx_slot = 0;
	priv->rx_slot = 0;
	memset(priv->saved_cmd, 0, NUM_CDRAM);
	priv->saved_cmd_len = 0;
	priv->saved_din_addr = NULL;

	debug("spi_xfer: tx regs: 0x%p\n", &priv->regs->txram[0]);
	debug("spi_xfer: rx regs: 0x%p\n", &priv->regs->rxram[0]);

	/* Disable BSPI. */
	writel(1, priv->bspi + BSPI_MAST_N_BOOT_CTRL);
	readl(priv->bspi + BSPI_MAST_N_BOOT_CTRL);

	/* Set up interrupts. */
	bcmstb_spi_disable_interrupt(priv->hif_spi_intr2, 0xffffffff);
	bcmstb_spi_clear_interrupt(priv->hif_spi_intr2, 0xffffffff);
	bcmstb_spi_enable_interrupt(priv->hif_spi_intr2,
	HIF_SPI_INTR2_CPU_SET_MSPI_DONE_MASK);

	/* Set up control registers. */
	writel(0, &priv->regs->spcr1_lsb);
	writel(0, &priv->regs->spcr1_msb);
	writel(0, &priv->regs->newqp);
	writel(0, &priv->regs->endqp);
	writel(HIF_MSPI_SPCR2_SPIFIE_MASK, &priv->regs->spcr2);
	writel(0, &priv->regs->spcr3);

	bcmstb_spi_hw_set_parms(priv);

	return 0;
	}

	static void bcmstb_spi_submit(struct bcmstb_spi_priv *priv, bool done)
	{
	debug("WR NEWQP: %d\n", 0);
	writel(0, &priv->regs->newqp);

	debug("WR ENDQP: %d\n", priv->tx_slot - 1);
	writel(priv->tx_slot - 1, &priv->regs->endqp);

	if (done) {
	debug("WR CDRAM[%d]: %02x\n", priv->tx_slot - 1,
	readl(&priv->regs->cdram[priv->tx_slot - 1]) & ~0x80);
	writel(readl(&priv->regs->cdram[priv->tx_slot - 1]) & ~0x80,
	&priv->regs->cdram[priv->tx_slot - 1]);
	}

	/* Force chip select first time. */
	if (priv->curr_cs != priv->default_cs) {
	debug("spi_xfer: switching chip select to %d\n",
	priv->default_cs);
	writel((readl(priv->cs_reg) & ~0xff) \| (1 << priv->default_cs),
	priv->cs_reg);
	readl(priv->cs_reg);
	udelay(10);
	priv->curr_cs = priv->default_cs;
	}

	debug("WR WRITE_LOCK: %02x\n", 1);
	writel((readl(&priv->regs->write_lock) &
	~HIF_MSPI_WRITE_LOCK_WRITE_LOCK_MASK) \| 1,
	&priv->regs->write_lock);
	readl(&priv->regs->write_lock);

	debug("WR SPCR2: %02x\n",
	HIF_MSPI_SPCR2_SPIFIE_MASK \|
	HIF_MSPI_SPCR2_SPE_MASK \|
	HIF_MSPI_SPCR2_CONT_AFTER_CMD_MASK);
	writel(HIF_MSPI_SPCR2_SPIFIE_MASK \|
	HIF_MSPI_SPCR2_SPE_MASK \|
	HIF_MSPI_SPCR2_CONT_AFTER_CMD_MASK,
	&priv->regs->spcr2);
	}

	static int bcmstb_spi_wait(struct bcmstb_spi_priv *priv)
	{
	u32 start_time = get_timer(0);
	u32 status = readl(&priv->regs->mspi_status);

	while (!(status & 1)) {
	if (get_timer(start_time) > HIF_MSPI_WAIT)
	return -ETIMEDOUT;
	status = readl(&priv->regs->mspi_status);
	}

	writel(readl(&priv->regs->mspi_status) & ~1, &priv->regs->mspi_status);
	bcmstb_spi_clear_interrupt(priv->hif_spi_intr2,
	HIF_SPI_INTR2_CPU_SET_MSPI_DONE_MASK);

	return 0;
	}

	static int bcmstb_spi_xfer(struct udevice *dev, unsigned int bitlen,
	const void dout, void din, unsigned long flags)
	{
	uint len = bitlen / 8;
	uint tx_len = len;
	uint rx_len = len;
	const u8 out_bytes = (u8 )dout;
	u8 in_bytes = (u8 )din;
	struct udevice *bus = dev_get_parent(dev);
	struct bcmstb_spi_priv *priv = dev_get_priv(bus);
	struct bcmstb_hif_mspi_regs *regs = priv->regs;

	debug("spi_xfer: %d, t: 0x%p, r: 0x%p, f: %lx\n",
	len, dout, din, flags);
	debug("spi_xfer: chip select: %x\n", readl(priv->cs_reg) & 0xff);
	debug("spi_xfer: tx addr: 0x%p\n", &regs->txram[0]);
	debug("spi_xfer: rx addr: 0x%p\n", &regs->rxram[0]);
	debug("spi_xfer: cd addr: 0x%p\n", &regs->cdram[0]);

	if (flags & SPI_XFER_END) {
	debug("spi_xfer: clearing saved din address: 0x%p\n",
	priv->saved_din_addr);
	priv->saved_din_addr = NULL;
	priv->saved_cmd_len = 0;
	memset(priv->saved_cmd, 0, NUM_CDRAM);
	}

	if (bitlen == 0)
	return 0;

	if (bitlen % 8) {
	printf("%s: Non-byte-aligned transfer\n", __func__);
	return -EOPNOTSUPP;
	}

	if (flags & ~(SPI_XFER_BEGIN \| SPI_XFER_END)) {
	printf("%s: Unsupported flags: %lx\n", __func__, flags);
	return -EOPNOTSUPP;
	}

	if (flags & SPI_XFER_BEGIN) {
	priv->tx_slot = 0;
	priv->rx_slot = 0;

	if (out_bytes && len > NUM_CDRAM) {
	printf("%s: Unable to save transfer\n", __func__);
	return -EOPNOTSUPP;
	}

	if (out_bytes && !(flags & SPI_XFER_END)) {
	/*
	* This is the start of a transmit operation
	* that will need repeating if the calling
	* code polls for the result. Save it for
	* subsequent transmission.
	*/
	debug("spi_xfer: saving command: %x, %d\n",
	out_bytes[0], len);
	priv->saved_cmd_len = len;
	memcpy(priv->saved_cmd, out_bytes, priv->saved_cmd_len);
	}
	}

	if (!(flags & (SPI_XFER_BEGIN \| SPI_XFER_END))) {
	if (priv->saved_din_addr == din) {
	/*
	* The caller is polling for status. Repeat
	* the last transmission.
	*/
	int ret = 0;

	debug("spi_xfer: Making recursive call\n");
	ret = bcmstb_spi_xfer(dev, priv->saved_cmd_len * 8,
	priv->saved_cmd, NULL,
	SPI_XFER_BEGIN);
	if (ret) {
	printf("%s: Recursive call failed\n", __func__);
	return ret;
	}
	} else {
	debug("spi_xfer: saving din address: 0x%p\n", din);
	priv->saved_din_addr = din;
	}
	}

	while (rx_len > 0) {
	priv->rx_slot = priv->tx_slot;

	while (priv->tx_slot < NUM_CDRAM && tx_len > 0) {
	bcmstb_spi_hw_set_parms(priv);
	debug("WR TXRAM[%d]: %02x\n", priv->tx_slot,
	out_bytes ? out_bytes[len - tx_len] : 0xff);
	writel(out_bytes ? out_bytes[len - tx_len] : 0xff,
	&regs->txram[priv->tx_slot << 1]);
	debug("WR CDRAM[%d]: %02x\n", priv->tx_slot, 0x8e);
	writel(0x8e, &regs->cdram[priv->tx_slot]);
	priv->tx_slot++;
	tx_len--;
	if (!in_bytes)
	rx_len--;
	}

	debug("spi_xfer: early return clauses: %d, %d, %d\n",
	len <= NUM_CDRAM,
	!in_bytes,
	(flags & (SPI_XFER_BEGIN \|
	SPI_XFER_END)) == SPI_XFER_BEGIN);
	if (len <= NUM_CDRAM &&
	!in_bytes &&
	(flags & (SPI_XFER_BEGIN \| SPI_XFER_END)) == SPI_XFER_BEGIN)
	return 0;

	bcmstb_spi_submit(priv, tx_len == 0);

	if (bcmstb_spi_wait(priv) == -ETIMEDOUT) {
	printf("%s: Timed out\n", __func__);
	return -ETIMEDOUT;
	}

	priv->tx_slot %= NUM_CDRAM;

	if (in_bytes) {
	while (priv->rx_slot < NUM_CDRAM && rx_len > 0) {
	in_bytes[len - rx_len] =
	readl(&regs->rxram[(priv->rx_slot << 1)
	+ 1])
	& 0xff;
	debug("RD RXRAM[%d]: %02x\n",
	priv->rx_slot, in_bytes[len - rx_len]);
	priv->rx_slot++;
	rx_len--;
	}
	}
	}

	if (flags & SPI_XFER_END) {
	debug("WR WRITE_LOCK: %02x\n", 0);
	writel((readl(&priv->regs->write_lock) &
	~HIF_MSPI_WRITE_LOCK_WRITE_LOCK_MASK) \| 0,
	&priv->regs->write_lock);
	readl(&priv->regs->write_lock);
	}

	return 0;
	}

	static int bcmstb_spi_set_speed(struct udevice *dev, uint speed)
	{
	return 0;
	}

	static int bcmstb_spi_set_mode(struct udevice *dev, uint mode)
	{
	return 0;
	}

	static const struct dm_spi_ops bcmstb_spi_ops = {
	.xfer = bcmstb_spi_xfer,
	.set_speed = bcmstb_spi_set_speed,
	.set_mode = bcmstb_spi_set_mode,
	};

	static const struct udevice_id bcmstb_spi_id[] = {
	{ .compatible = "brcm,spi-brcmstb" },
	{ }
	};

	U_BOOT_DRIVER(bcmstb_spi) = {
	.name = "bcmstb_spi",
	.id = UCLASS_SPI,
	.of_match = bcmstb_spi_id,
	.ops = &bcmstb_spi_ops,
	.ofdata_to_platdata = bcmstb_spi_ofdata_to_platdata,
	.probe = bcmstb_spi_probe,
	.platdata_auto_alloc_size = sizeof(struct bcmstb_spi_platdata),
	.priv_auto_alloc_size = sizeof(struct bcmstb_spi_priv),
	};