exynos_spi.c 10.9 KB
Newer Older
1 2 3 4
/*
 * (C) Copyright 2012 SAMSUNG Electronics
 * Padmavathi Venna <padma.v@samsung.com>
 *
5
 * SPDX-License-Identifier:	GPL-2.0+
6 7 8
 */

#include <common.h>
9 10
#include <dm.h>
#include <errno.h>
11 12
#include <malloc.h>
#include <spi.h>
13
#include <fdtdec.h>
14 15 16 17 18
#include <asm/arch/clk.h>
#include <asm/arch/clock.h>
#include <asm/arch/cpu.h>
#include <asm/arch/gpio.h>
#include <asm/arch/pinmux.h>
19
#include <asm/arch/spi.h>
20 21
#include <asm/io.h>

22 23
DECLARE_GLOBAL_DATA_PTR;

24
struct exynos_spi_platdata {
25 26 27
	enum periph_id periph_id;
	s32 frequency;		/* Default clock frequency, -1 for none */
	struct exynos_spi *regs;
28
	uint deactivate_delay_us;	/* Delay to wait after deactivate */
29 30
};

31
struct exynos_spi_priv {
32 33 34 35 36
	struct exynos_spi *regs;
	unsigned int freq;		/* Default frequency */
	unsigned int mode;
	enum periph_id periph_id;	/* Peripheral ID for this device */
	unsigned int fifo_size;
37
	int skip_preamble;
38
	ulong last_transaction_us;	/* Time of last transaction end */
39 40 41 42 43
};

/**
 * Flush spi tx, rx fifos and reset the SPI controller
 *
44
 * @param regs	Pointer to SPI registers
45
 */
46
static void spi_flush_fifo(struct exynos_spi *regs)
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67
{
	clrsetbits_le32(&regs->ch_cfg, SPI_CH_HS_EN, SPI_CH_RST);
	clrbits_le32(&regs->ch_cfg, SPI_CH_RST);
	setbits_le32(&regs->ch_cfg, SPI_TX_CH_ON | SPI_RX_CH_ON);
}

static void spi_get_fifo_levels(struct exynos_spi *regs,
	int *rx_lvl, int *tx_lvl)
{
	uint32_t spi_sts = readl(&regs->spi_sts);

	*rx_lvl = (spi_sts >> SPI_RX_LVL_OFFSET) & SPI_FIFO_LVL_MASK;
	*tx_lvl = (spi_sts >> SPI_TX_LVL_OFFSET) & SPI_FIFO_LVL_MASK;
}

/**
 * If there's something to transfer, do a software reset and set a
 * transaction size.
 *
 * @param regs	SPI peripheral registers
 * @param count	Number of bytes to transfer
68
 * @param step	Number of bytes to transfer in each packet (1 or 4)
69
 */
70
static void spi_request_bytes(struct exynos_spi *regs, int count, int step)
71
{
72 73
	debug("%s: regs=%p, count=%d, step=%d\n", __func__, regs, count, step);

74 75 76 77 78 79 80 81 82 83 84 85 86 87 88
	/* For word address we need to swap bytes */
	if (step == 4) {
		setbits_le32(&regs->mode_cfg,
			     SPI_MODE_CH_WIDTH_WORD | SPI_MODE_BUS_WIDTH_WORD);
		count /= 4;
		setbits_le32(&regs->swap_cfg, SPI_TX_SWAP_EN | SPI_RX_SWAP_EN |
			SPI_TX_BYTE_SWAP | SPI_RX_BYTE_SWAP |
			SPI_TX_HWORD_SWAP | SPI_RX_HWORD_SWAP);
	} else {
		/* Select byte access and clear the swap configuration */
		clrbits_le32(&regs->mode_cfg,
			     SPI_MODE_CH_WIDTH_WORD | SPI_MODE_BUS_WIDTH_WORD);
		writel(0, &regs->swap_cfg);
	}

89 90 91
	assert(count && count < (1 << 16));
	setbits_le32(&regs->ch_cfg, SPI_CH_RST);
	clrbits_le32(&regs->ch_cfg, SPI_CH_RST);
92

93 94 95
	writel(count | SPI_PACKET_CNT_EN, &regs->pkt_cnt);
}

