spi-imx.c 33.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 * Copyright 2004-2007 Freescale Semiconductor, Inc. All Rights Reserved.
 * Copyright (C) 2008 Juergen Beisert
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the
 * Free Software Foundation
 * 51 Franklin Street, Fifth Floor
 * Boston, MA  02110-1301, USA.
 */

#include <linux/clk.h>
#include <linux/completion.h>
#include <linux/delay.h>
Robin Gong's avatar
Robin Gong committed
24 25
#include <linux/dmaengine.h>
#include <linux/dma-mapping.h>
26 27 28 29 30 31 32 33
#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
34
#include <linux/slab.h>
35 36 37
#include <linux/spi/spi.h>
#include <linux/spi/spi_bitbang.h>
#include <linux/types.h>
38 39 40
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
41

Robin Gong's avatar
Robin Gong committed
42
#include <linux/platform_data/dma-imx.h>
43
#include <linux/platform_data/spi-imx.h>
44 45 46 47 48 49 50 51 52 53 54 55 56

#define DRIVER_NAME "spi_imx"

#define MXC_CSPIRXDATA		0x00
#define MXC_CSPITXDATA		0x04
#define MXC_CSPICTRL		0x08
#define MXC_CSPIINT		0x0c
#define MXC_RESET		0x1c

/* generic defines to abstract from the different register layouts */
#define MXC_INT_RR	(1 << 0) /* Receive data ready interrupt */
#define MXC_INT_TE	(1 << 1) /* Transmit FIFO empty interrupt */

Robin Gong's avatar
Robin Gong committed
57 58
/* The maximum  bytes that a sdma BD can transfer.*/
#define MAX_SDMA_BD_BYTES  (1 << 15)
59
struct spi_imx_config {
60 61 62 63
	unsigned int speed_hz;
	unsigned int bpw;
};

64
enum spi_imx_devtype {
65 66 67 68 69 70
	IMX1_CSPI,
	IMX21_CSPI,
	IMX27_CSPI,
	IMX31_CSPI,
	IMX35_CSPI,	/* CSPI on all i.mx except above */
	IMX51_ECSPI,	/* ECSPI on i.mx51 and later */
71 72 73 74 75 76
};

struct spi_imx_data;

struct spi_imx_devtype_data {
	void (*intctrl)(struct spi_imx_data *, int);
77
	int (*config)(struct spi_device *, struct spi_imx_config *);
78 79
	void (*trigger)(struct spi_imx_data *);
	int (*rx_available)(struct spi_imx_data *);
80
	void (*reset)(struct spi_imx_data *);
81
	enum spi_imx_devtype devtype;
82 83
};

84
struct spi_imx_data {
85
	struct spi_bitbang bitbang;
86
	struct device *dev;
87 88

	struct completion xfer_done;
89
	void __iomem *base;
90 91
	unsigned long base_phys;

92 93
	struct clk *clk_per;
	struct clk *clk_ipg;
94
	unsigned long spi_clk;
95
	unsigned int spi_bus_clk;
96

97 98
	unsigned int bytes_per_word;

99
	unsigned int count;
100 101
	void (*tx)(struct spi_imx_data *);
	void (*rx)(struct spi_imx_data *);
102 103 104 105
	void *rx_buf;
	const void *tx_buf;
	unsigned int txfifo; /* number of words pushed in tx FIFO */

Robin Gong's avatar
Robin Gong committed
106 107
	/* DMA */
	bool usedma;
108
	u32 wml;
Robin Gong's avatar
Robin Gong committed
109 110 111
	struct completion dma_rx_completion;
	struct completion dma_tx_completion;

112
	const struct spi_imx_devtype_data *devtype_data;
113 114
};

115 116 117 118 119 120 121 122 123 124
static inline int is_imx27_cspi(struct spi_imx_data *d)
{
	return d->devtype_data->devtype == IMX27_CSPI;
}

static inline int is_imx35_cspi(struct spi_imx_data *d)
{
	return d->devtype_data->devtype == IMX35_CSPI;
}

125 126 127 128 129
static inline int is_imx51_ecspi(struct spi_imx_data *d)
{
	return d->devtype_data->devtype == IMX51_ECSPI;
}

130 131
static inline unsigned spi_imx_get_fifosize(struct spi_imx_data *d)
{
132
	return is_imx51_ecspi(d) ? 64 : 8;
133 134
}

135
#define MXC_SPI_BUF_RX(type)						\
136
static void spi_imx_buf_rx_##type(struct spi_imx_data *spi_imx)		\
137
{									\
138
	unsigned int val = readl(spi_imx->base + MXC_CSPIRXDATA);	\
139
									\
140 141 142
	if (spi_imx->rx_buf) {						\
		*(type *)spi_imx->rx_buf = val;				\
		spi_imx->rx_buf += sizeof(type);			\
143 144 145 146
	}								\
}

#define MXC_SPI_BUF_TX(type)						\
147
static void spi_imx_buf_tx_##type(struct spi_imx_data *spi_imx)		\
148 149 150
{									\
	type val = 0;							\
									\
151 152 153
	if (spi_imx->tx_buf) {						\
		val = *(type *)spi_imx->tx_buf;				\
		spi_imx->tx_buf += sizeof(type);			\
154 155
	}								\
									\
156
	spi_imx->count -= sizeof(type);					\
157
									\
158
	writel(val, spi_imx->base + MXC_CSPITXDATA);			\
159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
}

MXC_SPI_BUF_RX(u8)
MXC_SPI_BUF_TX(u8)
MXC_SPI_BUF_RX(u16)
MXC_SPI_BUF_TX(u16)
MXC_SPI_BUF_RX(u32)
MXC_SPI_BUF_TX(u32)

/* First entry is reserved, second entry is valid only if SDHC_SPIEN is set
 * (which is currently not the case in this driver)
 */
static int mxc_clkdivs[] = {0, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192,
	256, 384, 512, 768, 1024};

/* MX21, MX27 */
175
static unsigned int spi_imx_clkdiv_1(unsigned int fin,
176
		unsigned int fspi, unsigned int max)
