spi-omap2-mcspi.c 33.5 KB
Newer Older
S
Samuel Ortiz 已提交
1 2 3 4 5
/*
 * OMAP2 McSPI controller driver
 *
 * Copyright (C) 2005, 2006 Nokia Corporation
 * Author:	Samuel Ortiz <samuel.ortiz@nokia.com> and
6
 *		Juha Yrj�l� <juha.yrjola@nokia.com>
S
Samuel Ortiz 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 * 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, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/dma-mapping.h>
31 32
#include <linux/dmaengine.h>
#include <linux/omap-dma.h>
S
Samuel Ortiz 已提交
33 34 35 36
#include <linux/platform_device.h>
#include <linux/err.h>
#include <linux/clk.h>
#include <linux/io.h>
37
#include <linux/slab.h>
38
#include <linux/pm_runtime.h>
39 40
#include <linux/of.h>
#include <linux/of_device.h>
41
#include <linux/pinctrl/consumer.h>
S
Samuel Ortiz 已提交
42 43 44

#include <linux/spi/spi.h>

45
#include <linux/platform_data/spi-omap2-mcspi.h>
S
Samuel Ortiz 已提交
46 47

#define OMAP2_MCSPI_MAX_FREQ		48000000
48
#define SPI_AUTOSUSPEND_TIMEOUT		2000
S
Samuel Ortiz 已提交
49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

#define OMAP2_MCSPI_REVISION		0x00
#define OMAP2_MCSPI_SYSSTATUS		0x14
#define OMAP2_MCSPI_IRQSTATUS		0x18
#define OMAP2_MCSPI_IRQENABLE		0x1c
#define OMAP2_MCSPI_WAKEUPENABLE	0x20
#define OMAP2_MCSPI_SYST		0x24
#define OMAP2_MCSPI_MODULCTRL		0x28

/* per-channel banks, 0x14 bytes each, first is: */
#define OMAP2_MCSPI_CHCONF0		0x2c
#define OMAP2_MCSPI_CHSTAT0		0x30
#define OMAP2_MCSPI_CHCTRL0		0x34
#define OMAP2_MCSPI_TX0			0x38
#define OMAP2_MCSPI_RX0			0x3c

/* per-register bitmasks: */

J
Jouni Hogander 已提交
67 68 69
#define OMAP2_MCSPI_MODULCTRL_SINGLE	BIT(0)
#define OMAP2_MCSPI_MODULCTRL_MS	BIT(2)
#define OMAP2_MCSPI_MODULCTRL_STEST	BIT(3)
S
Samuel Ortiz 已提交
70

J
Jouni Hogander 已提交
71 72
#define OMAP2_MCSPI_CHCONF_PHA		BIT(0)
#define OMAP2_MCSPI_CHCONF_POL		BIT(1)
S
Samuel Ortiz 已提交
73
#define OMAP2_MCSPI_CHCONF_CLKD_MASK	(0x0f << 2)
J
Jouni Hogander 已提交
74
#define OMAP2_MCSPI_CHCONF_EPOL		BIT(6)
S
Samuel Ortiz 已提交
75
#define OMAP2_MCSPI_CHCONF_WL_MASK	(0x1f << 7)
J
Jouni Hogander 已提交
76 77
#define OMAP2_MCSPI_CHCONF_TRM_RX_ONLY	BIT(12)
#define OMAP2_MCSPI_CHCONF_TRM_TX_ONLY	BIT(13)
S
Samuel Ortiz 已提交
78
#define OMAP2_MCSPI_CHCONF_TRM_MASK	(0x03 << 12)
J
Jouni Hogander 已提交
79 80 81 82 83 84 85
#define OMAP2_MCSPI_CHCONF_DMAW		BIT(14)
#define OMAP2_MCSPI_CHCONF_DMAR		BIT(15)
#define OMAP2_MCSPI_CHCONF_DPE0		BIT(16)
#define OMAP2_MCSPI_CHCONF_DPE1		BIT(17)
#define OMAP2_MCSPI_CHCONF_IS		BIT(18)
#define OMAP2_MCSPI_CHCONF_TURBO	BIT(19)
#define OMAP2_MCSPI_CHCONF_FORCE	BIT(20)
S
Samuel Ortiz 已提交
86

J
Jouni Hogander 已提交
87 88 89
#define OMAP2_MCSPI_CHSTAT_RXS		BIT(0)
#define OMAP2_MCSPI_CHSTAT_TXS		BIT(1)
#define OMAP2_MCSPI_CHSTAT_EOT		BIT(2)
S
Samuel Ortiz 已提交
90

J
Jouni Hogander 已提交
91
#define OMAP2_MCSPI_CHCTRL_EN		BIT(0)
S
Samuel Ortiz 已提交
92

J
Jouni Hogander 已提交
93
#define OMAP2_MCSPI_WAKEUPENABLE_WKEN	BIT(0)
S
Samuel Ortiz 已提交
94 95 96

/* We have 2 DMA channels per CS, one for RX and one for TX */
struct omap2_mcspi_dma {
97 98
	struct dma_chan *dma_tx;
	struct dma_chan *dma_rx;
S
Samuel Ortiz 已提交
99 100 101 102 103 104 105 106 107 108 109

	int dma_tx_sync_dev;
	int dma_rx_sync_dev;

	struct completion dma_tx_completion;
	struct completion dma_rx_completion;
};

/* use PIO for small transfers, avoiding DMA setup/teardown overhead and
 * cache operations; better heuristics consider wordsize and bitrate.
 */
110
#define DMA_MIN_BYTES			160
S
Samuel Ortiz 已提交
111 112


113 114 115 116 117 118 119 120 121 122
/*
 * Used for context save and restore, structure members to be updated whenever
 * corresponding registers are modified.
 */
struct omap2_mcspi_regs {
	u32 modulctrl;
	u32 wakeupenable;
	struct list_head cs;
};

S
Samuel Ortiz 已提交
123 124 125 126
struct omap2_mcspi {
	struct spi_master	*master;
	/* Virtual base address of the controller */
	void __iomem		*base;
127
	unsigned long		phys;
S
Samuel Ortiz 已提交
128 129
	/* SPI1 has 4 channels, while SPI2 has 2 */
	struct omap2_mcspi_dma	*dma_channels;
130 131
	struct device		*dev;
	struct omap2_mcspi_regs ctx;
132
	unsigned int		pin_dir:1;
S
Samuel Ortiz 已提交
133 134 135 136
};

struct omap2_mcspi_cs {
	void __iomem		*base;
137
	unsigned long		phys;
S
Samuel Ortiz 已提交
138
	int			word_len;
T
Tero Kristo 已提交
139
	struct list_head	node;
H
Hemanth V 已提交
140 141 142 143
	/* Context save and restore shadow register */
	u32			chconf0;
};

S
Samuel Ortiz 已提交
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
static inline void mcspi_write_reg(struct spi_master *master,
		int idx, u32 val)
{
	struct omap2_mcspi *mcspi = spi_master_get_devdata(master);

	__raw_writel(val, mcspi->base + idx);
}

static inline u32 mcspi_read_reg(struct spi_master *master, int idx)
{
	struct omap2_mcspi *mcspi = spi_master_get_devdata(master);

	return __raw_readl(mcspi->base + idx);
}

static inline void mcspi_write_cs_reg(const struct spi_device *spi,
		int idx, u32 val)
{
	struct omap2_mcspi_cs	*cs = spi->controller_state;

	__raw_writel(val, cs->base +  idx);
}

