spi-mpc52xx-psc.c 13.5 KB
Newer Older
Dragos Carp's avatar
Dragos Carp committed
1
/*
2
 * MPC52xx PSC in SPI mode driver.
Dragos Carp's avatar
Dragos Carp committed
3 4 5 6 7 8 9 10 11 12 13 14 15
 *
 * Maintainer: Dragos Carp
 *
 * Copyright (C) 2006 TOPTICA Photonics AG.
 *
 * 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.
 */

#include <linux/module.h>
#include <linux/init.h>
16
#include <linux/types.h>
Dragos Carp's avatar
Dragos Carp committed
17 18
#include <linux/errno.h>
#include <linux/interrupt.h>
19
#include <linux/of_address.h>
20
#include <linux/of_platform.h>
Dragos Carp's avatar
Dragos Carp committed
21 22 23 24 25 26
#include <linux/workqueue.h>
#include <linux/completion.h>
#include <linux/io.h>
#include <linux/delay.h>
#include <linux/spi/spi.h>
#include <linux/fsl_devices.h>
27
#include <linux/slab.h>
Dragos Carp's avatar
Dragos Carp committed
28 29 30 31 32 33 34 35

#include <asm/mpc52xx.h>
#include <asm/mpc52xx_psc.h>

#define MCLK 20000000 /* PSC port MClk in hz */

struct mpc52xx_psc_spi {
	/* fsl_spi_platform data */
36
	void (*cs_control)(struct spi_device *spi, bool on);
Dragos Carp's avatar
Dragos Carp committed
37 38 39 40
	u32 sysclk;

	/* driver internal data */
	struct mpc52xx_psc __iomem *psc;
41
	struct mpc52xx_psc_fifo __iomem *fifo;
Dragos Carp's avatar
Dragos Carp committed
42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106
	unsigned int irq;
	u8 bits_per_word;
	u8 busy;

	struct workqueue_struct *workqueue;
	struct work_struct work;

	struct list_head queue;
	spinlock_t lock;

	struct completion done;
};

/* controller state */
struct mpc52xx_psc_spi_cs {
	int bits_per_word;
	int speed_hz;
};

/* set clock freq, clock ramp, bits per work
 * if t is NULL then reset the values to the default values
 */
static int mpc52xx_psc_spi_transfer_setup(struct spi_device *spi,
		struct spi_transfer *t)
{
	struct mpc52xx_psc_spi_cs *cs = spi->controller_state;

	cs->speed_hz = (t && t->speed_hz)
			? t->speed_hz : spi->max_speed_hz;
	cs->bits_per_word = (t && t->bits_per_word)
			? t->bits_per_word : spi->bits_per_word;
	cs->bits_per_word = ((cs->bits_per_word + 7) / 8) * 8;
	return 0;
}

static void mpc52xx_psc_spi_activate_cs(struct spi_device *spi)
{
	struct mpc52xx_psc_spi_cs *cs = spi->controller_state;
	struct mpc52xx_psc_spi *mps = spi_master_get_devdata(spi->master);
	struct mpc52xx_psc __iomem *psc = mps->psc;
	u32 sicr;
	u16 ccr;

	sicr = in_be32(&psc->sicr);

	/* Set clock phase and polarity */
	if (spi->mode & SPI_CPHA)
		sicr |= 0x00001000;
	else
		sicr &= ~0x00001000;
	if (spi->mode & SPI_CPOL)
		sicr |= 0x00002000;
	else
		sicr &= ~0x00002000;

	if (spi->mode & SPI_LSB_FIRST)
		sicr |= 0x10000000;
	else
		sicr &= ~0x10000000;
	out_be32(&psc->sicr, sicr);

	/* Set clock frequency and bits per word
	 * Because psc->ccr is defined as 16bit register instead of 32bit
	 * just set the lower byte of BitClkDiv
	 */
107
	ccr = in_be16((u16 __iomem *)&psc->ccr);
Dragos Carp's avatar
Dragos Carp committed
108 109 110 111 112
	ccr &= 0xFF00;
	if (cs->speed_hz)
		ccr |= (MCLK / cs->speed_hz - 1) & 0xFF;
	else /* by default SPI Clk 1MHz */
		ccr |= (MCLK / 1000000 - 1) & 0xFF;
113
	out_be16((u16 __iomem *)&psc->ccr, ccr);
Dragos Carp's avatar
Dragos Carp committed
114 115
	mps->bits_per_word = cs->bits_per_word;

116 117
	if (mps->cs_control)
		mps->cs_control(spi, (spi->mode & SPI_CS_HIGH) ? 1 : 0);
Dragos Carp's avatar
Dragos Carp committed
118 119 120 121 122 123
}

