spi-imx.c 23.7 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 24 25 26 27 28 29 30 31 32
/*
 * 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>
#include <linux/err.h>
#include <linux/gpio.h>
#include <linux/init.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>
33
#include <linux/slab.h>
34 35 36
#include <linux/spi/spi.h>
#include <linux/spi/spi_bitbang.h>
#include <linux/types.h>
37 38 39
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

#include <mach/spi.h>

#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 */

55
struct spi_imx_config {
56 57 58
	unsigned int speed_hz;
	unsigned int bpw;
	unsigned int mode;
59
	u8 cs;
60 61
};

62
enum spi_imx_devtype {
63 64 65 66 67 68
	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 */
69 70 71 72 73 74 75 76 77
};

struct spi_imx_data;

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

82
struct spi_imx_data {
83 84 85
	struct spi_bitbang bitbang;

	struct completion xfer_done;
86
	void __iomem *base;
87 88 89 90 91
	int irq;
	struct clk *clk;
	unsigned long spi_clk;

	unsigned int count;
92 93
	void (*tx)(struct spi_imx_data *);
	void (*rx)(struct spi_imx_data *);
94 95 96 97
	void *rx_buf;
	const void *tx_buf;
	unsigned int txfifo; /* number of words pushed in tx FIFO */

98
	struct spi_imx_devtype_data *devtype_data;
99
	int chipselect[0];
100 101
};

102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
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;
}

static inline unsigned spi_imx_get_fifosize(struct spi_imx_data *d)
{
	return (d->devtype_data->devtype == IMX51_ECSPI) ? 64 : 8;
}

117
#define MXC_SPI_BUF_RX(type)						\
118
static void spi_imx_buf_rx_##type(struct spi_imx_data *spi_imx)		\
119
{									\
120
	unsigned int val = readl(spi_imx->base + MXC_CSPIRXDATA);	\
121
									\
122 123 124
	if (spi_imx->rx_buf) {						\
		*(type *)spi_imx->rx_buf = val;				\
		spi_imx->rx_buf += sizeof(type);			\
125 126 127 128
	}								\
}

#define MXC_SPI_BUF_TX(type)						\
129
static void spi_imx_buf_tx_##type(struct spi_imx_data *spi_imx)		\
130 131 132
{									\
	type val = 0;							\
									\
133 134 135
	if (spi_imx->tx_buf) {						\
		val = *(type *)spi_imx->tx_buf;				\
		spi_imx->tx_buf += sizeof(type);			\
136 137
	}								\
									\
138
	spi_imx->count -= sizeof(type);					\
139
									\
140
	writel(val, spi_imx->base + MXC_CSPITXDATA);			\
141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156
}

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 */
157
static unsigned int spi_imx_clkdiv_1(unsigned int fin,
158
		unsigned int fspi, unsigned int max)
159
{
160
	int i;
161 162 163 164 165 166 167 168

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

	return max;
}

169
/* MX1, MX31, MX35, MX51 CSPI */
170
static unsigned int spi_imx_clkdiv_2(unsigned int fin,
171 172 173 174 175 176 177 178 179 180 181 182 183
		unsigned int fspi)
{
	int i, div = 4;

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

	return 7;
}

184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204
#define MX51_ECSPI_CTRL		0x08
#define MX51_ECSPI_CTRL_ENABLE		(1 <<  0)
#define MX51_ECSPI_CTRL_XCH		(1 <<  2)
#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))

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

#define MX51_ECSPI_STAT		0x18
#define MX51_ECSPI_STAT_RR		(1 <<  3)
205 206

/* MX51 eCSPI */
207
static unsigned int mx51_ecspi_clkdiv(unsigned int fin, unsigned int fspi)
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
{
	/*
	 * there are two 4-bit dividers, the pre-divider divides by
	 * $pre, the post-divider by 2^$post
	 */
	unsigned int pre, post;

	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)) {
		pr_err("%s: cannot set clock freq: %u (base freq: %u)\n",
				__func__, fspi, fin);
		return 0xff;
	}

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

	pr_debug("%s: fin: %u, fspi: %u, post: %u, pre: %u\n",
			__func__, fin, fspi, post, pre);