static inline u32 mcspi_read_cs_reg(const struct spi_device *spi, int idx)
{
	struct omap2_mcspi_cs	*cs = spi->controller_state;

	return __raw_readl(cs->base + idx);
}

H
Hemanth V 已提交
174 175 176 177 178 179 180 181 182 183 184 185 186
static inline u32 mcspi_cached_chconf0(const struct spi_device *spi)
{
	struct omap2_mcspi_cs *cs = spi->controller_state;

	return cs->chconf0;
}

static inline void mcspi_write_chconf0(const struct spi_device *spi, u32 val)
{
	struct omap2_mcspi_cs *cs = spi->controller_state;

	cs->chconf0 = val;
	mcspi_write_cs_reg(spi, OMAP2_MCSPI_CHCONF0, val);
187
	mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHCONF0);
H
Hemanth V 已提交
188 189
}

S
Samuel Ortiz 已提交
190 191 192 193 194
static void omap2_mcspi_set_dma_req(const struct spi_device *spi,
		int is_read, int enable)
{
	u32 l, rw;

H
Hemanth V 已提交
195
	l = mcspi_cached_chconf0(spi);
S
Samuel Ortiz 已提交
196 197 198 199 200 201

	if (is_read) /* 1 is read, 0 write */
		rw = OMAP2_MCSPI_CHCONF_DMAR;
	else
		rw = OMAP2_MCSPI_CHCONF_DMAW;

202 203 204 205 206
	if (enable)
		l |= rw;
	else
		l &= ~rw;

H
Hemanth V 已提交
207
	mcspi_write_chconf0(spi, l);
S
Samuel Ortiz 已提交
208 209 210 211 212 213 214 215
}

static void omap2_mcspi_set_enable(const struct spi_device *spi, int enable)
{
	u32 l;

	l = enable ? OMAP2_MCSPI_CHCTRL_EN : 0;
	mcspi_write_cs_reg(spi, OMAP2_MCSPI_CHCTRL0, l);
216 217
	/* Flash post-writes */
	mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHCTRL0);
S
Samuel Ortiz 已提交
218 219 220 221 222 223
}

static void omap2_mcspi_force_cs(struct spi_device *spi, int cs_active)
{
	u32 l;

H
Hemanth V 已提交
224
	l = mcspi_cached_chconf0(spi);
225 226 227 228 229
	if (cs_active)
		l |= OMAP2_MCSPI_CHCONF_FORCE;
	else
		l &= ~OMAP2_MCSPI_CHCONF_FORCE;

H
Hemanth V 已提交
230
	mcspi_write_chconf0(spi, l);
S
Samuel Ortiz 已提交
231 232 233 234
}

static void omap2_mcspi_set_master_mode(struct spi_master *master)
{
235 236
	struct omap2_mcspi	*mcspi = spi_master_get_devdata(master);
	struct omap2_mcspi_regs	*ctx = &mcspi->ctx;
S
Samuel Ortiz 已提交
237 238
	u32 l;

239 240
	/*
	 * Setup when switching from (reset default) slave mode
S
Samuel Ortiz 已提交
241 242 243
	 * to single-channel master mode
	 */
	l = mcspi_read_reg(master, OMAP2_MCSPI_MODULCTRL);
244 245
	l &= ~(OMAP2_MCSPI_MODULCTRL_STEST | OMAP2_MCSPI_MODULCTRL_MS);
	l |= OMAP2_MCSPI_MODULCTRL_SINGLE;
S
Samuel Ortiz 已提交
246
	mcspi_write_reg(master, OMAP2_MCSPI_MODULCTRL, l);
H
Hemanth V 已提交
247

248
	ctx->modulctrl = l;
H
Hemanth V 已提交
249 250 251 252
}

static void omap2_mcspi_restore_ctx(struct omap2_mcspi *mcspi)
{
253 254 255
	struct spi_master	*spi_cntrl = mcspi->master;
	struct omap2_mcspi_regs	*ctx = &mcspi->ctx;
	struct omap2_mcspi_cs	*cs;
H
Hemanth V 已提交
256 257

	/* McSPI: context restore */
258 259
	mcspi_write_reg(spi_cntrl, OMAP2_MCSPI_MODULCTRL, ctx->modulctrl);
	mcspi_write_reg(spi_cntrl, OMAP2_MCSPI_WAKEUPENABLE, ctx->wakeupenable);
H
Hemanth V 已提交
260

261
	list_for_each_entry(cs, &ctx->cs, node)
T
Tero Kristo 已提交
262
		__raw_writel(cs->chconf0, cs->base + OMAP2_MCSPI_CHCONF0);
H
Hemanth V 已提交
263
}
S
Samuel Ortiz 已提交
264

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281
static int omap2_prepare_transfer(struct spi_master *master)
{
	struct omap2_mcspi *mcspi = spi_master_get_devdata(master);

	pm_runtime_get_sync(mcspi->dev);
	return 0;
}

static int omap2_unprepare_transfer(struct spi_master *master)
{
	struct omap2_mcspi *mcspi = spi_master_get_devdata(master);

	pm_runtime_mark_last_busy(mcspi->dev);
	pm_runtime_put_autosuspend(mcspi->dev);
	return 0;
}

282 283 284 285 286 287 288 289 290 291 292 293 294
static int mcspi_wait_for_reg_bit(void __iomem *reg, unsigned long bit)
{
	unsigned long timeout;

	timeout = jiffies + msecs_to_jiffies(1000);
	while (!(__raw_readl(reg) & bit)) {
		if (time_after(jiffies, timeout))
			return -1;
		cpu_relax();
	}
	return 0;
}

295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
static void omap2_mcspi_rx_callback(void *data)
{
	struct spi_device *spi = data;
	struct omap2_mcspi *mcspi = spi_master_get_devdata(spi->master);
	struct omap2_mcspi_dma *mcspi_dma = &mcspi->dma_channels[spi->chip_select];

	complete(&mcspi_dma->dma_rx_completion);

	/* We must disable the DMA RX request */
	omap2_mcspi_set_dma_req(spi, 1, 0);
}

static void omap2_mcspi_tx_callback(void *data)
{
	struct spi_device *spi = data;
	struct omap2_mcspi *mcspi = spi_master_get_devdata(spi->master);
	struct omap2_mcspi_dma *mcspi_dma = &mcspi->dma_channels[spi->chip_select];

	complete(&mcspi_dma->dma_tx_completion);

	/* We must disable the DMA TX request */
	omap2_mcspi_set_dma_req(spi, 0, 0);
}

319 320 321
static void omap2_mcspi_tx_dma(struct spi_device *spi,
				struct spi_transfer *xfer,
				struct dma_slave_config cfg)
