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

#include <common.h>
8
9
#include <dm.h>
#include <errno.h>
10
#include <log.h>
11
12
#include <malloc.h>
#include <spi.h>
13
#include <fdtdec.h>
14
#include <time.h>
15
16
17
18
19
#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>
20
#include <asm/arch/spi.h>
21
#include <asm/global_data.h>
22
#include <asm/io.h>
23
#include <linux/delay.h>
24

25
26
DECLARE_GLOBAL_DATA_PTR;

27
struct exynos_spi_plat {
28
29
30
	enum periph_id periph_id;
	s32 frequency;		/* Default clock frequency, -1 for none */
	struct exynos_spi *regs;
31
	uint deactivate_delay_us;	/* Delay to wait after deactivate */
32
33
};

34
struct exynos_spi_priv {
35
36
37
38
39
	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;
40
	int skip_preamble;
41
	ulong last_transaction_us;	/* Time of last transaction end */
42
43
44
45
46
};

/**
 * Flush spi tx, rx fifos and reset the SPI controller
 *
47
 * @param regs	Pointer to SPI registers
48
 */
49
static void spi_flush_fifo(struct exynos_spi *regs)
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
{
	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
71
 * @param step	Number of bytes to transfer in each packet (1 or 4)
72
 */
73
static void spi_request_bytes(struct exynos_spi *regs, int count, int step)
74
{
75
76
	debug("%s: regs=%p, count=%d, step=%d\n", __func__, regs, count, step);

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
	/* 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);
	}

92
93
94
	assert(count && count < (1 << 16));
	setbits_le32(&regs->ch_cfg, SPI_CH_RST);
	clrbits_le32(&regs->ch_cfg, SPI_CH_RST);
95

96
97
98
	writel(count | SPI_PACKET_CNT_EN, &regs->pkt_cnt);
}

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

	out_bytes = in_bytes = todo;

114
115
	stopping = priv->skip_preamble && (flags & SPI_XFER_END) &&
					!(priv->mode & SPI_SLAVE);
116

117
118
119
120
121
122
	/*
	 * 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) &&
123
	    !priv->skip_preamble)
124
125
		step = 4;

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

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

138
139
140
141
142
	while (in_bytes) {
		int temp;

		/* Keep the fifos full/empty. */
		spi_get_fifo_levels(regs, &rx_lvl, &tx_lvl);
143
144
145
146
147

		/*
		 * Don't completely fill the txfifo, since we don't want our
		 * rxfifo to overflow, and it may already contain data.
		 */
148
		while (tx_lvl < priv->fifo_size/2 && out_bytes) {
149
150
151
152
153
154
			if (!txp)
				temp = -1;
			else if (step == 4)
				temp = *(uint32_t *)txp;
			else
				temp = *txp;
155
			writel(temp, &regs->tx_data);
156
157
158
159
			out_bytes -= step;
			if (txp)
				txp += step;
			tx_lvl += step;
160
		}
161
162
		if (rx_lvl >= step) {
			while (rx_lvl >= step) {
163
				temp = readl(&regs->rx_data);
164
				if (priv->skip_preamble) {
165
					if (temp == SPI_PREAMBLE_END_BYTE) {
166
						priv->skip_preamble = 0;
167
168
169
						stopping = 0;
					}
				} else {
170
					if (rxp || stopping) {
171
172
173
174
						if (step == 4)
							*(uint32_t *)rxp = temp;
						else
							*rxp = temp;
175
176
177
						rxp += step;
					}
					in_bytes -= step;
178
				}
179
180
181
				toread -= step;
				rx_lvl -= step;
			}
182
183
184
185
186
187
188
189
190
191
192
		} 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;
193
			spi_request_bytes(regs, toread, step);
194
		}
195
		if (priv->skip_preamble && get_timer(start) > 100) {
196
197
198
			debug("SPI timeout: in_bytes=%d, out_bytes=%d, ",
			      in_bytes, out_bytes);
			return -ETIMEDOUT;
199
200
		}
	}
201

202
203
	*dinp = rxp;
	*doutp = txp;
204
205

	return 0;
206
207
208
209
210
211
212
213
}

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

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

229
230
231
	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;
232
233
234
235
236
237
238
239
}

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

246
	setbits_le32(&priv->regs->cs_reg, SPI_SLAVE_SIG_INACT);
247
248

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

252
	debug("Deactivate CS, bus '%s'\n", bus->name);
253
254
}

255
static int exynos_spi_of_to_plat(struct udevice *bus)
256
{
257
	struct exynos_spi_plat *plat = dev_get_plat(bus);
258
	const void *blob = gd->fdt_blob;
259
	int node = dev_of_offset(bus);
260

261
	plat->regs = dev_read_addr_ptr(bus);
262
	plat->periph_id = pinmux_decode_periph_id(blob, node);
263

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

	/* Use 500KHz as a suitable default */
271
	plat->frequency = fdtdec_get_int(blob, node, "spi-max-frequency",
272
					500000);
273
	plat->deactivate_delay_us = fdtdec_get_int(blob, node,
274
					"spi-deactivate-delay", 0);
275
276
277
	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);
278
279
280
281

	return 0;
}

282
static int exynos_spi_probe(struct udevice *bus)
283
{
284
	struct exynos_spi_plat *plat = dev_get_plat(bus);
285
	struct exynos_spi_priv *priv = dev_get_priv(bus);
286

287
288
289
290
291
292
	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;
293

294
295
296
297
	priv->skip_preamble = 0;
	priv->last_transaction_us = timer_get_us();
	priv->freq = plat->frequency;
	priv->periph_id = plat->periph_id;
298

299
300
	return 0;
}
301

302
static int exynos_spi_claim_bus(struct udevice *dev)
303
{
304
	struct udevice *bus = dev->parent;
305
306
307
308
309
310
	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);
311
312
313
314

	return 0;
}

315
static int exynos_spi_release_bus(struct udevice *dev)
316
{
317
	struct udevice *bus = dev->parent;
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
353
354
355
	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;
	}
356

357
358
359
360
361
362
363
364
	/* 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;
		}
365
366
	}

367
	return ret;
368
369
}

370
static int exynos_spi_set_speed(struct udevice *bus, uint speed)
371
{
372
	struct exynos_spi_plat *plat = dev_get_plat(bus);
373
374
	struct exynos_spi_priv *priv = dev_get_priv(bus);
	int ret;
375

376
377
378
379
380
381
382
383
384
385
	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;
}
386

387
388
389
390
static int exynos_spi_set_mode(struct udevice *bus, uint mode)
{
	struct exynos_spi_priv *priv = dev_get_priv(bus);
	uint32_t reg;
391

392
393
	reg = readl(&priv->regs->ch_cfg);
	reg &= ~(SPI_CH_CPHA_B | SPI_CH_CPOL_L);
394

395
396
	if (mode & SPI_CPHA)
		reg |= SPI_CH_CPHA_B;
397

398
399
400
401
402
403
404
405
	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;
406
}
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429

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,
430
	.of_to_plat = exynos_spi_of_to_plat,
431
	.plat_auto	= sizeof(struct exynos_spi_plat),
432
	.priv_auto	= sizeof(struct exynos_spi_priv),
433
434
	.probe	= exynos_spi_probe,
};