235 236
	return (pre << MX51_ECSPI_CTRL_PREDIV_OFFSET) |
		(post << MX51_ECSPI_CTRL_POSTDIV_OFFSET);
237 238
}

239
static void __maybe_unused mx51_ecspi_intctrl(struct spi_imx_data *spi_imx, int enable)
240 241 242 243
{
	unsigned val = 0;

	if (enable & MXC_INT_TE)
244
		val |= MX51_ECSPI_INT_TEEN;
245 246

	if (enable & MXC_INT_RR)
247
		val |= MX51_ECSPI_INT_RREN;
248

249
	writel(val, spi_imx->base + MX51_ECSPI_INT);
250 251
}

252
static void __maybe_unused mx51_ecspi_trigger(struct spi_imx_data *spi_imx)
253 254 255
{
	u32 reg;

256 257 258
	reg = readl(spi_imx->base + MX51_ECSPI_CTRL);
	reg |= MX51_ECSPI_CTRL_XCH;
	writel(reg, spi_imx->base + MX51_ECSPI_CTRL);
259 260
}

261
static int __maybe_unused mx51_ecspi_config(struct spi_imx_data *spi_imx,
262 263
		struct spi_imx_config *config)
{
264
	u32 ctrl = MX51_ECSPI_CTRL_ENABLE, cfg = 0;
265

266 267 268 269 270 271 272
	/*
	 * 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.
	 */
273
	ctrl |= MX51_ECSPI_CTRL_MODE_MASK;
274 275

	/* set clock speed */
276
	ctrl |= mx51_ecspi_clkdiv(spi_imx->spi_clk, config->speed_hz);
277 278

	/* set chip select to use */
279
	ctrl |= MX51_ECSPI_CTRL_CS(config->cs);
280

281
	ctrl |= (config->bpw - 1) << MX51_ECSPI_CTRL_BL_OFFSET;
282

283
	cfg |= MX51_ECSPI_CONFIG_SBBCTRL(config->cs);
284 285

	if (config->mode & SPI_CPHA)
286
		cfg |= MX51_ECSPI_CONFIG_SCLKPHA(config->cs);
287 288

	if (config->mode & SPI_CPOL)
289
		cfg |= MX51_ECSPI_CONFIG_SCLKPOL(config->cs);
290 291

	if (config->mode & SPI_CS_HIGH)
292
		cfg |= MX51_ECSPI_CONFIG_SSBPOL(config->cs);
293

294 295
	writel(ctrl, spi_imx->base + MX51_ECSPI_CTRL);
	writel(cfg, spi_imx->base + MX51_ECSPI_CONFIG);
296 297 298 299

	return 0;
}

300
static int __maybe_unused mx51_ecspi_rx_available(struct spi_imx_data *spi_imx)
301
{
302
	return readl(spi_imx->base + MX51_ECSPI_STAT) & MX51_ECSPI_STAT_RR;
303 304
}

305
static void __maybe_unused mx51_ecspi_reset(struct spi_imx_data *spi_imx)
306 307
{
	/* drain receive buffer */
308
	while (mx51_ecspi_rx_available(spi_imx))
309 310 311
		readl(spi_imx->base + MXC_CSPIRXDATA);
}

312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
#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.
 */
335
static void __maybe_unused mx31_intctrl(struct spi_imx_data *spi_imx, int enable)
336 337 338 339 340 341 342 343
{
	unsigned int val = 0;

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

344
	writel(val, spi_imx->base + MXC_CSPIINT);
345 346
}

347
static void __maybe_unused mx31_trigger(struct spi_imx_data *spi_imx)
348 349 350
{
	unsigned int reg;

351
	reg = readl(spi_imx->base + MXC_CSPICTRL);
352
	reg |= MX31_CSPICTRL_XCH;
353
	writel(reg, spi_imx->base + MXC_CSPICTRL);
354 355
}

356
static int __maybe_unused mx31_config(struct spi_imx_data *spi_imx,
357 358 359
		struct spi_imx_config *config)
{
	unsigned int reg = MX31_CSPICTRL_ENABLE | MX31_CSPICTRL_MASTER;
360
	int cs = spi_imx->chipselect[config->cs];
361 362 363 364

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

365
	if (is_imx35_cspi(spi_imx)) {
366 367 368 369 370
		reg |= (config->bpw - 1) << MX35_CSPICTRL_BL_SHIFT;
		reg |= MX31_CSPICTRL_SSCTL;
	} else {
		reg |= (config->bpw - 1) << MX31_CSPICTRL_BC_SHIFT;
	}
371 372 373 374 375 376 377