96
static int spi_rx_tx(struct exynos_spi_priv *priv, int todo,
97
			void **dinp, void const **doutp, unsigned long flags)
98
{
99
	struct exynos_spi *regs = priv->regs;
100 101 102 103
	uchar *rxp = *dinp;
	const uchar *txp = *doutp;
	int rx_lvl, tx_lvl;
	uint out_bytes, in_bytes;
104 105 106
	int toread;
	unsigned start = get_timer(0);
	int stopping;
107
	int step;
108 109 110

	out_bytes = in_bytes = todo;

111 112
	stopping = priv->skip_preamble && (flags & SPI_XFER_END) &&
					!(priv->mode & SPI_SLAVE);
113

114 115 116 117 118 119
	/*
	 * Try to transfer words if we can. This helps read performance at
	 * SPI clock speeds above about 20MHz.
	 */
	step = 1;
	if (!((todo | (uintptr_t)rxp | (uintptr_t)txp) & 3) &&
120
	    !priv->skip_preamble)
121 122
		step = 4;

123 124 125 126
	/*
	 * If there's something to send, do a software reset and set a
	 * transaction size.
	 */
127
	spi_request_bytes(regs, todo, step);
128 129 130 131 132

	/*
	 * Bytes are transmitted/received in pairs. Wait to receive all the
	 * data because then transmission will be done as well.
	 */
133 134
	toread = in_bytes;

135 136 137 138 139
	while (in_bytes) {
		int temp;

		/* Keep the fifos full/empty. */
		spi_get_fifo_levels(regs, &rx_lvl, &tx_lvl);
140 141 142 143 144

		/*
		 * Don't completely fill the txfifo, since we don't want our
		 * rxfifo to overflow, and it may already contain data.
		 */
145
		while (tx_lvl < priv->fifo_size/2 && out_bytes) {
146 147 148 149 150 151
			if (!txp)
				temp = -1;
			else if (step == 4)
				temp = *(uint32_t *)txp;
			else
				temp = *txp;
152
			writel(temp, &regs->tx_data);
153 154 155 156
			out_bytes -= step;
			if (txp)
				txp += step;
			tx_lvl += step;
157
		}
158 159
		if (rx_lvl >= step) {
			while (rx_lvl >= step) {
160
				temp = readl(&regs->rx_data);
161
				if (priv->skip_preamble) {
162
					if (temp == SPI_PREAMBLE_END_BYTE) {
163
						priv->skip_preamble = 0;
164 165 166
						stopping = 0;
					}
				} else {
167
					if (rxp || stopping) {
168 169 170 171
						if (step == 4)
							*(uint32_t *)rxp = temp;
						else
							*rxp = temp;
172 173 174
						rxp += step;
					}
					in_bytes -= step;
175
				}
176 177 178
				toread -= step;
				rx_lvl -= step;
			}
179 180 181 182 183 184 185 186 187 188 189
		} else if (!toread) {
			/*
			 * We have run out of input data, but haven't read
			 * enough bytes after the preamble yet. Read some more,
			 * and make sure that we transmit dummy bytes too, to
			 * keep things going.
			 */
			assert(!out_bytes);
			out_bytes = in_bytes;
			toread = in_bytes;
			txp = NULL;
190
			spi_request_bytes(regs, toread, step);
191
		}
192
		if (priv->skip_preamble && get_timer(start) > 100) {
193 194 195
			debug("SPI timeout: in_bytes=%d, out_bytes=%d, ",
			      in_bytes, out_bytes);
			return -ETIMEDOUT;
196 197
		}
	}
198

199 200
	*dinp = rxp;
	*doutp = txp;
201 202

	return 0;
203 204 205 206 207 208 209 210
}

/**
 * Activate the CS by driving it LOW
 *
 * @param slave	Pointer to spi_slave to which controller has to
 *		communicate with
 */