static void mpc52xx_psc_spi_deactivate_cs(struct spi_device *spi)
{
	struct mpc52xx_psc_spi *mps = spi_master_get_devdata(spi->master);

124 125
	if (mps->cs_control)
		mps->cs_control(spi, (spi->mode & SPI_CS_HIGH) ? 0 : 1);
Dragos Carp's avatar
Dragos Carp committed
126 127 128 129 130 131 132 133 134 135 136
}

#define MPC52xx_PSC_BUFSIZE (MPC52xx_PSC_RFNUM_MASK + 1)
/* wake up when 80% fifo full */
#define MPC52xx_PSC_RFALARM (MPC52xx_PSC_BUFSIZE * 20 / 100)

static int mpc52xx_psc_spi_transfer_rxtx(struct spi_device *spi,
						struct spi_transfer *t)
{
	struct mpc52xx_psc_spi *mps = spi_master_get_devdata(spi->master);
	struct mpc52xx_psc __iomem *psc = mps->psc;
137
	struct mpc52xx_psc_fifo __iomem *fifo = mps->fifo;
Dragos Carp's avatar
Dragos Carp committed
138 139 140 141 142 143 144
	unsigned rb = 0;	/* number of bytes receieved */
	unsigned sb = 0;	/* number of bytes sent */
	unsigned char *rx_buf = (unsigned char *)t->rx_buf;
	unsigned char *tx_buf = (unsigned char *)t->tx_buf;
	unsigned rfalarm;
	unsigned send_at_once = MPC52xx_PSC_BUFSIZE;
	unsigned recv_at_once;
145
	int last_block = 0;
Dragos Carp's avatar
Dragos Carp committed
146 147 148 149 150 151 152 153 154

	if (!t->tx_buf && !t->rx_buf && t->len)
		return -EINVAL;