177
{
178
	int i;
179 180 181 182 183 184 185 186

	for (i = 2; i < max; i++)
		if (fspi * mxc_clkdivs[i] >= fin)
			return i;

	return max;
}

187
/* MX1, MX31, MX35, MX51 CSPI */
188
static unsigned int spi_imx_clkdiv_2(unsigned int fin,
189 190 191 192 193 194 195 196 197 198 199 200 201
		unsigned int fspi)
{
	int i, div = 4;

	for (i = 0; i < 7; i++) {
		if (fspi * div >= fin)
			return i;
		div <<= 1;
	}

	return 7;
}

202 203 204 205 206
static int spi_imx_bytes_per_word(const int bpw)
{
	return DIV_ROUND_UP(bpw, BITS_PER_BYTE);
}

Robin Gong's avatar
Robin Gong committed
207 208 209 210
static bool spi_imx_can_dma(struct spi_master *master, struct spi_device *spi,
			 struct spi_transfer *transfer)
{
	struct spi_imx_data *spi_imx = spi_master_get_devdata(master);
211
	unsigned int bpw;
212 213 214 215

	if (!master->dma_rx)
		return false;

216 217 218 219
	if (!transfer)
		return false;

	bpw = transfer->bits_per_word;
220 221 222 223 224 225 226 227 228 229 230 231 232
	if (!bpw)
		bpw = spi->bits_per_word;

	bpw = spi_imx_bytes_per_word(bpw);

	if (bpw != 1 && bpw != 2 && bpw != 4)
		return false;

	if (transfer->len < spi_imx->wml * bpw)
		return false;

	if (transfer->len % (spi_imx->wml * bpw))
		return false;
Robin Gong's avatar
Robin Gong committed
233

234
	return true;
Robin Gong's avatar
Robin Gong committed
235 236
}

237 238 239
#define MX51_ECSPI_CTRL		0x08
#define MX51_ECSPI_CTRL_ENABLE		(1 <<  0)
#define MX51_ECSPI_CTRL_XCH		(1 <<  2)
Robin Gong's avatar
Robin Gong committed
240
#define MX51_ECSPI_CTRL_SMC		(1 << 3)
241 242 243 244 245 246 247 248 249 250 251
#define MX51_ECSPI_CTRL_MODE_MASK	(0xf << 4)
#define MX51_ECSPI_CTRL_POSTDIV_OFFSET	8
#define MX51_ECSPI_CTRL_PREDIV_OFFSET	12
#define MX51_ECSPI_CTRL_CS(cs)		((cs) << 18)
#define MX51_ECSPI_CTRL_BL_OFFSET	20

#define MX51_ECSPI_CONFIG	0x0c
#define MX51_ECSPI_CONFIG_SCLKPHA(cs)	(1 << ((cs) +  0))
#define MX51_ECSPI_CONFIG_SCLKPOL(cs)	(1 << ((cs) +  4))
#define MX51_ECSPI_CONFIG_SBBCTRL(cs)	(1 << ((cs) +  8))
#define MX51_ECSPI_CONFIG_SSBPOL(cs)	(1 << ((cs) + 12))
252
#define MX51_ECSPI_CONFIG_SCLKCTL(cs)	(1 << ((cs) + 20))
253 254 255 256 257

#define MX51_ECSPI_INT		0x10
#define MX51_ECSPI_INT_TEEN		(1 <<  0)
#define MX51_ECSPI_INT_RREN		(1 <<  3)

Robin Gong's avatar
Robin Gong committed
258
#define MX51_ECSPI_DMA      0x14
259 260 261
#define MX51_ECSPI_DMA_TX_WML(wml)	((wml) & 0x3f)
#define MX51_ECSPI_DMA_RX_WML(wml)	(((wml) & 0x3f) << 16)
#define MX51_ECSPI_DMA_RXT_WML(wml)	(((wml) & 0x3f) << 24)
Robin Gong's avatar
Robin Gong committed
262

263 264 265
#define MX51_ECSPI_DMA_TEDEN		(1 << 7)
#define MX51_ECSPI_DMA_RXDEN		(1 << 23)
#define MX51_ECSPI_DMA_RXTDEN		(1 << 31)
Robin Gong's avatar
Robin Gong committed
266

267 268
#define MX51_ECSPI_STAT		0x18
#define MX51_ECSPI_STAT_RR		(1 <<  3)
269

270 271 272
#define MX51_ECSPI_TESTREG	0x20
#define MX51_ECSPI_TESTREG_LBC	BIT(31)

273
/* MX51 eCSPI */
274 275
static unsigned int mx51_ecspi_clkdiv(struct spi_imx_data *spi_imx,
				      unsigned int fspi, unsigned int *fres)
276 277 278 279 280 281
{
	/*
	 * there are two 4-bit dividers, the pre-divider divides by
	 * $pre, the post-divider by 2^$post
	 */
	unsigned int pre, post;
282
	unsigned int fin = spi_imx->spi_clk;
283 284 285 286 287 288 289 290 291 292 293 294

	if (unlikely(fspi > fin))
		return 0;

	post = fls(fin) - fls(fspi);
	if (fin > fspi << post)
		post++;

	/* now we have: (fin <= fspi << post) with post being minimal */

	post = max(4U, post) - 4;
	if (unlikely(post > 0xf)) {
295 296
		dev_err(spi_imx->dev, "cannot set clock freq: %u (base freq: %u)\n",
				fspi, fin);
297 298 299 300 301
		return 0xff;
	}

	pre = DIV_ROUND_UP(fin, fspi << post) - 1;

302
	dev_dbg(spi_imx->dev, "%s: fin: %u, fspi: %u, post: %u, pre: %u\n",
303
			__func__, fin, fspi, post, pre);
304 305 306 307

	/* Resulting frequency for the SCLK line. */
	*fres = (fin / (pre + 1)) >> post;

308 309
	return (pre << MX51_ECSPI_CTRL_PREDIV_OFFSET) |
		(post << MX51_ECSPI_CTRL_POSTDIV_OFFSET);
310 311
}