	if (config->mode & SPI_CPHA)
		reg |= MX31_CSPICTRL_PHA;
	if (config->mode & SPI_CPOL)
		reg |= MX31_CSPICTRL_POL;
	if (config->mode & SPI_CS_HIGH)
		reg |= MX31_CSPICTRL_SSPOL;
378
	if (cs < 0)
379
		reg |= (cs + 32) <<
380 381
			(is_imx35_cspi(spi_imx) ? MX35_CSPICTRL_CS_SHIFT :
						  MX31_CSPICTRL_CS_SHIFT);
382 383 384 385 386 387

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

	return 0;
}

388
static int __maybe_unused mx31_rx_available(struct spi_imx_data *spi_imx)
389
{
390
	return readl(spi_imx->base + MX31_CSPISTATUS) & MX31_STATUS_RR;
391 392
}

393
static void __maybe_unused mx31_reset(struct spi_imx_data *spi_imx)
394 395
{
	/* drain receive buffer */
396
	while (readl(spi_imx->base + MX31_CSPISTATUS) & MX31_STATUS_RR)
397 398 399
		readl(spi_imx->base + MXC_CSPIRXDATA);
}

400 401 402 403 404 405 406 407 408 409 410 411 412 413
#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

static void __maybe_unused mx21_intctrl(struct spi_imx_data *spi_imx, int enable)
414 415 416 417
{
	unsigned int val = 0;

	if (enable & MXC_INT_TE)
418
		val |= MX21_INTREG_TEEN;
419
	if (enable & MXC_INT_RR)
420
		val |= MX21_INTREG_RREN;
421

422
	writel(val, spi_imx->base + MXC_CSPIINT);
423 424
}

425
static void __maybe_unused mx21_trigger(struct spi_imx_data *spi_imx)
426 427 428
{
	unsigned int reg;

429
	reg = readl(spi_imx->base + MXC_CSPICTRL);
430
	reg |= MX21_CSPICTRL_XCH;
431
	writel(reg, spi_imx->base + MXC_CSPICTRL);
432 433
}

434
static int __maybe_unused mx21_config(struct spi_imx_data *spi_imx,
435
		struct spi_imx_config *config)
436
{
437
	unsigned int reg = MX21_CSPICTRL_ENABLE | MX21_CSPICTRL_MASTER;
438
	int cs = spi_imx->chipselect[config->cs];
439
	unsigned int max = is_imx27_cspi(spi_imx) ? 16 : 18;
440

441
	reg |= spi_imx_clkdiv_1(spi_imx->spi_clk, config->speed_hz, max) <<
442
		MX21_CSPICTRL_DR_SHIFT;
443 444 445
	reg |= config->bpw - 1;

	if (config->mode & SPI_CPHA)
446
		reg |= MX21_CSPICTRL_PHA;
447
	if (config->mode & SPI_CPOL)
448
		reg |= MX21_CSPICTRL_POL;
449
	if (config->mode & SPI_CS_HIGH)
450
		reg |= MX21_CSPICTRL_SSPOL;
451
	if (cs < 0)
452
		reg |= (cs + 32) << MX21_CSPICTRL_CS_SHIFT;
453

454
	writel(reg, spi_imx->base + MXC_CSPICTRL);
455 456 457 458

	return 0;
}

459
static int __maybe_unused mx21_rx_available(struct spi_imx_data *spi_imx)
460
{
461
	return readl(spi_imx->base + MXC_CSPIINT) & MX21_INTREG_RR;
462 463
}

464
static void __maybe_unused mx21_reset(struct spi_imx_data *spi_imx)
465 466 467 468
{
	writel(1, spi_imx->base + MXC_RESET);
}

469 470 471 472 473 474 475 476 477 478 479
#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

480
static void __maybe_unused mx1_intctrl(struct spi_imx_data *spi_imx, int enable)
481 482 483 484 485 486 487 488
{
	unsigned int val = 0;

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

489
	writel(val, spi_imx->base + MXC_CSPIINT);
490 491
}