S
Samuel Ortiz 已提交
322 323 324
{
	struct omap2_mcspi	*mcspi;
	struct omap2_mcspi_dma  *mcspi_dma;
325
	unsigned int		count;
S
Samuel Ortiz 已提交
326 327 328

	mcspi = spi_master_get_devdata(spi->master);
	mcspi_dma = &mcspi->dma_channels[spi->chip_select];
329
	count = xfer->len;
S
Samuel Ortiz 已提交
330

331
	if (mcspi_dma->dma_tx) {
332 333 334 335 336 337 338 339 340 341
		struct dma_async_tx_descriptor *tx;
		struct scatterlist sg;

		dmaengine_slave_config(mcspi_dma->dma_tx, &cfg);

		sg_init_table(&sg, 1);
		sg_dma_address(&sg) = xfer->tx_dma;
		sg_dma_len(&sg) = xfer->len;

		tx = dmaengine_prep_slave_sg(mcspi_dma->dma_tx, &sg, 1,
342
		DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
343 344 345 346 347 348 349 350
		if (tx) {
			tx->callback = omap2_mcspi_tx_callback;
			tx->callback_param = spi;
			dmaengine_submit(tx);
		} else {
			/* FIXME: fall back to PIO? */
		}
	}
351 352 353 354
	dma_async_issue_pending(mcspi_dma->dma_tx);
	omap2_mcspi_set_dma_req(spi, 0, 1);

}
355

356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
static unsigned
omap2_mcspi_rx_dma(struct spi_device *spi, struct spi_transfer *xfer,
				struct dma_slave_config cfg,
				unsigned es)
{
	struct omap2_mcspi	*mcspi;
	struct omap2_mcspi_dma  *mcspi_dma;
	unsigned int		count;
	u32			l;
	int			elements = 0;
	int			word_len, element_count;
	struct omap2_mcspi_cs	*cs = spi->controller_state;
	mcspi = spi_master_get_devdata(spi->master);
	mcspi_dma = &mcspi->dma_channels[spi->chip_select];
	count = xfer->len;
	word_len = cs->word_len;
	l = mcspi_cached_chconf0(spi);
373

374 375 376 377 378 379 380 381
	if (word_len <= 8)
		element_count = count;
	else if (word_len <= 16)
		element_count = count >> 1;
	else /* word_len <= 32 */
		element_count = count >> 2;

	if (mcspi_dma->dma_rx) {
382 383 384 385 386 387 388 389 390 391 392 393 394 395
		struct dma_async_tx_descriptor *tx;
		struct scatterlist sg;
		size_t len = xfer->len - es;

		dmaengine_slave_config(mcspi_dma->dma_rx, &cfg);

		if (l & OMAP2_MCSPI_CHCONF_TURBO)
			len -= es;

		sg_init_table(&sg, 1);
		sg_dma_address(&sg) = xfer->rx_dma;
		sg_dma_len(&sg) = len;

		tx = dmaengine_prep_slave_sg(mcspi_dma->dma_rx, &sg, 1,
396 397
				DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT |
				DMA_CTRL_ACK);
398 399 400 401 402
		if (tx) {
			tx->callback = omap2_mcspi_rx_callback;
			tx->callback_param = spi;
			dmaengine_submit(tx);
		} else {
403
				/* FIXME: fall back to PIO? */
404
		}
S
Samuel Ortiz 已提交
405 406
	}

407 408
	dma_async_issue_pending(mcspi_dma->dma_rx);
	omap2_mcspi_set_dma_req(spi, 1, 1);
409

410 411 412 413
	wait_for_completion(&mcspi_dma->dma_rx_completion);
	dma_unmap_single(mcspi->dev, xfer->rx_dma, count,
			 DMA_FROM_DEVICE);
	omap2_mcspi_set_enable(spi, 0);
414

415
	elements = element_count - 1;
416

417 418
	if (l & OMAP2_MCSPI_CHCONF_TURBO) {
		elements--;
419

E
Eero Nurkkala 已提交
420
		if (likely(mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHSTAT0)
421
				   & OMAP2_MCSPI_CHSTAT_RXS)) {
E
Eero Nurkkala 已提交
422 423 424 425
			u32 w;

			w = mcspi_read_cs_reg(spi, OMAP2_MCSPI_RX0);
			if (word_len <= 8)
426
				((u8 *)xfer->rx_buf)[elements++] = w;
E
Eero Nurkkala 已提交
427
			else if (word_len <= 16)
428
				((u16 *)xfer->rx_buf)[elements++] = w;
E
Eero Nurkkala 已提交
429
			else /* word_len <= 32 */
430
				((u32 *)xfer->rx_buf)[elements++] = w;
E
Eero Nurkkala 已提交
431
		} else {
432 433 434 435 436 437
			dev_err(&spi->dev, "DMA RX penultimate word empty");
			count -= (word_len <= 8)  ? 2 :
				(word_len <= 16) ? 4 :
				/* word_len <= 32 */ 8;
			omap2_mcspi_set_enable(spi, 1);
			return count;
E
Eero Nurkkala 已提交
438
		}
S
Samuel Ortiz 已提交
439
	}
440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473
	if (likely(mcspi_read_cs_reg(spi, OMAP2_MCSPI_CHSTAT0)
				& OMAP2_MCSPI_CHSTAT_RXS)) {
		u32 w;

		w = mcspi_read_cs_reg(spi, OMAP2_MCSPI_RX0);
		if (word_len <= 8)
			((u8 *)xfer->rx_buf)[elements] = w;
		else if (word_len <= 16)
			((u16 *)xfer->rx_buf)[elements] = w;
		else /* word_len <= 32 */
			((u32 *)xfer->rx_buf)[elements] = w;
	} else {
		dev_err(&spi->dev, "DMA RX last word empty");
		count -= (word_len <= 8)  ? 1 :
			 (word_len <= 16) ? 2 :
		       /* word_len <= 32 */ 4;
	}
	omap2_mcspi_set_enable(spi, 1);
	return count;
}

static unsigned
omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
{
	struct omap2_mcspi	*mcspi;
	struct omap2_mcspi_cs	*cs = spi->controller_state;
	struct omap2_mcspi_dma  *mcspi_dma;
	unsigned int		count;
	u32			l;
	u8			*rx;
	const u8		*tx;
	struct dma_slave_config	cfg;
	enum dma_slave_buswidth width;
	unsigned es;
474
	void __iomem		*chstat_reg;
475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508

	mcspi = spi_master_get_devdata(spi->master);
	mcspi_dma = &mcspi->dma_channels[spi->chip_select];
	l = mcspi_cached_chconf0(spi);


	if (cs->word_len <= 8) {
		width = DMA_SLAVE_BUSWIDTH_1_BYTE;
		es = 1;
	} else if (cs->word_len <= 16) {
		width = DMA_SLAVE_BUSWIDTH_2_BYTES;
		es = 2;
	} else {
		width = DMA_SLAVE_BUSWIDTH_4_BYTES;
		es = 4;
	}

	memset(&cfg, 0, sizeof(cfg));
	cfg.src_addr = cs->phys + OMAP2_MCSPI_RX0;
	cfg.dst_addr = cs->phys + OMAP2_MCSPI_TX0;
	cfg.src_addr_width = width;
	cfg.dst_addr_width = width;
	cfg.src_maxburst = 1;
	cfg.dst_maxburst = 1;

	rx = xfer->rx_buf;
	tx = xfer->tx_buf;

	count = xfer->len;

	if (tx != NULL)
		omap2_mcspi_tx_dma(spi, xfer, cfg);

	if (rx != NULL)
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
		count = omap2_mcspi_rx_dma(spi, xfer, cfg, es);

	if (tx != NULL) {
		chstat_reg = cs->base + OMAP2_MCSPI_CHSTAT0;
		wait_for_completion(&mcspi_dma->dma_tx_completion);
		dma_unmap_single(mcspi->dev, xfer->tx_dma, xfer->len,
				 DMA_TO_DEVICE);

		/* for TX_ONLY mode, be sure all words have shifted out */
		if (rx == NULL) {
			if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_TXS) < 0)
				dev_err(&spi->dev, "TXS timed out\n");
			else if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_EOT) < 0)
				dev_err(&spi->dev, "EOT timed out\n");
		}
	}