312
static void mx51_ecspi_intctrl(struct spi_imx_data *spi_imx, int enable)
313 314 315 316
{
	unsigned val = 0;

	if (enable & MXC_INT_TE)
317
		val |= MX51_ECSPI_INT_TEEN;
318 319

	if (enable & MXC_INT_RR)
320
		val |= MX51_ECSPI_INT_RREN;
321

322
	writel(val, spi_imx->base + MX51_ECSPI_INT);
323 324
}

325
static void mx51_ecspi_trigger(struct spi_imx_data *spi_imx)
326
{
327
	u32 reg;
Robin Gong's avatar
Robin Gong committed
328

329 330
	reg = readl(spi_imx->base + MX51_ECSPI_CTRL);
	reg |= MX51_ECSPI_CTRL_XCH;
331
	writel(reg, spi_imx->base + MX51_ECSPI_CTRL);
332 333
}

334 335
static int mx51_ecspi_config(struct spi_device *spi,
			     struct spi_imx_config *config)
336
{
337
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
338
	u32 ctrl = MX51_ECSPI_CTRL_ENABLE;
339
	u32 clk = config->speed_hz, delay, reg;
340
	u32 cfg = readl(spi_imx->base + MX51_ECSPI_CONFIG);
341

342 343 344 345 346 347 348
	/*
	 * The hardware seems to have a race condition when changing modes. The
	 * current assumption is that the selection of the channel arrives
	 * earlier in the hardware than the mode bits when they are written at
	 * the same time.
	 * So set master mode for all channels as we do not support slave mode.
	 */
349
	ctrl |= MX51_ECSPI_CTRL_MODE_MASK;
350 351

	/* set clock speed */
352
	ctrl |= mx51_ecspi_clkdiv(spi_imx, config->speed_hz, &clk);
353
	spi_imx->spi_bus_clk = clk;
354 355

	/* set chip select to use */
356
	ctrl |= MX51_ECSPI_CTRL_CS(spi->chip_select);
357

358
	ctrl |= (config->bpw - 1) << MX51_ECSPI_CTRL_BL_OFFSET;
359

360
	cfg |= MX51_ECSPI_CONFIG_SBBCTRL(spi->chip_select);
361

362
	if (spi->mode & SPI_CPHA)
363
		cfg |= MX51_ECSPI_CONFIG_SCLKPHA(spi->chip_select);
364
	else
365
		cfg &= ~MX51_ECSPI_CONFIG_SCLKPHA(spi->chip_select);
366

367
	if (spi->mode & SPI_CPOL) {
368 369
		cfg |= MX51_ECSPI_CONFIG_SCLKPOL(spi->chip_select);
		cfg |= MX51_ECSPI_CONFIG_SCLKCTL(spi->chip_select);
370
	} else {
371 372
		cfg &= ~MX51_ECSPI_CONFIG_SCLKPOL(spi->chip_select);
		cfg &= ~MX51_ECSPI_CONFIG_SCLKCTL(spi->chip_select);
373
	}
374
	if (spi->mode & SPI_CS_HIGH)
375
		cfg |= MX51_ECSPI_CONFIG_SSBPOL(spi->chip_select);
376
	else
377
		cfg &= ~MX51_ECSPI_CONFIG_SSBPOL(spi->chip_select);
378

379 380 381
	if (spi_imx->usedma)
		ctrl |= MX51_ECSPI_CTRL_SMC;

382 383 384
	/* CTRL register always go first to bring out controller from reset */
	writel(ctrl, spi_imx->base + MX51_ECSPI_CTRL);

385
	reg = readl(spi_imx->base + MX51_ECSPI_TESTREG);
386
	if (spi->mode & SPI_LOOP)
387 388 389 390 391
		reg |= MX51_ECSPI_TESTREG_LBC;
	else
		reg &= ~MX51_ECSPI_TESTREG_LBC;
	writel(reg, spi_imx->base + MX51_ECSPI_TESTREG);

392
	writel(cfg, spi_imx->base + MX51_ECSPI_CONFIG);
393

394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410
	/*
	 * Wait until the changes in the configuration register CONFIGREG
	 * propagate into the hardware. It takes exactly one tick of the
	 * SCLK clock, but we will wait two SCLK clock just to be sure. The
	 * effect of the delay it takes for the hardware to apply changes
	 * is noticable if the SCLK clock run very slow. In such a case, if
	 * the polarity of SCLK should be inverted, the GPIO ChipSelect might
	 * be asserted before the SCLK polarity changes, which would disrupt
	 * the SPI communication as the device on the other end would consider
	 * the change of SCLK polarity as a clock tick already.
	 */
	delay = (2 * 1000000) / clk;
	if (likely(delay < 10))	/* SCLK is faster than 100 kHz */
		udelay(delay);
	else			/* SCLK is _very_ slow */
		usleep_range(delay, delay + 10);

Robin Gong's avatar
Robin Gong committed
411 412 413 414
	/*
	 * Configure the DMA register: setup the watermark
	 * and enable DMA request.
	 */
415

416 417 418
	writel(MX51_ECSPI_DMA_RX_WML(spi_imx->wml) |
		MX51_ECSPI_DMA_TX_WML(spi_imx->wml) |
		MX51_ECSPI_DMA_RXT_WML(spi_imx->wml) |
419 420
		MX51_ECSPI_DMA_TEDEN | MX51_ECSPI_DMA_RXDEN |
		MX51_ECSPI_DMA_RXTDEN, spi_imx->base + MX51_ECSPI_DMA);
Robin Gong's avatar
Robin Gong committed
421

422 423 424
	return 0;
}

425
static int mx51_ecspi_rx_available(struct spi_imx_data *spi_imx)
426
{
427
	return readl(spi_imx->base + MX51_ECSPI_STAT) & MX51_ECSPI_STAT_RR;
428 429
}

430
static void mx51_ecspi_reset(struct spi_imx_data *spi_imx)
431 432
{
	/* drain receive buffer */
433
	while (mx51_ecspi_rx_available(spi_imx))
434 435 436
		readl(spi_imx->base + MXC_CSPIRXDATA);
}

437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
#define MX31_INTREG_TEEN	(1 << 0)
#define MX31_INTREG_RREN	(1 << 3)