211
static void spi_cs_activate(struct udevice *dev)
212
{
213 214 215
	struct udevice *bus = dev->parent;
	struct exynos_spi_platdata *pdata = dev_get_platdata(bus);
	struct exynos_spi_priv *priv = dev_get_priv(bus);
216

217
	/* If it's too soon to do another transaction, wait */
218 219
	if (pdata->deactivate_delay_us &&
	    priv->last_transaction_us) {
220
		ulong delay_us;		/* The delay completed so far */
221 222 223
		delay_us = timer_get_us() - priv->last_transaction_us;
		if (delay_us < pdata->deactivate_delay_us)
			udelay(pdata->deactivate_delay_us - delay_us);
224 225
	}

226 227 228
	clrbits_le32(&priv->regs->cs_reg, SPI_SLAVE_SIG_INACT);
	debug("Activate CS, bus '%s'\n", bus->name);
	priv->skip_preamble = priv->mode & SPI_PREAMBLE;
229 230 231 232 233 234 235 236
}

/**
 * Deactivate the CS by driving it HIGH
 *
 * @param slave	Pointer to spi_slave to which controller has to
 *		communicate with
 */
237
static void spi_cs_deactivate(struct udevice *dev)
238
{
239 240 241
	struct udevice *bus = dev->parent;
	struct exynos_spi_platdata *pdata = dev_get_platdata(bus);
	struct exynos_spi_priv *priv = dev_get_priv(bus);
242

243
	setbits_le32(&priv->regs->cs_reg, SPI_SLAVE_SIG_INACT);
244 245

	/* Remember time of this transaction so we can honour the bus delay */
246 247
	if (pdata->deactivate_delay_us)
		priv->last_transaction_us = timer_get_us();
248

249
	debug("Deactivate CS, bus '%s'\n", bus->name);
250 251
}

252
static int exynos_spi_ofdata_to_platdata(struct udevice *bus)
253
{
254 255 256
	struct exynos_spi_platdata *plat = bus->platdata;
	const void *blob = gd->fdt_blob;
	int node = bus->of_offset;
257

258
	plat->regs = (struct exynos_spi *)dev_get_addr(bus);
259
	plat->periph_id = pinmux_decode_periph_id(blob, node);
260

261
	if (plat->periph_id == PERIPH_ID_NONE) {
262
		debug("%s: Invalid peripheral ID %d\n", __func__,
263
			plat->periph_id);
264 265 266 267
		return -FDT_ERR_NOTFOUND;
	}

	/* Use 500KHz as a suitable default */
268
	plat->frequency = fdtdec_get_int(blob, node, "spi-max-frequency",
269
					500000);
270
	plat->deactivate_delay_us = fdtdec_get_int(blob, node,
271
					"spi-deactivate-delay", 0);
272 273 274
	debug("%s: regs=%p, periph_id=%d, max-frequency=%d, deactivate_delay=%d\n",
	      __func__, plat->regs, plat->periph_id, plat->frequency,
	      plat->deactivate_delay_us);
275 276 277 278

	return 0;
}

279
static int exynos_spi_probe(struct udevice *bus)
280
{
281 282
	struct exynos_spi_platdata *plat = dev_get_platdata(bus);
	struct exynos_spi_priv *priv = dev_get_priv(bus);
283

284 285 286 287 288 289
	priv->regs = plat->regs;
	if (plat->periph_id == PERIPH_ID_SPI1 ||
	    plat->periph_id == PERIPH_ID_SPI2)
		priv->fifo_size = 64;
	else
		priv->fifo_size = 256;
290

291 292 293 294
	priv->skip_preamble = 0;
	priv->last_transaction_us = timer_get_us();
	priv->freq = plat->frequency;
	priv->periph_id = plat->periph_id;
295

296 297
	return 0;
}
298

299
static int exynos_spi_claim_bus(struct udevice *dev)
300
{
301
	struct udevice *bus = dev->parent;
302 303 304 305 306 307
	struct exynos_spi_priv *priv = dev_get_priv(bus);

	exynos_pinmux_config(priv->periph_id, PINMUX_FLAG_NONE);
	spi_flush_fifo(priv->regs);

	writel(SPI_FB_DELAY_180, &priv->regs->fb_clk);
308 309 310 311

	return 0;
}

312
static int exynos_spi_release_bus(struct udevice *dev)
313
{
314
	struct udevice *bus = dev->parent;
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352
	struct exynos_spi_priv *priv = dev_get_priv(bus);

	spi_flush_fifo(priv->regs);

	return 0;
}