S
Samuel Ortiz 已提交
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
	return count;
}

static unsigned
omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
{
	struct omap2_mcspi	*mcspi;
	struct omap2_mcspi_cs	*cs = spi->controller_state;
	unsigned int		count, c;
	u32			l;
	void __iomem		*base = cs->base;
	void __iomem		*tx_reg;
	void __iomem		*rx_reg;
	void __iomem		*chstat_reg;
	int			word_len;

	mcspi = spi_master_get_devdata(spi->master);
	count = xfer->len;
	c = count;
	word_len = cs->word_len;

H
Hemanth V 已提交
548
	l = mcspi_cached_chconf0(spi);
S
Samuel Ortiz 已提交
549 550 551 552 553 554 555

	/* We store the pre-calculated register addresses on stack to speed
	 * up the transfer loop. */
	tx_reg		= base + OMAP2_MCSPI_TX0;
	rx_reg		= base + OMAP2_MCSPI_RX0;
	chstat_reg	= base + OMAP2_MCSPI_CHSTAT0;

556 557 558
	if (c < (word_len>>3))
		return 0;

S
Samuel Ortiz 已提交
559 560 561 562 563 564 565 566
	if (word_len <= 8) {
		u8		*rx;
		const u8	*tx;

		rx = xfer->rx_buf;
		tx = xfer->tx_buf;

		do {
K
Kalle Valo 已提交
567
			c -= 1;
S
Samuel Ortiz 已提交
568 569 570 571 572 573
			if (tx != NULL) {
				if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_TXS) < 0) {
					dev_err(&spi->dev, "TXS timed out\n");
					goto out;
				}
574
				dev_vdbg(&spi->dev, "write-%d %02x\n",
S
Samuel Ortiz 已提交
575 576 577 578 579 580 581 582 583
						word_len, *tx);
				__raw_writel(*tx++, tx_reg);
			}
			if (rx != NULL) {
				if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_RXS) < 0) {
					dev_err(&spi->dev, "RXS timed out\n");
					goto out;
				}
584 585 586 587 588

				if (c == 1 && tx == NULL &&
				    (l & OMAP2_MCSPI_CHCONF_TURBO)) {
					omap2_mcspi_set_enable(spi, 0);
					*rx++ = __raw_readl(rx_reg);
589
					dev_vdbg(&spi->dev, "read-%d %02x\n",
590 591 592 593 594 595 596 597 598 599 600 601
						    word_len, *(rx - 1));
					if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_RXS) < 0) {
						dev_err(&spi->dev,
							"RXS timed out\n");
						goto out;
					}
					c = 0;
				} else if (c == 0 && tx == NULL) {
					omap2_mcspi_set_enable(spi, 0);
				}

S
Samuel Ortiz 已提交
602
				*rx++ = __raw_readl(rx_reg);
603
				dev_vdbg(&spi->dev, "read-%d %02x\n",
S
Samuel Ortiz 已提交
604 605
						word_len, *(rx - 1));
			}
606
		} while (c);
S
Samuel Ortiz 已提交
607 608 609 610 611 612 613
	} else if (word_len <= 16) {
		u16		*rx;
		const u16	*tx;

		rx = xfer->rx_buf;
		tx = xfer->tx_buf;
		do {
K
Kalle Valo 已提交
614
			c -= 2;
S
Samuel Ortiz 已提交
615 616 617 618 619 620
			if (tx != NULL) {
				if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_TXS) < 0) {
					dev_err(&spi->dev, "TXS timed out\n");
					goto out;
				}
621
				dev_vdbg(&spi->dev, "write-%d %04x\n",
S
Samuel Ortiz 已提交
622 623 624 625 626 627 628 629 630
						word_len, *tx);
				__raw_writel(*tx++, tx_reg);
			}
			if (rx != NULL) {
				if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_RXS) < 0) {
					dev_err(&spi->dev, "RXS timed out\n");
					goto out;
				}
631 632 633 634 635

				if (c == 2 && tx == NULL &&
				    (l & OMAP2_MCSPI_CHCONF_TURBO)) {
					omap2_mcspi_set_enable(spi, 0);
					*rx++ = __raw_readl(rx_reg);
636
					dev_vdbg(&spi->dev, "read-%d %04x\n",
637 638 639 640 641 642 643 644 645 646 647 648
						    word_len, *(rx - 1));
					if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_RXS) < 0) {
						dev_err(&spi->dev,
							"RXS timed out\n");
						goto out;
					}
					c = 0;
				} else if (c == 0 && tx == NULL) {
					omap2_mcspi_set_enable(spi, 0);
				}

S
Samuel Ortiz 已提交
649
				*rx++ = __raw_readl(rx_reg);
650
				dev_vdbg(&spi->dev, "read-%d %04x\n",
S
Samuel Ortiz 已提交
651 652
						word_len, *(rx - 1));
			}
653
		} while (c >= 2);
S
Samuel Ortiz 已提交
654 655 656 657 658 659 660
	} else if (word_len <= 32) {
		u32		*rx;
		const u32	*tx;

		rx = xfer->rx_buf;
		tx = xfer->tx_buf;
		do {
K
Kalle Valo 已提交
661
			c -= 4;
S
Samuel Ortiz 已提交
662 663 664 665 666 667
			if (tx != NULL) {
				if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_TXS) < 0) {
					dev_err(&spi->dev, "TXS timed out\n");
					goto out;
				}
668
				dev_vdbg(&spi->dev, "write-%d %08x\n",
S
Samuel Ortiz 已提交
669 670 671 672 673 674 675 676 677
						word_len, *tx);
				__raw_writel(*tx++, tx_reg);
			}
			if (rx != NULL) {
				if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_RXS) < 0) {
					dev_err(&spi->dev, "RXS timed out\n");
					goto out;
				}
678 679 680 681 682

				if (c == 4 && tx == NULL &&
				    (l & OMAP2_MCSPI_CHCONF_TURBO)) {
					omap2_mcspi_set_enable(spi, 0);
					*rx++ = __raw_readl(rx_reg);
683
					dev_vdbg(&spi->dev, "read-%d %08x\n",
684 685 686 687 688 689 690 691 692 693 694 695
						    word_len, *(rx - 1));
					if (mcspi_wait_for_reg_bit(chstat_reg,
						OMAP2_MCSPI_CHSTAT_RXS) < 0) {
						dev_err(&spi->dev,
							"RXS timed out\n");
						goto out;
					}
					c = 0;
				} else if (c == 0 && tx == NULL) {
					omap2_mcspi_set_enable(spi, 0);
				}

S
Samuel Ortiz 已提交
696
				*rx++ = __raw_readl(rx_reg);
697
				dev_vdbg(&spi->dev, "read-%d %08x\n",
S
Samuel Ortiz 已提交
698 699
						word_len, *(rx - 1));
			}
700
		} while (c >= 4);
S
Samuel Ortiz 已提交
701 702 703 704 705 706 707 708 709 710
	}

	/* for TX_ONLY mode, be sure all words have shifted out */
	if (xfer->rx_buf == NULL) {
		if (mcspi_wait_for_reg_bit(chstat_reg,
				OMAP2_MCSPI_CHSTAT_TXS) < 0) {
			dev_err(&spi->dev, "TXS timed out\n");
		} else if (mcspi_wait_for_reg_bit(chstat_reg,
				OMAP2_MCSPI_CHSTAT_EOT) < 0)
			dev_err(&spi->dev, "EOT timed out\n");
711 712 713 714 715 716

		/* disable chan to purge rx datas received in TX_ONLY transfer,
		 * otherwise these rx datas will affect the direct following
		 * RX_ONLY transfer.
		 */
		omap2_mcspi_set_enable(spi, 0);
S
Samuel Ortiz 已提交
717 718
	}