#define MX31_CSPICTRL_ENABLE	(1 << 0)
#define MX31_CSPICTRL_MASTER	(1 << 1)
#define MX31_CSPICTRL_XCH	(1 << 2)
#define MX31_CSPICTRL_POL	(1 << 4)
#define MX31_CSPICTRL_PHA	(1 << 5)
#define MX31_CSPICTRL_SSCTL	(1 << 6)
#define MX31_CSPICTRL_SSPOL	(1 << 7)
#define MX31_CSPICTRL_BC_SHIFT	8
#define MX35_CSPICTRL_BL_SHIFT	20
#define MX31_CSPICTRL_CS_SHIFT	24
#define MX35_CSPICTRL_CS_SHIFT	12
#define MX31_CSPICTRL_DR_SHIFT	16

#define MX31_CSPISTATUS		0x14
#define MX31_STATUS_RR		(1 << 3)

/* These functions also work for the i.MX35, but be aware that
 * the i.MX35 has a slightly different register layout for bits
 * we do not use here.
 */
460
static void mx31_intctrl(struct spi_imx_data *spi_imx, int enable)
461 462 463 464 465 466 467 468
{
	unsigned int val = 0;

	if (enable & MXC_INT_TE)
		val |= MX31_INTREG_TEEN;
	if (enable & MXC_INT_RR)
		val |= MX31_INTREG_RREN;

469
	writel(val, spi_imx->base + MXC_CSPIINT);
470 471
}

472
static void mx31_trigger(struct spi_imx_data *spi_imx)
473 474 475
{
	unsigned int reg;

476
	reg = readl(spi_imx->base + MXC_CSPICTRL);
477
	reg |= MX31_CSPICTRL_XCH;
478
	writel(reg, spi_imx->base + MXC_CSPICTRL);
479 480
}

481
static int mx31_config(struct spi_device *spi, struct spi_imx_config *config)
482
{
483
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
484 485 486 487 488
	unsigned int reg = MX31_CSPICTRL_ENABLE | MX31_CSPICTRL_MASTER;

	reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) <<
		MX31_CSPICTRL_DR_SHIFT;

489
	if (is_imx35_cspi(spi_imx)) {
490 491 492 493 494
		reg |= (config->bpw - 1) << MX35_CSPICTRL_BL_SHIFT;
		reg |= MX31_CSPICTRL_SSCTL;
	} else {
		reg |= (config->bpw - 1) << MX31_CSPICTRL_BC_SHIFT;
	}
495

496
	if (spi->mode & SPI_CPHA)
497
		reg |= MX31_CSPICTRL_PHA;
498
	if (spi->mode & SPI_CPOL)
499
		reg |= MX31_CSPICTRL_POL;
500
	if (spi->mode & SPI_CS_HIGH)
501
		reg |= MX31_CSPICTRL_SSPOL;
502 503
	if (spi->cs_gpio < 0)
		reg |= (spi->cs_gpio + 32) <<
504 505
			(is_imx35_cspi(spi_imx) ? MX35_CSPICTRL_CS_SHIFT :
						  MX31_CSPICTRL_CS_SHIFT);
506 507 508 509 510 511

	writel(reg, spi_imx->base + MXC_CSPICTRL);

	return 0;
}

512
static int mx31_rx_available(struct spi_imx_data *spi_imx)
513
{
514
	return readl(spi_imx->base + MX31_CSPISTATUS) & MX31_STATUS_RR;
515 516
}

517
static void mx31_reset(struct spi_imx_data *spi_imx)
518 519
{
	/* drain receive buffer */
520
	while (readl(spi_imx->base + MX31_CSPISTATUS) & MX31_STATUS_RR)
521 522 523
		readl(spi_imx->base + MXC_CSPIRXDATA);
}

524 525 526 527 528 529 530 531 532 533 534 535 536
#define MX21_INTREG_RR		(1 << 4)
#define MX21_INTREG_TEEN	(1 << 9)
#define MX21_INTREG_RREN	(1 << 13)

#define MX21_CSPICTRL_POL	(1 << 5)
#define MX21_CSPICTRL_PHA	(1 << 6)
#define MX21_CSPICTRL_SSPOL	(1 << 8)
#define MX21_CSPICTRL_XCH	(1 << 9)
#define MX21_CSPICTRL_ENABLE	(1 << 10)
#define MX21_CSPICTRL_MASTER	(1 << 11)
#define MX21_CSPICTRL_DR_SHIFT	14
#define MX21_CSPICTRL_CS_SHIFT	19

537
static void mx21_intctrl(struct spi_imx_data *spi_imx, int enable)
538 539 540 541
{
	unsigned int val = 0;

	if (enable & MXC_INT_TE)
542
		val |= MX21_INTREG_TEEN;
543
	if (enable & MXC_INT_RR)
544
		val |= MX21_INTREG_RREN;
545

546
	writel(val, spi_imx->base + MXC_CSPIINT);
547 548
}

549
static void mx21_trigger(struct spi_imx_data *spi_imx)
550 551 552
{
	unsigned int reg;

553
	reg = readl(spi_imx->base + MXC_CSPICTRL);
554
	reg |= MX21_CSPICTRL_XCH;
555
	writel(reg, spi_imx->base + MXC_CSPICTRL);
556 557
}

558
static int mx21_config(struct spi_device *spi, struct spi_imx_config *config)
559
{
560
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
561
	unsigned int reg = MX21_CSPICTRL_ENABLE | MX21_CSPICTRL_MASTER;
562
	unsigned int max = is_imx27_cspi(spi_imx) ? 16 : 18;
563

564
	reg |= spi_imx_clkdiv_1(spi_imx->spi_clk, config->speed_hz, max) <<
565
		MX21_CSPICTRL_DR_SHIFT;
566 567
	reg |= config->bpw - 1;

568
	if (spi->mode & SPI_CPHA)
569
		reg |= MX21_CSPICTRL_PHA;
570
	if (spi->mode & SPI_CPOL)
571
		reg |= MX21_CSPICTRL_POL;
572
	if (spi->mode & SPI_CS_HIGH)
573
		reg |= MX21_CSPICTRL_SSPOL;
574 575
	if (spi->cs_gpio < 0)
		reg |= (spi->cs_gpio + 32) << MX21_CSPICTRL_CS_SHIFT;
576

577
	writel(reg, spi_imx->base + MXC_CSPICTRL);
578 579 580 581

	return 0;
}