492
static void __maybe_unused mx1_trigger(struct spi_imx_data *spi_imx)
493 494 495
{
	unsigned int reg;

496
	reg = readl(spi_imx->base + MXC_CSPICTRL);
497
	reg |= MX1_CSPICTRL_XCH;
498
	writel(reg, spi_imx->base + MXC_CSPICTRL);
499 500
}

501
static int __maybe_unused mx1_config(struct spi_imx_data *spi_imx,
502
		struct spi_imx_config *config)
503 504 505
{
	unsigned int reg = MX1_CSPICTRL_ENABLE | MX1_CSPICTRL_MASTER;

506
	reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) <<
507 508 509 510 511 512 513 514
		MX1_CSPICTRL_DR_SHIFT;
	reg |= config->bpw - 1;

	if (config->mode & SPI_CPHA)
		reg |= MX1_CSPICTRL_PHA;
	if (config->mode & SPI_CPOL)
		reg |= MX1_CSPICTRL_POL;

515
	writel(reg, spi_imx->base + MXC_CSPICTRL);
516 517 518 519

	return 0;
}

520
static int __maybe_unused mx1_rx_available(struct spi_imx_data *spi_imx)
521
{
522
	return readl(spi_imx->base + MXC_CSPIINT) & MX1_INTREG_RR;
523 524
}

525 526 527 528 529
static void __maybe_unused mx1_reset(struct spi_imx_data *spi_imx)
{
	writel(1, spi_imx->base + MXC_RESET);
}

530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607
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,
};

static struct platform_device_id spi_imx_devtype[] = {
	{
		.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 */
	}
608 609
};

610 611 612 613 614 615 616 617 618 619
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 */ }
};

620
static void spi_imx_chipselect(struct spi_device *spi, int is_active)
621
{
622 623
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
	int gpio = spi_imx->chipselect[spi->chip_select];
624 625
	int active = is_active != BITBANG_CS_INACTIVE;
	int dev_is_lowactive = !(spi->mode & SPI_CS_HIGH);
626

627
	if (gpio < 0)
628 629
		return;

630
	gpio_set_value(gpio, dev_is_lowactive ^ active);
631 632
}

633
static void spi_imx_push(struct spi_imx_data *spi_imx)
634
{
635
	while (spi_imx->txfifo < spi_imx_get_fifosize(spi_imx)) {
636
		if (!spi_imx->count)
637
			break;
638 639
		spi_imx->tx(spi_imx);
		spi_imx->txfifo++;
640 641
	}

642
	spi_imx->devtype_data->trigger(spi_imx);
643 644
}

645
static irqreturn_t spi_imx_isr(int irq, void *dev_id)
646
{
647
	struct spi_imx_data *spi_imx = dev_id;
648

649
	while (spi_imx->devtype_data->rx_available(spi_imx)) {
650 651
		spi_imx->rx(spi_imx);
		spi_imx->txfifo--;
652 653
	}

654 655
	if (spi_imx->count) {
		spi_imx_push(spi_imx);
656 657 658
		return IRQ_HANDLED;
	}

659
	if (spi_imx->txfifo) {
660 661 662
		/* No data left to push, but still waiting for rx data,
		 * enable receive data available interrupt.
		 */
663
		spi_imx->devtype_data->intctrl(
664
				spi_imx, MXC_INT_RR);
665 666 667
		return IRQ_HANDLED;
	}

668
	spi_imx->devtype_data->intctrl(spi_imx, 0);
669
	complete(&spi_imx->xfer_done);
670 671 672 673

	return IRQ_HANDLED;
}

674
static int spi_imx_setupxfer(struct spi_device *spi,
675 676
				 struct spi_transfer *t)
{
677 678
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
	struct spi_imx_config config;
679 680 681 682