out:
719
	omap2_mcspi_set_enable(spi, 1);
S
Samuel Ortiz 已提交
720 721 722
	return count - c;
}

723 724 725 726 727 728 729 730 731 732 733
static u32 omap2_mcspi_calc_divisor(u32 speed_hz)
{
	u32 div;

	for (div = 0; div < 15; div++)
		if (speed_hz >= (OMAP2_MCSPI_MAX_FREQ >> div))
			return div;

	return 15;
}

S
Samuel Ortiz 已提交
734 735 736 737 738 739
/* called only when no transfer is active to this device */
static int omap2_mcspi_setup_transfer(struct spi_device *spi,
		struct spi_transfer *t)
{
	struct omap2_mcspi_cs *cs = spi->controller_state;
	struct omap2_mcspi *mcspi;
H
Hemanth V 已提交
740
	struct spi_master *spi_cntrl;
S
Samuel Ortiz 已提交
741 742
	u32 l = 0, div = 0;
	u8 word_len = spi->bits_per_word;
743
	u32 speed_hz = spi->max_speed_hz;
S
Samuel Ortiz 已提交
744 745

	mcspi = spi_master_get_devdata(spi->master);
H
Hemanth V 已提交
746
	spi_cntrl = mcspi->master;
S
Samuel Ortiz 已提交
747 748 749 750 751 752

	if (t != NULL && t->bits_per_word)
		word_len = t->bits_per_word;

	cs->word_len = word_len;

753 754 755
	if (t && t->speed_hz)
		speed_hz = t->speed_hz;

756 757
	speed_hz = min_t(u32, speed_hz, OMAP2_MCSPI_MAX_FREQ);
	div = omap2_mcspi_calc_divisor(speed_hz);
S
Samuel Ortiz 已提交
758

H
Hemanth V 已提交
759
	l = mcspi_cached_chconf0(spi);
S
Samuel Ortiz 已提交
760 761 762 763

	/* standard 4-wire master mode:  SCK, MOSI/out, MISO/in, nCS
	 * REVISIT: this controller could support SPI_3WIRE mode.
	 */
764
	if (mcspi->pin_dir == MCSPI_PINDIR_D0_IN_D1_OUT) {
765 766 767 768 769 770 771 772
		l &= ~OMAP2_MCSPI_CHCONF_IS;
		l &= ~OMAP2_MCSPI_CHCONF_DPE1;
		l |= OMAP2_MCSPI_CHCONF_DPE0;
	} else {
		l |= OMAP2_MCSPI_CHCONF_IS;
		l |= OMAP2_MCSPI_CHCONF_DPE1;
		l &= ~OMAP2_MCSPI_CHCONF_DPE0;
	}
S
Samuel Ortiz 已提交
773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797

	/* wordlength */
	l &= ~OMAP2_MCSPI_CHCONF_WL_MASK;
	l |= (word_len - 1) << 7;

	/* set chipselect polarity; manage with FORCE */
	if (!(spi->mode & SPI_CS_HIGH))
		l |= OMAP2_MCSPI_CHCONF_EPOL;	/* active-low; normal */
	else
		l &= ~OMAP2_MCSPI_CHCONF_EPOL;

	/* set clock divisor */
	l &= ~OMAP2_MCSPI_CHCONF_CLKD_MASK;
	l |= div << 2;

	/* set SPI mode 0..3 */
	if (spi->mode & SPI_CPOL)
		l |= OMAP2_MCSPI_CHCONF_POL;
	else
		l &= ~OMAP2_MCSPI_CHCONF_POL;
	if (spi->mode & SPI_CPHA)
		l |= OMAP2_MCSPI_CHCONF_PHA;
	else
		l &= ~OMAP2_MCSPI_CHCONF_PHA;

H
Hemanth V 已提交
798
	mcspi_write_chconf0(spi, l);
S
Samuel Ortiz 已提交
799 800

	dev_dbg(&spi->dev, "setup: speed %d, sample %s edge, clk %s\n",
801
			OMAP2_MCSPI_MAX_FREQ >> div,
S
Samuel Ortiz 已提交
802 803 804 805 806 807 808 809 810 811 812
			(spi->mode & SPI_CPHA) ? "trailing" : "leading",
			(spi->mode & SPI_CPOL) ? "inverted" : "normal");

	return 0;
}

static int omap2_mcspi_request_dma(struct spi_device *spi)
{
	struct spi_master	*master = spi->master;
	struct omap2_mcspi	*mcspi;
	struct omap2_mcspi_dma	*mcspi_dma;
813 814
	dma_cap_mask_t mask;
	unsigned sig;
S
Samuel Ortiz 已提交
815 816 817 818

	mcspi = spi_master_get_devdata(master);
	mcspi_dma = mcspi->dma_channels + spi->chip_select;

819 820 821 822 823 824 825 826 827
	init_completion(&mcspi_dma->dma_rx_completion);
	init_completion(&mcspi_dma->dma_tx_completion);

	dma_cap_zero(mask);
	dma_cap_set(DMA_SLAVE, mask);
	sig = mcspi_dma->dma_rx_sync_dev;
	mcspi_dma->dma_rx = dma_request_channel(mask, omap_dma_filter_fn, &sig);
	if (!mcspi_dma->dma_rx) {
		dev_err(&spi->dev, "no RX DMA engine channel for McSPI\n");
S
Samuel Ortiz 已提交
828 829 830
		return -EAGAIN;
	}

831 832 833 834 835 836
	sig = mcspi_dma->dma_tx_sync_dev;
	mcspi_dma->dma_tx = dma_request_channel(mask, omap_dma_filter_fn, &sig);
	if (!mcspi_dma->dma_tx) {
		dev_err(&spi->dev, "no TX DMA engine channel for McSPI\n");
		dma_release_channel(mcspi_dma->dma_rx);
		mcspi_dma->dma_rx = NULL;
S
Samuel Ortiz 已提交
837 838 839 840 841 842 843 844 845
		return -EAGAIN;
	}

	return 0;
}