582
static int mx21_rx_available(struct spi_imx_data *spi_imx)
583
{
584
	return readl(spi_imx->base + MXC_CSPIINT) & MX21_INTREG_RR;
585 586
}

587
static void mx21_reset(struct spi_imx_data *spi_imx)
588 589 590 591
{
	writel(1, spi_imx->base + MXC_RESET);
}

592 593 594 595 596 597 598 599 600 601 602
#define MX1_INTREG_RR		(1 << 3)
#define MX1_INTREG_TEEN		(1 << 8)
#define MX1_INTREG_RREN		(1 << 11)

#define MX1_CSPICTRL_POL	(1 << 4)
#define MX1_CSPICTRL_PHA	(1 << 5)
#define MX1_CSPICTRL_XCH	(1 << 8)
#define MX1_CSPICTRL_ENABLE	(1 << 9)
#define MX1_CSPICTRL_MASTER	(1 << 10)
#define MX1_CSPICTRL_DR_SHIFT	13

603
static void mx1_intctrl(struct spi_imx_data *spi_imx, int enable)
604 605 606 607 608 609 610 611
{
	unsigned int val = 0;

	if (enable & MXC_INT_TE)
		val |= MX1_INTREG_TEEN;
	if (enable & MXC_INT_RR)
		val |= MX1_INTREG_RREN;

612
	writel(val, spi_imx->base + MXC_CSPIINT);
613 614
}

615
static void mx1_trigger(struct spi_imx_data *spi_imx)
616 617 618
{
	unsigned int reg;

619
	reg = readl(spi_imx->base + MXC_CSPICTRL);
620
	reg |= MX1_CSPICTRL_XCH;
621
	writel(reg, spi_imx->base + MXC_CSPICTRL);
622 623
}

624
static int mx1_config(struct spi_device *spi, struct spi_imx_config *config)
625
{
626
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
627 628
	unsigned int reg = MX1_CSPICTRL_ENABLE | MX1_CSPICTRL_MASTER;

629
	reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) <<
630 631 632
		MX1_CSPICTRL_DR_SHIFT;
	reg |= config->bpw - 1;

633
	if (spi->mode & SPI_CPHA)
634
		reg |= MX1_CSPICTRL_PHA;
635
	if (spi->mode & SPI_CPOL)
636 637
		reg |= MX1_CSPICTRL_POL;

638
	writel(reg, spi_imx->base + MXC_CSPICTRL);
639 640 641 642

	return 0;
}

643
static int mx1_rx_available(struct spi_imx_data *spi_imx)
644
{
645
	return readl(spi_imx->base + MXC_CSPIINT) & MX1_INTREG_RR;
646 647
}

648
static void mx1_reset(struct spi_imx_data *spi_imx)
649 650 651 652
{
	writel(1, spi_imx->base + MXC_RESET);
}

653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708
static struct spi_imx_devtype_data imx1_cspi_devtype_data = {
	.intctrl = mx1_intctrl,
	.config = mx1_config,
	.trigger = mx1_trigger,
	.rx_available = mx1_rx_available,
	.reset = mx1_reset,
	.devtype = IMX1_CSPI,
};

static struct spi_imx_devtype_data imx21_cspi_devtype_data = {
	.intctrl = mx21_intctrl,
	.config = mx21_config,
	.trigger = mx21_trigger,
	.rx_available = mx21_rx_available,
	.reset = mx21_reset,
	.devtype = IMX21_CSPI,
};

static struct spi_imx_devtype_data imx27_cspi_devtype_data = {
	/* i.mx27 cspi shares the functions with i.mx21 one */
	.intctrl = mx21_intctrl,
	.config = mx21_config,
	.trigger = mx21_trigger,
	.rx_available = mx21_rx_available,
	.reset = mx21_reset,
	.devtype = IMX27_CSPI,
};

static struct spi_imx_devtype_data imx31_cspi_devtype_data = {
	.intctrl = mx31_intctrl,
	.config = mx31_config,
	.trigger = mx31_trigger,
	.rx_available = mx31_rx_available,
	.reset = mx31_reset,
	.devtype = IMX31_CSPI,
};

static struct spi_imx_devtype_data imx35_cspi_devtype_data = {
	/* i.mx35 and later cspi shares the functions with i.mx31 one */
	.intctrl = mx31_intctrl,
	.config = mx31_config,
	.trigger = mx31_trigger,
	.rx_available = mx31_rx_available,
	.reset = mx31_reset,
	.devtype = IMX35_CSPI,
};

static struct spi_imx_devtype_data imx51_ecspi_devtype_data = {
	.intctrl = mx51_ecspi_intctrl,
	.config = mx51_ecspi_config,
	.trigger = mx51_ecspi_trigger,
	.rx_available = mx51_ecspi_rx_available,
	.reset = mx51_ecspi_reset,
	.devtype = IMX51_ECSPI,
};

709
static const struct platform_device_id spi_imx_devtype[] = {
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730
	{
		.name = "imx1-cspi",
		.driver_data = (kernel_ulong_t) &imx1_cspi_devtype_data,
	}, {
		.name = "imx21-cspi",
		.driver_data = (kernel_ulong_t) &imx21_cspi_devtype_data,
	}, {
		.name = "imx27-cspi",
		.driver_data = (kernel_ulong_t) &imx27_cspi_devtype_data,
	}, {
		.name = "imx31-cspi",
		.driver_data = (kernel_ulong_t) &imx31_cspi_devtype_data,
	}, {
		.name = "imx35-cspi",
		.driver_data = (kernel_ulong_t) &imx35_cspi_devtype_data,
	}, {
		.name = "imx51-ecspi",
		.driver_data = (kernel_ulong_t) &imx51_ecspi_devtype_data,
	}, {
		/* sentinel */
	}
731 732
};