	/* enable transmiter/receiver */
	out_8(&psc->command, MPC52xx_PSC_TX_ENABLE | MPC52xx_PSC_RX_ENABLE);
	while (rb < t->len) {
		if (t->len - rb > MPC52xx_PSC_BUFSIZE) {
			rfalarm = MPC52xx_PSC_RFALARM;
155
			last_block = 0;
Dragos Carp's avatar
Dragos Carp committed
156 157 158
		} else {
			send_at_once = t->len - sb;
			rfalarm = MPC52xx_PSC_BUFSIZE - (t->len - rb);
159
			last_block = 1;
Dragos Carp's avatar
Dragos Carp committed
160 161 162
		}

		dev_dbg(&spi->dev, "send %d bytes...\n", send_at_once);
163 164
		for (; send_at_once; sb++, send_at_once--) {
			/* set EOF flag before the last word is sent */
165
			if (send_at_once == 1 && last_block)
166 167 168
				out_8(&psc->ircr2, 0x01);

			if (tx_buf)
Dragos Carp's avatar
Dragos Carp committed
169
				out_8(&psc->mpc52xx_psc_buffer_8, tx_buf[sb]);
170
			else
Dragos Carp's avatar
Dragos Carp committed
171 172 173 174
				out_8(&psc->mpc52xx_psc_buffer_8, 0);
		}


175
		/* enable interrupts and wait for wake up
Dragos Carp's avatar
Dragos Carp committed
176 177 178 179 180 181 182 183
		 * if just one byte is expected the Rx FIFO genererates no
		 * FFULL interrupt, so activate the RxRDY interrupt
		 */
		out_8(&psc->command, MPC52xx_PSC_SEL_MODE_REG_1);
		if (t->len - rb == 1) {
			out_8(&psc->mode, 0);
		} else {
			out_8(&psc->mode, MPC52xx_PSC_MODE_FFULL);
184
			out_be16(&fifo->rfalarm, rfalarm);
Dragos Carp's avatar
Dragos Carp committed
185 186 187
		}
		out_be16(&psc->mpc52xx_psc_imr, MPC52xx_PSC_IMR_RXRDY);
		wait_for_completion(&mps->done);
188
		recv_at_once = in_be16(&fifo->rfnum);
Dragos Carp's avatar
Dragos Carp committed
189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 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 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
		dev_dbg(&spi->dev, "%d bytes received\n", recv_at_once);

		send_at_once = recv_at_once;
		if (rx_buf) {
			for (; recv_at_once; rb++, recv_at_once--)
				rx_buf[rb] = in_8(&psc->mpc52xx_psc_buffer_8);
		} else {
			for (; recv_at_once; rb++, recv_at_once--)
				in_8(&psc->mpc52xx_psc_buffer_8);
		}
	}
	/* disable transmiter/receiver */
	out_8(&psc->command, MPC52xx_PSC_TX_DISABLE | MPC52xx_PSC_RX_DISABLE);

	return 0;
}

static void mpc52xx_psc_spi_work(struct work_struct *work)
{
	struct mpc52xx_psc_spi *mps =
		container_of(work, struct mpc52xx_psc_spi, work);

	spin_lock_irq(&mps->lock);
	mps->busy = 1;
	while (!list_empty(&mps->queue)) {
		struct spi_message *m;
		struct spi_device *spi;
		struct spi_transfer *t = NULL;
		unsigned cs_change;
		int status;

		m = container_of(mps->queue.next, struct spi_message, queue);
		list_del_init(&m->queue);
		spin_unlock_irq(&mps->lock);

		spi = m->spi;
		cs_change = 1;
		status = 0;
		list_for_each_entry (t, &m->transfers, transfer_list) {
			if (t->bits_per_word || t->speed_hz) {
				status = mpc52xx_psc_spi_transfer_setup(spi, t);
				if (status < 0)
					break;
			}

			if (cs_change)
				mpc52xx_psc_spi_activate_cs(spi);
			cs_change = t->cs_change;

			status = mpc52xx_psc_spi_transfer_rxtx(spi, t);
			if (status)
				break;
			m->actual_length += t->len;

			if (t->delay_usecs)
				udelay(t->delay_usecs);

			if (cs_change)
				mpc52xx_psc_spi_deactivate_cs(spi);
		}

		m->status = status;
		m->complete(m->context);

		if (status || !cs_change)
			mpc52xx_psc_spi_deactivate_cs(spi);

		mpc52xx_psc_spi_transfer_setup(spi, NULL);

		spin_lock_irq(&mps->lock);
	}
	mps->busy = 0;
	spin_unlock_irq(&mps->lock);
}

static int mpc52xx_psc_spi_setup(struct spi_device *spi)
{
	struct mpc52xx_psc_spi *mps = spi_master_get_devdata(spi->master);
	struct mpc52xx_psc_spi_cs *cs = spi->controller_state;
	unsigned long flags;

	if (spi->bits_per_word%8)
		return -EINVAL;

	if (!cs) {
		cs = kzalloc(sizeof *cs, GFP_KERNEL);
		if (!cs)
			return -ENOMEM;
		spi->controller_state = cs;
	}

	cs->bits_per_word = spi->bits_per_word;
	cs->speed_hz = spi->max_speed_hz;

	spin_lock_irqsave(&mps->lock, flags);
	if (!mps->busy)
		mpc52xx_psc_spi_deactivate_cs(spi);
	spin_unlock_irqrestore(&mps->lock, flags);

	return 0;
}