static int omap2_mcspi_setup(struct spi_device *spi)
{
	int			ret;
846 847
	struct omap2_mcspi	*mcspi = spi_master_get_devdata(spi->master);
	struct omap2_mcspi_regs	*ctx = &mcspi->ctx;
S
Samuel Ortiz 已提交
848 849 850
	struct omap2_mcspi_dma	*mcspi_dma;
	struct omap2_mcspi_cs	*cs = spi->controller_state;

851
	if (spi->bits_per_word < 4 || spi->bits_per_word > 32) {
S
Samuel Ortiz 已提交
852 853 854 855 856 857 858 859
		dev_dbg(&spi->dev, "setup: unsupported %d bit words\n",
			spi->bits_per_word);
		return -EINVAL;
	}

	mcspi_dma = &mcspi->dma_channels[spi->chip_select];

	if (!cs) {
860
		cs = kzalloc(sizeof *cs, GFP_KERNEL);
S
Samuel Ortiz 已提交
861 862 863
		if (!cs)
			return -ENOMEM;
		cs->base = mcspi->base + spi->chip_select * 0x14;
864
		cs->phys = mcspi->phys + spi->chip_select * 0x14;
H
Hemanth V 已提交
865
		cs->chconf0 = 0;
S
Samuel Ortiz 已提交
866
		spi->controller_state = cs;
T
Tero Kristo 已提交
867
		/* Link this to context save list */
868
		list_add_tail(&cs->node, &ctx->cs);
S
Samuel Ortiz 已提交
869 870
	}

871
	if (!mcspi_dma->dma_rx || !mcspi_dma->dma_tx) {
S
Samuel Ortiz 已提交
872 873 874 875 876
		ret = omap2_mcspi_request_dma(spi);
		if (ret < 0)
			return ret;
	}

877
	ret = pm_runtime_get_sync(mcspi->dev);
878 879
	if (ret < 0)
		return ret;
H
Hemanth V 已提交
880

K
Kyungmin Park 已提交
881
	ret = omap2_mcspi_setup_transfer(spi, NULL);
882 883
	pm_runtime_mark_last_busy(mcspi->dev);
	pm_runtime_put_autosuspend(mcspi->dev);
S
Samuel Ortiz 已提交
884 885 886 887 888 889 890 891

	return ret;
}

static void omap2_mcspi_cleanup(struct spi_device *spi)
{
	struct omap2_mcspi	*mcspi;
	struct omap2_mcspi_dma	*mcspi_dma;
T
Tero Kristo 已提交
892
	struct omap2_mcspi_cs	*cs;
S
Samuel Ortiz 已提交
893 894 895

	mcspi = spi_master_get_devdata(spi->master);

896 897 898 899
	if (spi->controller_state) {
		/* Unlink controller state from context save list */
		cs = spi->controller_state;
		list_del(&cs->node);
T
Tero Kristo 已提交
900

901
		kfree(cs);
902
	}
S
Samuel Ortiz 已提交
903

904 905 906
	if (spi->chip_select < spi->master->num_chipselect) {
		mcspi_dma = &mcspi->dma_channels[spi->chip_select];

907 908 909
		if (mcspi_dma->dma_rx) {
			dma_release_channel(mcspi_dma->dma_rx);
			mcspi_dma->dma_rx = NULL;
910
		}
911 912 913
		if (mcspi_dma->dma_tx) {
			dma_release_channel(mcspi_dma->dma_tx);
			mcspi_dma->dma_tx = NULL;
914
		}
S
Samuel Ortiz 已提交
915 916 917
	}
}

918
static void omap2_mcspi_work(struct omap2_mcspi *mcspi, struct spi_message *m)
S
Samuel Ortiz 已提交
919 920 921
{

	/* We only enable one channel at a time -- the one whose message is
922
	 * -- although this controller would gladly
S
Samuel Ortiz 已提交
923 924 925 926 927
	 * arbitrate among multiple channels.  This corresponds to "single
	 * channel" master mode.  As a side effect, we need to manage the
	 * chipselect with the FORCE bit ... CS != channel enable.
	 */

928 929 930 931 932 933 934 935
	struct spi_device		*spi;
	struct spi_transfer		*t = NULL;
	int				cs_active = 0;
	struct omap2_mcspi_cs		*cs;
	struct omap2_mcspi_device_config *cd;
	int				par_override = 0;
	int				status = 0;
	u32				chconf;
S
Samuel Ortiz 已提交
936

937 938 939
	spi = m->spi;
	cs = spi->controller_state;
	cd = spi->controller_data;
S
Samuel Ortiz 已提交
940

941 942 943 944 945 946 947 948 949 950 951 952 953 954
	omap2_mcspi_set_enable(spi, 1);
	list_for_each_entry(t, &m->transfers, transfer_list) {
		if (t->tx_buf == NULL && t->rx_buf == NULL && t->len) {
			status = -EINVAL;
			break;
		}
		if (par_override || t->speed_hz || t->bits_per_word) {
			par_override = 1;
			status = omap2_mcspi_setup_transfer(spi, t);
			if (status < 0)
				break;
			if (!t->speed_hz && !t->bits_per_word)
				par_override = 0;
		}
955

956 957 958 959
		if (!cs_active) {
			omap2_mcspi_force_cs(spi, 1);
			cs_active = 1;
		}
960

961 962 963
		chconf = mcspi_cached_chconf0(spi);
		chconf &= ~OMAP2_MCSPI_CHCONF_TRM_MASK;
		chconf &= ~OMAP2_MCSPI_CHCONF_TURBO;
S
Samuel Ortiz 已提交
964

965 966 967 968
		if (t->tx_buf == NULL)
			chconf |= OMAP2_MCSPI_CHCONF_TRM_RX_ONLY;
		else if (t->rx_buf == NULL)
			chconf |= OMAP2_MCSPI_CHCONF_TRM_TX_ONLY;
S
Samuel Ortiz 已提交
969

970 971 972 973 974
		if (cd && cd->turbo_mode && t->tx_buf == NULL) {
			/* Turbo mode is for more than one word */
			if (t->len > ((cs->word_len + 7) >> 3))
				chconf |= OMAP2_MCSPI_CHCONF_TURBO;
		}
S
Samuel Ortiz 已提交
975

976
		mcspi_write_chconf0(spi, chconf);
S
Samuel Ortiz 已提交
977

978 979 980 981 982 983 984
		if (t->len) {
			unsigned	count;

			/* RX_ONLY mode needs dummy data in TX reg */
			if (t->tx_buf == NULL)
				__raw_writel(0, cs->base
						+ OMAP2_MCSPI_TX0);
S
Samuel Ortiz 已提交
985

986 987 988 989 990
			if (m->is_dma_mapped || t->len >= DMA_MIN_BYTES)
				count = omap2_mcspi_txrx_dma(spi, t);
			else
				count = omap2_mcspi_txrx_pio(spi, t);
			m->actual_length += count;
S
Samuel Ortiz 已提交
991

992 993 994
			if (count != t->len) {
				status = -EIO;
				break;
S
Samuel Ortiz 已提交
995 996 997
			}
		}

998 999
		if (t->delay_usecs)
			udelay(t->delay_usecs);
S
Samuel Ortiz 已提交
1000

1001 1002
		/* ignore the "leave it on after last xfer" hint */
		if (t->cs_change) {
S
Samuel Ortiz 已提交
1003
			omap2_mcspi_force_cs(spi, 0);
1004 1005 1006 1007 1008 1009 1010 1011
			cs_active = 0;
		}
	}
	/* Restore defaults if they were overriden */
	if (par_override) {
		par_override = 0;
		status = omap2_mcspi_setup_transfer(spi, NULL);
	}
S
Samuel Ortiz 已提交
1012

1013 1014
	if (cs_active)
		omap2_mcspi_force_cs(spi, 0);
S
Samuel Ortiz 已提交
1015

1016
	omap2_mcspi_set_enable(spi, 0);
S
Samuel Ortiz 已提交
1017

1018
	m->status = status;
1019

S
Samuel Ortiz 已提交
1020 1021
}

1022
static int omap2_mcspi_transfer_one_message(struct spi_master *master,
1023
		struct spi_message *m)