733 734 735 736 737 738 739 740 741
static const struct of_device_id spi_imx_dt_ids[] = {
	{ .compatible = "fsl,imx1-cspi", .data = &imx1_cspi_devtype_data, },
	{ .compatible = "fsl,imx21-cspi", .data = &imx21_cspi_devtype_data, },
	{ .compatible = "fsl,imx27-cspi", .data = &imx27_cspi_devtype_data, },
	{ .compatible = "fsl,imx31-cspi", .data = &imx31_cspi_devtype_data, },
	{ .compatible = "fsl,imx35-cspi", .data = &imx35_cspi_devtype_data, },
	{ .compatible = "fsl,imx51-ecspi", .data = &imx51_ecspi_devtype_data, },
	{ /* sentinel */ }
};
742
MODULE_DEVICE_TABLE(of, spi_imx_dt_ids);
743

744
static void spi_imx_chipselect(struct spi_device *spi, int is_active)
745
{
746 747
	int active = is_active != BITBANG_CS_INACTIVE;
	int dev_is_lowactive = !(spi->mode & SPI_CS_HIGH);
748

749
	if (!gpio_is_valid(spi->cs_gpio))
750 751
		return;

752
	gpio_set_value(spi->cs_gpio, dev_is_lowactive ^ active);
753 754
}

755
static void spi_imx_push(struct spi_imx_data *spi_imx)
756
{
757
	while (spi_imx->txfifo < spi_imx_get_fifosize(spi_imx)) {
758
		if (!spi_imx->count)
759
			break;
760 761
		spi_imx->tx(spi_imx);
		spi_imx->txfifo++;
762 763
	}

764
	spi_imx->devtype_data->trigger(spi_imx);
765 766
}

767
static irqreturn_t spi_imx_isr(int irq, void *dev_id)
768
{
769
	struct spi_imx_data *spi_imx = dev_id;
770

771
	while (spi_imx->devtype_data->rx_available(spi_imx)) {
772 773
		spi_imx->rx(spi_imx);
		spi_imx->txfifo--;
774 775
	}

776 777
	if (spi_imx->count) {
		spi_imx_push(spi_imx);
778 779 780
		return IRQ_HANDLED;
	}

781
	if (spi_imx->txfifo) {
782 783 784
		/* No data left to push, but still waiting for rx data,
		 * enable receive data available interrupt.
		 */
785
		spi_imx->devtype_data->intctrl(
786
				spi_imx, MXC_INT_RR);
787 788 789
		return IRQ_HANDLED;
	}

790
	spi_imx->devtype_data->intctrl(spi_imx, 0);
791
	complete(&spi_imx->xfer_done);
792 793 794 795

	return IRQ_HANDLED;
}

796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
static int spi_imx_dma_configure(struct spi_master *master,
				 int bytes_per_word)
{
	int ret;
	enum dma_slave_buswidth buswidth;
	struct dma_slave_config rx = {}, tx = {};
	struct spi_imx_data *spi_imx = spi_master_get_devdata(master);

	if (bytes_per_word == spi_imx->bytes_per_word)
		/* Same as last time */
		return 0;

	switch (bytes_per_word) {
	case 4:
		buswidth = DMA_SLAVE_BUSWIDTH_4_BYTES;
		break;
	case 2:
		buswidth = DMA_SLAVE_BUSWIDTH_2_BYTES;
		break;
	case 1:
		buswidth = DMA_SLAVE_BUSWIDTH_1_BYTE;
		break;
	default:
		return -EINVAL;
	}

	tx.direction = DMA_MEM_TO_DEV;
	tx.dst_addr = spi_imx->base_phys + MXC_CSPITXDATA;
	tx.dst_addr_width = buswidth;
	tx.dst_maxburst = spi_imx->wml;
	ret = dmaengine_slave_config(master->dma_tx, &tx);
	if (ret) {
		dev_err(spi_imx->dev, "TX dma configuration failed with %d\n", ret);
		return ret;
	}

	rx.direction = DMA_DEV_TO_MEM;
	rx.src_addr = spi_imx->base_phys + MXC_CSPIRXDATA;
	rx.src_addr_width = buswidth;
	rx.src_maxburst = spi_imx->wml;
	ret = dmaengine_slave_config(master->dma_rx, &rx);
	if (ret) {
		dev_err(spi_imx->dev, "RX dma configuration failed with %d\n", ret);
		return ret;
	}

	spi_imx->bytes_per_word = bytes_per_word;

	return 0;
}

847
static int spi_imx_setupxfer(struct spi_device *spi,
848 849
				 struct spi_transfer *t)
{
850 851
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
	struct spi_imx_config config;
852
	int ret;
853 854 855 856

	config.bpw = t ? t->bits_per_word : spi->bits_per_word;
	config.speed_hz  = t ? t->speed_hz : spi->max_speed_hz;

857 858 859 860 861
	if (!config.speed_hz)
		config.speed_hz = spi->max_speed_hz;
	if (!config.bpw)
		config.bpw = spi->bits_per_word;

862 863 864 865 866 867 868
	/* Initialize the functions for transfer */
	if (config.bpw <= 8) {
		spi_imx->rx = spi_imx_buf_rx_u8;
		spi_imx->tx = spi_imx_buf_tx_u8;
	} else if (config.bpw <= 16) {
		spi_imx->rx = spi_imx_buf_rx_u16;
		spi_imx->tx = spi_imx_buf_tx_u16;
869
	} else {
870 871
		spi_imx->rx = spi_imx_buf_rx_u32;
		spi_imx->tx = spi_imx_buf_tx_u32;
872
	}
873

874 875 876 877 878
	if (spi_imx_can_dma(spi_imx->bitbang.master, spi, t))
		spi_imx->usedma = 1;
	else
		spi_imx->usedma = 0;

879 880 881 882 883 884 885
	if (spi_imx->usedma) {
		ret = spi_imx_dma_configure(spi->master,
					    spi_imx_bytes_per_word(config.bpw));
		if (ret)
			return ret;
	}

886
	spi_imx->devtype_data->config(spi, &config);
887 888 889 890

	return 0;
}

Robin Gong's avatar
Robin Gong committed
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906
static void spi_imx_sdma_exit(struct spi_imx_data *spi_imx)
{
	struct spi_master *master = spi_imx->bitbang.master;

	if (master->dma_rx) {
		dma_release_channel(master->dma_rx);
		master->dma_rx = NULL;
	}

	if (master->dma_tx) {
		dma_release_channel(master->dma_tx);
		master->dma_tx = NULL;
	}
}