static int exynos_spi_xfer(struct udevice *dev, unsigned int bitlen,
			   const void *dout, void *din, unsigned long flags)
{
	struct udevice *bus = dev->parent;
	struct exynos_spi_priv *priv = dev_get_priv(bus);
	int upto, todo;
	int bytelen;
	int ret = 0;

	/* spi core configured to do 8 bit transfers */
	if (bitlen % 8) {
		debug("Non byte aligned SPI transfer.\n");
		return -1;
	}

	/* Start the transaction, if necessary. */
	if ((flags & SPI_XFER_BEGIN))
		spi_cs_activate(dev);

	/*
	 * Exynos SPI limits each transfer to 65535 transfers. To keep
	 * things simple, allow a maximum of 65532 bytes. We could allow
	 * more in word mode, but the performance difference is small.
	 */
	bytelen = bitlen / 8;
	for (upto = 0; !ret && upto < bytelen; upto += todo) {
		todo = min(bytelen - upto, (1 << 16) - 4);
		ret = spi_rx_tx(priv, todo, &din, &dout, flags);
		if (ret)
			break;
	}
353

354 355 356 357 358 359 360 361
	/* Stop the transaction, if necessary. */
	if ((flags & SPI_XFER_END) && !(priv->mode & SPI_SLAVE)) {
		spi_cs_deactivate(dev);
		if (priv->skip_preamble) {
			assert(!priv->skip_preamble);
			debug("Failed to complete premable transaction\n");
			ret = -1;
		}
362 363
	}

364
	return ret;
365 366
}

367
static int exynos_spi_set_speed(struct udevice *bus, uint speed)
368
{
369 370 371
	struct exynos_spi_platdata *plat = bus->platdata;
	struct exynos_spi_priv *priv = dev_get_priv(bus);
	int ret;
372

373 374 375 376 377 378 379 380 381 382
	if (speed > plat->frequency)
		speed = plat->frequency;
	ret = set_spi_clk(priv->periph_id, speed);
	if (ret)
		return ret;
	priv->freq = speed;
	debug("%s: regs=%p, speed=%d\n", __func__, priv->regs, priv->freq);

	return 0;
}
383

384 385 386 387
static int exynos_spi_set_mode(struct udevice *bus, uint mode)
{
	struct exynos_spi_priv *priv = dev_get_priv(bus);
	uint32_t reg;
388

389 390
	reg = readl(&priv->regs->ch_cfg);
	reg &= ~(SPI_CH_CPHA_B | SPI_CH_CPOL_L);
391

392 393
	if (mode & SPI_CPHA)
		reg |= SPI_CH_CPHA_B;
394

395 396 397 398 399 400 401 402
	if (mode & SPI_CPOL)
		reg |= SPI_CH_CPOL_L;

	writel(reg, &priv->regs->ch_cfg);
	priv->mode = mode;
	debug("%s: regs=%p, mode=%d\n", __func__, priv->regs, priv->mode);

	return 0;
403
}
404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431

static const struct dm_spi_ops exynos_spi_ops = {
	.claim_bus	= exynos_spi_claim_bus,
	.release_bus	= exynos_spi_release_bus,
	.xfer		= exynos_spi_xfer,
	.set_speed	= exynos_spi_set_speed,
	.set_mode	= exynos_spi_set_mode,
	/*
	 * cs_info is not needed, since we require all chip selects to be
	 * in the device tree explicitly
	 */
};

static const struct udevice_id exynos_spi_ids[] = {
	{ .compatible = "samsung,exynos-spi" },
	{ }
};

U_BOOT_DRIVER(exynos_spi) = {
	.name	= "exynos_spi",
	.id	= UCLASS_SPI,
	.of_match = exynos_spi_ids,
	.ops	= &exynos_spi_ops,
	.ofdata_to_platdata = exynos_spi_ofdata_to_platdata,
	.platdata_auto_alloc_size = sizeof(struct exynos_spi_platdata),
	.priv_auto_alloc_size = sizeof(struct exynos_spi_priv),
	.probe	= exynos_spi_probe,
};