S
Samuel Ortiz 已提交
1024 1025 1026 1027
{
	struct omap2_mcspi	*mcspi;
	struct spi_transfer	*t;

1028
	mcspi = spi_master_get_devdata(master);
S
Samuel Ortiz 已提交
1029 1030 1031 1032
	m->actual_length = 0;
	m->status = 0;

	/* reject invalid messages and transfers */
1033
	if (list_empty(&m->transfers))
S
Samuel Ortiz 已提交
1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
		return -EINVAL;
	list_for_each_entry(t, &m->transfers, transfer_list) {
		const void	*tx_buf = t->tx_buf;
		void		*rx_buf = t->rx_buf;
		unsigned	len = t->len;

		if (t->speed_hz > OMAP2_MCSPI_MAX_FREQ
				|| (len && !(rx_buf || tx_buf))
				|| (t->bits_per_word &&
					(  t->bits_per_word < 4
1044
					   || t->bits_per_word > 32))) {
1045
			dev_dbg(mcspi->dev, "transfer: %d Hz, %d %s%s, %d bpw\n",
S
Samuel Ortiz 已提交
1046 1047 1048 1049 1050 1051 1052
					t->speed_hz,
					len,
					tx_buf ? "tx" : "",
					rx_buf ? "rx" : "",
					t->bits_per_word);
			return -EINVAL;
		}
1053
		if (t->speed_hz && t->speed_hz < (OMAP2_MCSPI_MAX_FREQ >> 15)) {
1054
			dev_dbg(mcspi->dev, "speed_hz %d below minimum %d Hz\n",
1055 1056
					t->speed_hz,
					OMAP2_MCSPI_MAX_FREQ >> 15);
S
Samuel Ortiz 已提交
1057 1058 1059 1060 1061 1062 1063
			return -EINVAL;
		}

		if (m->is_dma_mapped || len < DMA_MIN_BYTES)
			continue;

		if (tx_buf != NULL) {
1064
			t->tx_dma = dma_map_single(mcspi->dev, (void *) tx_buf,
S
Samuel Ortiz 已提交
1065
					len, DMA_TO_DEVICE);
1066 1067
			if (dma_mapping_error(mcspi->dev, t->tx_dma)) {
				dev_dbg(mcspi->dev, "dma %cX %d bytes error\n",
S
Samuel Ortiz 已提交
1068 1069 1070 1071 1072
						'T', len);
				return -EINVAL;
			}
		}
		if (rx_buf != NULL) {
1073
			t->rx_dma = dma_map_single(mcspi->dev, rx_buf, t->len,
S
Samuel Ortiz 已提交
1074
					DMA_FROM_DEVICE);
1075 1076
			if (dma_mapping_error(mcspi->dev, t->rx_dma)) {
				dev_dbg(mcspi->dev, "dma %cX %d bytes error\n",
S
Samuel Ortiz 已提交
1077 1078
						'R', len);
				if (tx_buf != NULL)
1079
					dma_unmap_single(mcspi->dev, t->tx_dma,
S
Samuel Ortiz 已提交
1080 1081 1082 1083 1084 1085
							len, DMA_TO_DEVICE);
				return -EINVAL;
			}
		}
	}

1086 1087
	omap2_mcspi_work(mcspi, m);
	spi_finalize_current_message(master);
S
Samuel Ortiz 已提交
1088 1089 1090
	return 0;
}

1091
static int omap2_mcspi_master_setup(struct omap2_mcspi *mcspi)
S
Samuel Ortiz 已提交
1092 1093
{
	struct spi_master	*master = mcspi->master;
1094 1095
	struct omap2_mcspi_regs	*ctx = &mcspi->ctx;
	int			ret = 0;
S
Samuel Ortiz 已提交
1096

1097
	ret = pm_runtime_get_sync(mcspi->dev);
1098 1099
	if (ret < 0)
		return ret;
1100

1101
	mcspi_write_reg(master, OMAP2_MCSPI_WAKEUPENABLE,
1102
			OMAP2_MCSPI_WAKEUPENABLE_WKEN);
1103
	ctx->wakeupenable = OMAP2_MCSPI_WAKEUPENABLE_WKEN;
S
Samuel Ortiz 已提交
1104 1105

	omap2_mcspi_set_master_mode(master);
1106 1107
	pm_runtime_mark_last_busy(mcspi->dev);
	pm_runtime_put_autosuspend(mcspi->dev);
S
Samuel Ortiz 已提交
1108 1109 1110
	return 0;
}

1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122
static int omap_mcspi_runtime_resume(struct device *dev)
{
	struct omap2_mcspi	*mcspi;
	struct spi_master	*master;

	master = dev_get_drvdata(dev);
	mcspi = spi_master_get_devdata(master);
	omap2_mcspi_restore_ctx(mcspi);

	return 0;
}

1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
static struct omap2_mcspi_platform_config omap2_pdata = {
	.regs_offset = 0,
};

static struct omap2_mcspi_platform_config omap4_pdata = {
	.regs_offset = OMAP4_MCSPI_REG_OFFSET,
};

static const struct of_device_id omap_mcspi_of_match[] = {
	{
		.compatible = "ti,omap2-mcspi",
		.data = &omap2_pdata,
	},
	{
		.compatible = "ti,omap4-mcspi",
		.data = &omap4_pdata,
	},
	{ },
};
MODULE_DEVICE_TABLE(of, omap_mcspi_of_match);
G
Girish 已提交
1143