static int spi_imx_sdma_init(struct device *dev, struct spi_imx_data *spi_imx,
907
			     struct spi_master *master)
Robin Gong's avatar
Robin Gong committed
908 909 910
{
	int ret;

911 912 913 914
	/* use pio mode for i.mx6dl chip TKT238285 */
	if (of_machine_is_compatible("fsl,imx6dl"))
		return 0;

915 916
	spi_imx->wml = spi_imx_get_fifosize(spi_imx) / 2;

Robin Gong's avatar
Robin Gong committed
917
	/* Prepare for TX DMA: */
918 919 920 921 922
	master->dma_tx = dma_request_slave_channel_reason(dev, "tx");
	if (IS_ERR(master->dma_tx)) {
		ret = PTR_ERR(master->dma_tx);
		dev_dbg(dev, "can't get the TX DMA channel, error %d!\n", ret);
		master->dma_tx = NULL;
Robin Gong's avatar
Robin Gong committed
923 924 925 926
		goto err;
	}

	/* Prepare for RX : */
927 928 929 930 931
	master->dma_rx = dma_request_slave_channel_reason(dev, "rx");
	if (IS_ERR(master->dma_rx)) {
		ret = PTR_ERR(master->dma_rx);
		dev_dbg(dev, "can't get the RX DMA channel, error %d\n", ret);
		master->dma_rx = NULL;
Robin Gong's avatar
Robin Gong committed
932 933 934
		goto err;
	}

935
	spi_imx_dma_configure(master, 1);
Robin Gong's avatar
Robin Gong committed
936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963

	init_completion(&spi_imx->dma_rx_completion);
	init_completion(&spi_imx->dma_tx_completion);
	master->can_dma = spi_imx_can_dma;
	master->max_dma_len = MAX_SDMA_BD_BYTES;
	spi_imx->bitbang.master->flags = SPI_MASTER_MUST_RX |
					 SPI_MASTER_MUST_TX;

	return 0;
err:
	spi_imx_sdma_exit(spi_imx);
	return ret;
}

static void spi_imx_dma_rx_callback(void *cookie)
{
	struct spi_imx_data *spi_imx = (struct spi_imx_data *)cookie;

	complete(&spi_imx->dma_rx_completion);
}

static void spi_imx_dma_tx_callback(void *cookie)
{
	struct spi_imx_data *spi_imx = (struct spi_imx_data *)cookie;

	complete(&spi_imx->dma_tx_completion);
}

964 965 966 967 968 969 970 971 972 973 974 975 976 977
static int spi_imx_calculate_timeout(struct spi_imx_data *spi_imx, int size)
{
	unsigned long timeout = 0;

	/* Time with actual data transfer and CS change delay related to HW */
	timeout = (8 + 4) * size / spi_imx->spi_bus_clk;

	/* Add extra second for scheduler related activities */
	timeout += 1;

	/* Double calculated timeout */
	return msecs_to_jiffies(2 * timeout * MSEC_PER_SEC);
}

Robin Gong's avatar
Robin Gong committed
978 979 980
static int spi_imx_dma_transfer(struct spi_imx_data *spi_imx,
				struct spi_transfer *transfer)
{
981
	struct dma_async_tx_descriptor *desc_tx, *desc_rx;
982
	unsigned long transfer_timeout;
983
	unsigned long timeout;
Robin Gong's avatar
Robin Gong committed
984 985 986
	struct spi_master *master = spi_imx->bitbang.master;
	struct sg_table *tx = &transfer->tx_sg, *rx = &transfer->rx_sg;

987 988 989 990 991 992 993 994 995
	/*
	 * The TX DMA setup starts the transfer, so make sure RX is configured
	 * before TX.
	 */
	desc_rx = dmaengine_prep_slave_sg(master->dma_rx,
				rx->sgl, rx->nents, DMA_DEV_TO_MEM,
				DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
	if (!desc_rx)
		return -EINVAL;
Robin Gong's avatar
Robin Gong committed
996

997 998 999 1000 1001
	desc_rx->callback = spi_imx_dma_rx_callback;
	desc_rx->callback_param = (void *)spi_imx;
	dmaengine_submit(desc_rx);
	reinit_completion(&spi_imx->dma_rx_completion);
	dma_async_issue_pending(master->dma_rx);
Robin Gong's avatar
Robin Gong committed
1002

1003 1004 1005 1006 1007 1008
	desc_tx = dmaengine_prep_slave_sg(master->dma_tx,
				tx->sgl, tx->nents, DMA_MEM_TO_DEV,
				DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
	if (!desc_tx) {
		dmaengine_terminate_all(master->dma_tx);
		return -EINVAL;
Robin Gong's avatar
Robin Gong committed
1009 1010
	}

1011 1012 1013
	desc_tx->callback = spi_imx_dma_tx_callback;
	desc_tx->callback_param = (void *)spi_imx;
	dmaengine_submit(desc_tx);
Robin Gong's avatar
Robin Gong committed
1014
	reinit_completion(&spi_imx->dma_tx_completion);
1015
	dma_async_issue_pending(master->dma_tx);
Robin Gong's avatar
Robin Gong committed
1016

1017 1018
	transfer_timeout = spi_imx_calculate_timeout(spi_imx, transfer->len);

Robin Gong's avatar
Robin Gong committed
1019
	/* Wait SDMA to finish the data transfer.*/
1020
	timeout = wait_for_completion_timeout(&spi_imx->dma_tx_completion,
1021
						transfer_timeout);
1022
	if (!timeout) {
1023
		dev_err(spi_imx->dev, "I/O Error in DMA TX\n");
Robin Gong's avatar
Robin Gong committed
1024
		dmaengine_terminate_all(master->dma_tx);
1025
		dmaengine_terminate_all(master->dma_rx);
1026
		return -ETIMEDOUT;
Robin Gong's avatar
Robin Gong committed
1027 1028
	}

1029 1030 1031 1032 1033 1034 1035 1036
	timeout = wait_for_completion_timeout(&spi_imx->dma_rx_completion,
					      transfer_timeout);
	if (!timeout) {
		dev_err(&master->dev, "I/O Error in DMA RX\n");
		spi_imx->devtype_data->reset(spi_imx);
		dmaengine_terminate_all(master->dma_rx);
		return -ETIMEDOUT;
	}
Robin Gong's avatar
Robin Gong committed
1037

1038
	return transfer->len;
Robin Gong's avatar
Robin Gong committed
1039 1040 1041
}

static int spi_imx_pio_transfer(struct spi_device *spi,
1042 1043
				struct spi_transfer *transfer)
{
1044
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
1045 1046
	unsigned long transfer_timeout;
	unsigned long timeout;
1047

1048 1049 1050 1051
	spi_imx->tx_buf = transfer->tx_buf;
	spi_imx->rx_buf = transfer->rx_buf;
	spi_imx->count = transfer->len;
	spi_imx->txfifo = 0;
1052

1053
	reinit_completion(&spi_imx->xfer_done);
1054

1055
	spi_imx_push(spi_imx);
1056

1057
	spi_imx->devtype_data->intctrl(spi_imx, MXC_INT_TE);
1058

1059 1060 1061 1062 1063 1064 1065 1066 1067
	transfer_timeout = spi_imx_calculate_timeout(spi_imx, transfer->len);

	timeout = wait_for_completion_timeout(&spi_imx->xfer_done,
					      transfer_timeout);
	if (!timeout) {
		dev_err(&spi->dev, "I/O Error in PIO\n");
		spi_imx->devtype_data->reset(spi_imx);
		return -ETIMEDOUT;
	}
1068 1069 1070 1071

	return transfer->len;
}

Robin Gong's avatar
Robin Gong committed
1072 1073 1074 1075 1076
static int spi_imx_transfer(struct spi_device *spi,
				struct spi_transfer *transfer)
{
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);

1077
	if (spi_imx->usedma)
1078
		return spi_imx_dma_transfer(spi_imx, transfer);
1079 1080
	else
		return spi_imx_pio_transfer(spi, transfer);
Robin Gong's avatar
Robin Gong committed
1081 1082
}

1083
static int spi_imx_setup(struct spi_device *spi)
1084
{
1085
	dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz\n", __func__,
1086 1087
		 spi->mode, spi->bits_per_word, spi->max_speed_hz);

1088 1089 1090
	if (gpio_is_valid(spi->cs_gpio))
		gpio_direction_output(spi->cs_gpio,
				      spi->mode & SPI_CS_HIGH ? 0 : 1);
1091

1092
	spi_imx_chipselect(spi, BITBANG_CS_INACTIVE);
1093 1094 1095 1096