static int mpc52xx_psc_spi_transfer(struct spi_device *spi,
		struct spi_message *m)
{
	struct mpc52xx_psc_spi *mps = spi_master_get_devdata(spi->master);
	unsigned long flags;

	m->actual_length = 0;
	m->status = -EINPROGRESS;

	spin_lock_irqsave(&mps->lock, flags);
	list_add_tail(&m->queue, &mps->queue);
	queue_work(mps->workqueue, &mps->work);
	spin_unlock_irqrestore(&mps->lock, flags);

	return 0;
}

static void mpc52xx_psc_spi_cleanup(struct spi_device *spi)
{
	kfree(spi->controller_state);
}

static int mpc52xx_psc_spi_port_config(int psc_id, struct mpc52xx_psc_spi *mps)
{
	struct mpc52xx_psc __iomem *psc = mps->psc;
316
	struct mpc52xx_psc_fifo __iomem *fifo = mps->fifo;
Dragos Carp's avatar
Dragos Carp committed
317
	u32 mclken_div;
318
	int ret;
Dragos Carp's avatar
Dragos Carp committed
319 320

	/* default sysclk is 512MHz */
321
	mclken_div = (mps->sysclk ? mps->sysclk : 512000000) / MCLK;
322 323 324
	ret = mpc52xx_set_psc_clkdiv(psc_id, mclken_div);
	if (ret)
		return ret;
Dragos Carp's avatar
Dragos Carp committed
325 326 327 328 329 330 331 332 333

	/* Reset the PSC into a known state */
	out_8(&psc->command, MPC52xx_PSC_RST_RX);
	out_8(&psc->command, MPC52xx_PSC_RST_TX);
	out_8(&psc->command, MPC52xx_PSC_TX_DISABLE | MPC52xx_PSC_RX_DISABLE);

	/* Disable interrupts, interrupts are based on alarm level */
	out_be16(&psc->mpc52xx_psc_imr, 0);
	out_8(&psc->command, MPC52xx_PSC_SEL_MODE_REG_1);
334
	out_8(&fifo->rfcntl, 0);
Dragos Carp's avatar
Dragos Carp committed
335 336 337 338 339
	out_8(&psc->mode, MPC52xx_PSC_MODE_FFULL);

	/* Configure 8bit codec mode as a SPI master and use EOF flags */
	/* SICR_SIM_CODEC8|SICR_GENCLK|SICR_SPI|SICR_MSTR|SICR_USEEOF */
	out_be32(&psc->sicr, 0x0180C800);
340
	out_be16((u16 __iomem *)&psc->ccr, 0x070F); /* default SPI Clk 1MHz */
Dragos Carp's avatar
Dragos Carp committed
341 342 343 344 345 346 347

	/* Set 2ms DTL delay */
	out_8(&psc->ctur, 0x00);
	out_8(&psc->ctlr, 0x84);

	mps->bits_per_word = 8;

348
	return 0;
Dragos Carp's avatar
Dragos Carp committed
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365
}

static irqreturn_t mpc52xx_psc_spi_isr(int irq, void *dev_id)
{
	struct mpc52xx_psc_spi *mps = (struct mpc52xx_psc_spi *)dev_id;
	struct mpc52xx_psc __iomem *psc = mps->psc;

	/* disable interrupt and wake up the work queue */
	if (in_be16(&psc->mpc52xx_psc_isr) & MPC52xx_PSC_IMR_RXRDY) {
		out_be16(&psc->mpc52xx_psc_imr, 0);
		complete(&mps->done);
		return IRQ_HANDLED;
	}
	return IRQ_NONE;
}