	config.bpw = t ? t->bits_per_word : spi->bits_per_word;
	config.speed_hz  = t ? t->speed_hz : spi->max_speed_hz;
	config.mode = spi->mode;
683
	config.cs = spi->chip_select;
684

S
Sascha Hauer 已提交
685 686 687 688 689 690 691
	if (!config.speed_hz)
		config.speed_hz = spi->max_speed_hz;
	if (!config.bpw)
		config.bpw = spi->bits_per_word;
	if (!config.speed_hz)
		config.speed_hz = spi->max_speed_hz;

692 693 694 695 696 697 698 699 700 701 702 703 704
	/* 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;
	} else if (config.bpw <= 32) {
		spi_imx->rx = spi_imx_buf_rx_u32;
		spi_imx->tx = spi_imx_buf_tx_u32;
	} else
		BUG();

705
	spi_imx->devtype_data->config(spi_imx, &config);
706 707 708 709

	return 0;
}

710
static int spi_imx_transfer(struct spi_device *spi,
711 712
				struct spi_transfer *transfer)
{
713
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
714

715 716 717 718
	spi_imx->tx_buf = transfer->tx_buf;
	spi_imx->rx_buf = transfer->rx_buf;
	spi_imx->count = transfer->len;
	spi_imx->txfifo = 0;
719

720
	init_completion(&spi_imx->xfer_done);
721

722
	spi_imx_push(spi_imx);
723

724
	spi_imx->devtype_data->intctrl(spi_imx, MXC_INT_TE);
725

726
	wait_for_completion(&spi_imx->xfer_done);
727 728 729 730

	return transfer->len;
}

731
static int spi_imx_setup(struct spi_device *spi)
732
{
733 734 735
	struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
	int gpio = spi_imx->chipselect[spi->chip_select];

736
	dev_dbg(&spi->dev, "%s: mode %d, %u bpw, %d hz\n", __func__,
737 738
		 spi->mode, spi->bits_per_word, spi->max_speed_hz);

739 740 741
	if (gpio >= 0)
		gpio_direction_output(gpio, spi->mode & SPI_CS_HIGH ? 0 : 1);

742
	spi_imx_chipselect(spi, BITBANG_CS_INACTIVE);
743 744 745 746

	return 0;
}

747
static void spi_imx_cleanup(struct spi_device *spi)
748 749 750
{
}

751
static int __devinit spi_imx_probe(struct platform_device *pdev)
752
{
753 754 755 756 757
	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);
758
	struct spi_master *master;
759
	struct spi_imx_data *spi_imx;
760
	struct resource *res;
761
	int i, ret, num_cs;
762

763
	if (!np && !mxc_platform_info) {
764 765 766 767
		dev_err(&pdev->dev, "can't get the platform data\n");
		return -EINVAL;
	}

768
	ret = of_property_read_u32(np, "fsl,spi-num-chipselects", &num_cs);
769 770 771 772 773 774
	if (ret < 0) {
		if (mxc_platform_info)
			num_cs = mxc_platform_info->num_chipselect;
		else
			return ret;
	}
775

776 777
	master = spi_alloc_master(&pdev->dev,
			sizeof(struct spi_imx_data) + sizeof(int) * num_cs);
778 779 780 781 782 783
	if (!master)
		return -ENOMEM;

	platform_set_drvdata(pdev, master);

	master->bus_num = pdev->id;
784
	master->num_chipselect = num_cs;
785

786 787
	spi_imx = spi_master_get_devdata(master);
	spi_imx->bitbang.master = spi_master_get(master);
788 789

	for (i = 0; i < master->num_chipselect; i++) {
790
		int cs_gpio = of_get_named_gpio(np, "cs-gpios", i);
791
		if (cs_gpio < 0 && mxc_platform_info)
792
			cs_gpio = mxc_platform_info->chipselect[i];
793 794

		spi_imx->chipselect[i] = cs_gpio;
795
		if (cs_gpio < 0)
796
			continue;
797

798
		ret = gpio_request(spi_imx->chipselect[i], DRIVER_NAME);
799
		if (ret) {
800
			dev_err(&pdev->dev, "can't get cs gpios\n");
801
			goto out_gpio_free;
802 803 804
		}
	}

805 806 807 808 809
	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;
810
	spi_imx->bitbang.master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;
811

812
	init_completion(&spi_imx->xfer_done);
813

814
	spi_imx->devtype_data = of_id ? of_id->data :
815
		(struct spi_imx_devtype_data *) pdev->id_entry->driver_data;
816

817 818 819 820 821 822 823 824 825 826 827 828 829
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res) {
		dev_err(&pdev->dev, "can't get platform resource\n");
		ret = -ENOMEM;
		goto out_gpio_free;
	}

	if (!request_mem_region(res->start, resource_size(res), pdev->name)) {
		dev_err(&pdev->dev, "request_mem_region failed\n");
		ret = -EBUSY;
		goto out_gpio_free;
	}

830 831
	spi_imx->base = ioremap(res->start, resource_size(res));
	if (!spi_imx->base) {
832 833 834 835
		ret = -EINVAL;
		goto out_release_mem;
	}

836
	spi_imx->irq = platform_get_irq(pdev, 0);
837
	if (spi_imx->irq < 0) {
838 839 840 841
		ret = -EINVAL;
		goto out_iounmap;
	}

842
	ret = request_irq(spi_imx->irq, spi_imx_isr, 0, DRIVER_NAME, spi_imx);
843
	if (ret) {
844
		dev_err(&pdev->dev, "can't get irq%d: %d\n", spi_imx->irq, ret);
845 846 847
		goto out_iounmap;
	}

848 849
	spi_imx->clk = clk_get(&pdev->dev, NULL);
	if (IS_ERR(spi_imx->clk)) {
850
		dev_err(&pdev->dev, "unable to get clock\n");
851
		ret = PTR_ERR(spi_imx->clk);
852 853 854
		goto out_free_irq;
	}

855 856
	clk_enable(spi_imx->clk);
	spi_imx->spi_clk = clk_get_rate(spi_imx->clk);
857

858
	spi_imx->devtype_data->reset(spi_imx);
859

860
	spi_imx->devtype_data->intctrl(spi_imx, 0);
861

862
	master->dev.of_node = pdev->dev.of_node;
863
	ret = spi_bitbang_start(&spi_imx->bitbang);
864 865 866 867 868 869 870 871 872 873
	if (ret) {
		dev_err(&pdev->dev, "bitbang start failed with %d\n", ret);
		goto out_clk_put;
	}

	dev_info(&pdev->dev, "probed\n");

	return ret;

out_clk_put:
874 875
	clk_disable(spi_imx->clk);
	clk_put(spi_imx->clk);
876
out_free_irq:
877
	free_irq(spi_imx->irq, spi_imx);
878
out_iounmap:
879
	iounmap(spi_imx->base);
880 881 882
out_release_mem:
	release_mem_region(res->start, resource_size(res));
out_gpio_free:
883
	while (--i >= 0) {
884 885
		if (spi_imx->chipselect[i] >= 0)
			gpio_free(spi_imx->chipselect[i]);
886
	}
887 888 889 890 891 892
	spi_master_put(master);
	kfree(master);
	platform_set_drvdata(pdev, NULL);
	return ret;
}

893
static int __devexit spi_imx_remove(struct platform_device *pdev)
894 895 896
{
	struct spi_master *master = platform_get_drvdata(pdev);
	struct resource *res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
897
	struct spi_imx_data *spi_imx = spi_master_get_devdata(master);
898 899
	int i;

900
	spi_bitbang_stop(&spi_imx->bitbang);
901

902 903 904 905 906
	writel(0, spi_imx->base + MXC_CSPICTRL);
	clk_disable(spi_imx->clk);
	clk_put(spi_imx->clk);
	free_irq(spi_imx->irq, spi_imx);
	iounmap(spi_imx->base);
907 908

	for (i = 0; i < master->num_chipselect; i++)
909 910
		if (spi_imx->chipselect[i] >= 0)
			gpio_free(spi_imx->chipselect[i]);
911 912 913 914 915 916 917 918 919 920

	spi_master_put(master);

	release_mem_region(res->start, resource_size(res));

	platform_set_drvdata(pdev, NULL);

	return 0;
}

921
static struct platform_driver spi_imx_driver = {
922 923 924
	.driver = {
		   .name = DRIVER_NAME,
		   .owner = THIS_MODULE,
925
		   .of_match_table = spi_imx_dt_ids,
926
		   },
927
	.id_table = spi_imx_devtype,
928
	.probe = spi_imx_probe,
929
	.remove = __devexit_p(spi_imx_remove),
930
};
931
module_platform_driver(spi_imx_driver);
932 933 934 935

MODULE_DESCRIPTION("SPI Master Controller driver");
MODULE_AUTHOR("Sascha Hauer, Pengutronix");
MODULE_LICENSE("GPL");