1144
static int omap2_mcspi_probe(struct platform_device *pdev)
S
Samuel Ortiz 已提交
1145 1146
{
	struct spi_master	*master;
1147
	const struct omap2_mcspi_platform_config *pdata;
S
Samuel Ortiz 已提交
1148 1149 1150
	struct omap2_mcspi	*mcspi;
	struct resource		*r;
	int			status = 0, i;
1151 1152 1153 1154
	u32			regs_offset = 0;
	static int		bus_num = 1;
	struct device_node	*node = pdev->dev.of_node;
	const struct of_device_id *match;
1155
	struct pinctrl *pinctrl;
S
Samuel Ortiz 已提交
1156 1157 1158 1159 1160 1161 1162

	master = spi_alloc_master(&pdev->dev, sizeof *mcspi);
	if (master == NULL) {
		dev_dbg(&pdev->dev, "master allocation failed\n");
		return -ENOMEM;
	}

1163 1164 1165
	/* the spi->mode bits understood by this driver: */
	master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH;

S
Samuel Ortiz 已提交
1166
	master->setup = omap2_mcspi_setup;
1167 1168 1169
	master->prepare_transfer_hardware = omap2_prepare_transfer;
	master->unprepare_transfer_hardware = omap2_unprepare_transfer;
	master->transfer_one_message = omap2_mcspi_transfer_one_message;
S
Samuel Ortiz 已提交
1170
	master->cleanup = omap2_mcspi_cleanup;
1171 1172
	master->dev.of_node = node;

1173 1174 1175 1176 1177
	dev_set_drvdata(&pdev->dev, master);

	mcspi = spi_master_get_devdata(master);
	mcspi->master = master;

1178 1179 1180 1181 1182 1183 1184 1185
	match = of_match_device(omap_mcspi_of_match, &pdev->dev);
	if (match) {
		u32 num_cs = 1; /* default number of chipselect */
		pdata = match->data;

		of_property_read_u32(node, "ti,spi-num-cs", &num_cs);
		master->num_chipselect = num_cs;
		master->bus_num = bus_num++;
1186 1187
		if (of_get_property(node, "ti,pindir-d0-out-d1-in", NULL))
			mcspi->pin_dir = MCSPI_PINDIR_D0_OUT_D1_IN;
1188 1189 1190 1191 1192
	} else {
		pdata = pdev->dev.platform_data;
		master->num_chipselect = pdata->num_cs;
		if (pdev->id != -1)
			master->bus_num = pdev->id;
1193
		mcspi->pin_dir = pdata->pin_dir;
1194 1195
	}
	regs_offset = pdata->regs_offset;
S
Samuel Ortiz 已提交
1196 1197 1198 1199

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (r == NULL) {
		status = -ENODEV;
S
Shubhrajyoti D 已提交
1200
		goto free_master;
S
Samuel Ortiz 已提交
1201
	}
1202

1203 1204
	r->start += regs_offset;
	r->end += regs_offset;
1205
	mcspi->phys = r->start;
S
Samuel Ortiz 已提交
1206

1207
	mcspi->base = devm_request_and_ioremap(&pdev->dev, r);
1208 1209 1210
	if (!mcspi->base) {
		dev_dbg(&pdev->dev, "can't ioremap MCSPI\n");
		status = -ENOMEM;
1211
		goto free_master;
1212
	}
S
Samuel Ortiz 已提交
1213

1214
	mcspi->dev = &pdev->dev;
S
Samuel Ortiz 已提交
1215

1216
	INIT_LIST_HEAD(&mcspi->ctx.cs);
S
Samuel Ortiz 已提交
1217 1218 1219 1220 1221 1222

	mcspi->dma_channels = kcalloc(master->num_chipselect,
			sizeof(struct omap2_mcspi_dma),
			GFP_KERNEL);

	if (mcspi->dma_channels == NULL)
1223
		goto free_master;
S
Samuel Ortiz 已提交
1224

1225 1226 1227 1228 1229 1230
	for (i = 0; i < master->num_chipselect; i++) {
		char dma_ch_name[14];
		struct resource *dma_res;

		sprintf(dma_ch_name, "rx%d", i);
		dma_res = platform_get_resource_byname(pdev, IORESOURCE_DMA,
1231
				dma_ch_name);
1232 1233 1234 1235 1236 1237 1238 1239 1240
		if (!dma_res) {
			dev_dbg(&pdev->dev, "cannot get DMA RX channel\n");
			status = -ENODEV;
			break;
		}

		mcspi->dma_channels[i].dma_rx_sync_dev = dma_res->start;
		sprintf(dma_ch_name, "tx%d", i);
		dma_res = platform_get_resource_byname(pdev, IORESOURCE_DMA,
1241
				dma_ch_name);
1242 1243 1244 1245 1246 1247 1248
		if (!dma_res) {
			dev_dbg(&pdev->dev, "cannot get DMA TX channel\n");
			status = -ENODEV;
			break;
		}

		mcspi->dma_channels[i].dma_tx_sync_dev = dma_res->start;
S
Samuel Ortiz 已提交
1249 1250
	}

S
Shubhrajyoti D 已提交
1251 1252 1253
	if (status < 0)
		goto dma_chnl_free;

1254 1255 1256
	pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
	if (IS_ERR(pinctrl))
		dev_warn(&pdev->dev,
1257
				"pins are not configured from the driver\n");
1258

1259 1260
	pm_runtime_use_autosuspend(&pdev->dev);
	pm_runtime_set_autosuspend_delay(&pdev->dev, SPI_AUTOSUSPEND_TIMEOUT);
1261 1262 1263
	pm_runtime_enable(&pdev->dev);

	if (status || omap2_mcspi_master_setup(mcspi) < 0)
S
Shubhrajyoti D 已提交
1264
		goto disable_pm;
S
Samuel Ortiz 已提交
1265 1266 1267

	status = spi_register_master(master);
	if (status < 0)
1268
		goto disable_pm;
S
Samuel Ortiz 已提交
1269 1270 1271

	return status;

S
Shubhrajyoti D 已提交
1272
disable_pm:
1273
	pm_runtime_disable(&pdev->dev);
S
Shubhrajyoti D 已提交
1274
dma_chnl_free:
1275
	kfree(mcspi->dma_channels);
S
Shubhrajyoti D 已提交
1276
free_master:
1277
	spi_master_put(master);
S
Samuel Ortiz 已提交
1278 1279 1280
	return status;
}

1281
static int omap2_mcspi_remove(struct platform_device *pdev)
S
Samuel Ortiz 已提交
1282 1283 1284 1285 1286 1287 1288 1289 1290
{
	struct spi_master	*master;
	struct omap2_mcspi	*mcspi;
	struct omap2_mcspi_dma	*dma_channels;

	master = dev_get_drvdata(&pdev->dev);
	mcspi = spi_master_get_devdata(master);
	dma_channels = mcspi->dma_channels;

1291
	pm_runtime_put_sync(mcspi->dev);
1292
	pm_runtime_disable(&pdev->dev);
S
Samuel Ortiz 已提交
1293 1294 1295 1296 1297 1298 1299

	spi_unregister_master(master);
	kfree(dma_channels);

	return 0;
}

1300 1301 1302
/* work with hotplug and coldplug */
MODULE_ALIAS("platform:omap2_mcspi");

1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
#ifdef	CONFIG_SUSPEND
/*
 * When SPI wake up from off-mode, CS is in activate state. If it was in
 * unactive state when driver was suspend, then force it to unactive state at
 * wake up.
 */
static int omap2_mcspi_resume(struct device *dev)
{
	struct spi_master	*master = dev_get_drvdata(dev);
	struct omap2_mcspi	*mcspi = spi_master_get_devdata(master);
1313 1314
	struct omap2_mcspi_regs	*ctx = &mcspi->ctx;
	struct omap2_mcspi_cs	*cs;
1315

1316
	pm_runtime_get_sync(mcspi->dev);
1317
	list_for_each_entry(cs, &ctx->cs, node) {
1318 1319 1320 1321 1322
		if ((cs->chconf0 & OMAP2_MCSPI_CHCONF_FORCE) == 0) {
			/*
			 * We need to toggle CS state for OMAP take this
			 * change in account.
			 */
1323
			cs->chconf0 |= OMAP2_MCSPI_CHCONF_FORCE;
1324
			__raw_writel(cs->chconf0, cs->base + OMAP2_MCSPI_CHCONF0);
1325
			cs->chconf0 &= ~OMAP2_MCSPI_CHCONF_FORCE;
1326 1327 1328
			__raw_writel(cs->chconf0, cs->base + OMAP2_MCSPI_CHCONF0);
		}
	}
1329 1330
	pm_runtime_mark_last_busy(mcspi->dev);
	pm_runtime_put_autosuspend(mcspi->dev);
1331 1332 1333 1334 1335 1336 1337 1338
	return 0;
}
#else
#define	omap2_mcspi_resume	NULL
#endif

static const struct dev_pm_ops omap2_mcspi_pm_ops = {
	.resume = omap2_mcspi_resume,
1339
	.runtime_resume	= omap_mcspi_runtime_resume,
1340 1341
};

S
Samuel Ortiz 已提交
1342 1343 1344 1345
static struct platform_driver omap2_mcspi_driver = {
	.driver = {
		.name =		"omap2_mcspi",
		.owner =	THIS_MODULE,
1346 1347
		.pm =		&omap2_mcspi_pm_ops,
		.of_match_table = omap_mcspi_of_match,
S
Samuel Ortiz 已提交
1348
	},
1349
	.probe =	omap2_mcspi_probe,
1350
	.remove =	omap2_mcspi_remove,
S
Samuel Ortiz 已提交
1351 1352
};

1353
module_platform_driver(omap2_mcspi_driver);
S
Samuel Ortiz 已提交
1354
MODULE_LICENSE("GPL");