/* bus_num is used only for the case dev->platform_data == NULL */
366
static int __devinit mpc52xx_psc_spi_do_probe(struct device *dev, u32 regaddr,
Dragos Carp's avatar
Dragos Carp committed
367 368 369 370 371 372 373 374 375 376 377 378 379 380
				u32 size, unsigned int irq, s16 bus_num)
{
	struct fsl_spi_platform_data *pdata = dev->platform_data;
	struct mpc52xx_psc_spi *mps;
	struct spi_master *master;
	int ret;

	master = spi_alloc_master(dev, sizeof *mps);
	if (master == NULL)
		return -ENOMEM;

	dev_set_drvdata(dev, master);
	mps = spi_master_get_devdata(master);

381 382 383
	/* the spi->mode bits understood by this driver: */
	master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LSB_FIRST;

Dragos Carp's avatar
Dragos Carp committed
384 385 386
	mps->irq = irq;
	if (pdata == NULL) {
		dev_warn(dev, "probe called without platform data, no "
387 388
				"cs_control function will be called\n");
		mps->cs_control = NULL;
Dragos Carp's avatar
Dragos Carp committed
389 390 391 392
		mps->sysclk = 0;
		master->bus_num = bus_num;
		master->num_chipselect = 255;
	} else {
393
		mps->cs_control = pdata->cs_control;
Dragos Carp's avatar
Dragos Carp committed
394 395 396 397 398 399 400
		mps->sysclk = pdata->sysclk;
		master->bus_num = pdata->bus_num;
		master->num_chipselect = pdata->max_chipselect;
	}
	master->setup = mpc52xx_psc_spi_setup;
	master->transfer = mpc52xx_psc_spi_transfer;
	master->cleanup = mpc52xx_psc_spi_cleanup;
401
	master->dev.of_node = dev->of_node;
Dragos Carp's avatar
Dragos Carp committed
402 403 404 405 406 407 408

	mps->psc = ioremap(regaddr, size);
	if (!mps->psc) {
		dev_err(dev, "could not ioremap I/O port range\n");
		ret = -EFAULT;
		goto free_master;
	}
409 410
	/* On the 5200, fifo regs are immediately ajacent to the psc regs */
	mps->fifo = ((void __iomem *)mps->psc) + sizeof(struct mpc52xx_psc);
Dragos Carp's avatar
Dragos Carp committed
411 412 413 414 415 416 417

	ret = request_irq(mps->irq, mpc52xx_psc_spi_isr, 0, "mpc52xx-psc-spi",
				mps);
	if (ret)
		goto free_master;

	ret = mpc52xx_psc_spi_port_config(master->bus_num, mps);
418 419
	if (ret < 0) {
		dev_err(dev, "can't configure PSC! Is it capable of SPI?\n");
Dragos Carp's avatar
Dragos Carp committed
420
		goto free_irq;
421
	}
Dragos Carp's avatar
Dragos Carp committed
422 423 424 425 426 427 428

	spin_lock_init(&mps->lock);
	init_completion(&mps->done);
	INIT_WORK(&mps->work, mpc52xx_psc_spi_work);
	INIT_LIST_HEAD(&mps->queue);

	mps->workqueue = create_singlethread_workqueue(
429
		dev_name(master->dev.parent));
Dragos Carp's avatar
Dragos Carp committed
430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452
	if (mps->workqueue == NULL) {
		ret = -EBUSY;
		goto free_irq;
	}

	ret = spi_register_master(master);
	if (ret < 0)
		goto unreg_master;

	return ret;

unreg_master:
	destroy_workqueue(mps->workqueue);
free_irq:
	free_irq(mps->irq, mps);
free_master:
	if (mps->psc)
		iounmap(mps->psc);
	spi_master_put(master);

	return ret;
}