	return 0;
}

1097
static void spi_imx_cleanup(struct spi_device *spi)
1098 1099 1100
{
}

1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129
static int
spi_imx_prepare_message(struct spi_master *master, struct spi_message *msg)
{
	struct spi_imx_data *spi_imx = spi_master_get_devdata(master);
	int ret;

	ret = clk_enable(spi_imx->clk_per);
	if (ret)
		return ret;

	ret = clk_enable(spi_imx->clk_ipg);
	if (ret) {
		clk_disable(spi_imx->clk_per);
		return ret;
	}

	return 0;
}

static int
spi_imx_unprepare_message(struct spi_master *master, struct spi_message *msg)
{
	struct spi_imx_data *spi_imx = spi_master_get_devdata(master);

	clk_disable(spi_imx->clk_ipg);
	clk_disable(spi_imx->clk_per);
	return 0;
}

1130
static int spi_imx_probe(struct platform_device *pdev)
1131
{
1132 1133 1134 1135 1136
	struct device_node *np = pdev->dev.of_node;
	const struct of_device_id *of_id =
			of_match_device(spi_imx_dt_ids, &pdev->dev);
	struct spi_imx_master *mxc_platform_info =
			dev_get_platdata(&pdev->dev);
1137
	struct spi_master *master;
1138
	struct spi_imx_data *spi_imx;
1139
	struct resource *res;
1140
	int i, ret, irq;
1141

1142
	if (!np && !mxc_platform_info) {
1143 1144 1145 1146
		dev_err(&pdev->dev, "can't get the platform data\n");
		return -EINVAL;
	}

1147
	master = spi_alloc_master(&pdev->dev, sizeof(struct spi_imx_data));
1148 1149 1150 1151 1152
	if (!master)
		return -ENOMEM;

	platform_set_drvdata(pdev, master);

1153
	master->bits_per_word_mask = SPI_BPW_RANGE_MASK(1, 32);
1154
	master->bus_num = np ? -1 : pdev->id;
1155

1156
	spi_imx = spi_master_get_devdata(master);
1157
	spi_imx->bitbang.master = master;
1158
	spi_imx->dev = &pdev->dev;
1159

1160 1161 1162
	spi_imx->devtype_data = of_id ? of_id->data :
		(struct spi_imx_devtype_data *)pdev->id_entry->driver_data;

1163 1164 1165 1166 1167 1168
	if (mxc_platform_info) {
		master->num_chipselect = mxc_platform_info->num_chipselect;
		master->cs_gpios = devm_kzalloc(&master->dev,
			sizeof(int) * master->num_chipselect, GFP_KERNEL);
		if (!master->cs_gpios)
			return -ENOMEM;
1169

1170 1171 1172
		for (i = 0; i < master->num_chipselect; i++)
			master->cs_gpios[i] = mxc_platform_info->chipselect[i];
 	}
1173

1174 1175 1176 1177 1178
	spi_imx->bitbang.chipselect = spi_imx_chipselect;
	spi_imx->bitbang.setup_transfer = spi_imx_setupxfer;
	spi_imx->bitbang.txrx_bufs = spi_imx_transfer;
	spi_imx->bitbang.master->setup = spi_imx_setup;
	spi_imx->bitbang.master->cleanup = spi_imx_cleanup;
1179 1180
	spi_imx->bitbang.master->prepare_message = spi_imx_prepare_message;
	spi_imx->bitbang.master->unprepare_message = spi_imx_unprepare_message;
Anton Bondarenko's avatar