453
static int __devinit mpc52xx_psc_spi_of_probe(struct platform_device *op)
Dragos Carp's avatar
Dragos Carp committed
454 455 456 457 458
{
	const u32 *regaddr_p;
	u64 regaddr64, size64;
	s16 id = -1;

459
	regaddr_p = of_get_address(op->dev.of_node, 0, &size64, NULL);
Dragos Carp's avatar
Dragos Carp committed
460
	if (!regaddr_p) {
461
		dev_err(&op->dev, "Invalid PSC address\n");
Dragos Carp's avatar
Dragos Carp committed
462 463
		return -EINVAL;
	}
464
	regaddr64 = of_translate_address(op->dev.of_node, regaddr_p);
Dragos Carp's avatar
Dragos Carp committed
465

466
	/* get PSC id (1..6, used by port_config) */
Dragos Carp's avatar
Dragos Carp committed
467
	if (op->dev.platform_data == NULL) {
468
		const u32 *psc_nump;
Dragos Carp's avatar
Dragos Carp committed
469

470
		psc_nump = of_get_property(op->dev.of_node, "cell-index", NULL);
471
		if (!psc_nump || *psc_nump > 5) {
472
			dev_err(&op->dev, "Invalid cell-index property\n");
473
			return -EINVAL;
Dragos Carp's avatar
Dragos Carp committed
474
		}
475
		id = *psc_nump + 1;
Dragos Carp's avatar
Dragos Carp committed
476 477
	}

478
	return mpc52xx_psc_spi_do_probe(&op->dev, (u32)regaddr64, (u32)size64,
479
				irq_of_parse_and_map(op->dev.of_node, 0), id);
Dragos Carp's avatar
Dragos Carp committed
480 481
}

482
static int __devexit mpc52xx_psc_spi_of_remove(struct platform_device *op)
Dragos Carp's avatar
Dragos Carp committed
483
{
484 485 486 487 488 489 490 491 492 493 494
	struct spi_master *master = dev_get_drvdata(&op->dev);
	struct mpc52xx_psc_spi *mps = spi_master_get_devdata(master);

	flush_workqueue(mps->workqueue);
	destroy_workqueue(mps->workqueue);
	spi_unregister_master(master);
	free_irq(mps->irq, mps);
	if (mps->psc)
		iounmap(mps->psc);

	return 0;
Dragos Carp's avatar
Dragos Carp committed
495 496
}

497
static const struct of_device_id mpc52xx_psc_spi_of_match[] = {
498 499 500
	{ .compatible = "fsl,mpc5200-psc-spi", },
	{ .compatible = "mpc5200-psc-spi", }, /* old */
	{}
Dragos Carp's avatar
Dragos Carp committed
501 502 503 504
};

MODULE_DEVICE_TABLE(of, mpc52xx_psc_spi_of_match);

505
static struct platform_driver mpc52xx_psc_spi_of_driver = {
Dragos Carp's avatar
Dragos Carp committed
506
	.probe = mpc52xx_psc_spi_of_probe,
507
	.remove = __devexit_p(mpc52xx_psc_spi_of_remove),
Dragos Carp's avatar
Dragos Carp committed
508 509 510
	.driver = {
		.name = "mpc52xx-psc-spi",
		.owner = THIS_MODULE,
511
		.of_match_table = mpc52xx_psc_spi_of_match,
Dragos Carp's avatar
Dragos Carp committed
512 513 514 515 516
	},
};

static int __init mpc52xx_psc_spi_init(void)
{
517
	return platform_driver_register(&mpc52xx_psc_spi_of_driver);
Dragos Carp's avatar
Dragos Carp committed
518 519 520 521 522
}
module_init(mpc52xx_psc_spi_init);

static void __exit mpc52xx_psc_spi_exit(void)
{
523
	platform_driver_unregister(&mpc52xx_psc_spi_of_driver);
Dragos Carp's avatar
Dragos Carp committed
524 525 526 527 528 529
}
module_exit(mpc52xx_psc_spi_exit);

MODULE_AUTHOR("Dragos Carp");
MODULE_DESCRIPTION("MPC52xx PSC SPI Driver");
MODULE_LICENSE("GPL");