2 * MPC512x PSC in SPI mode driver.
4 * Copyright (C) 2007,2008 Freescale Semiconductor Inc.
5 * Original port from 52xx driver:
6 * Hongjun Chen <hong-jun.chen@freescale.com>
8 * Fork of mpc52xx_psc_spi.c:
9 * Copyright (C) 2006 TOPTICA Photonics AG., Dragos Carp
11 * This program is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License as published by the
13 * Free Software Foundation; either version 2 of the License, or (at your
14 * option) any later version.
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/errno.h>
21 #include <linux/interrupt.h>
22 #include <linux/of_platform.h>
23 #include <linux/workqueue.h>
24 #include <linux/completion.h>
26 #include <linux/delay.h>
27 #include <linux/clk.h>
28 #include <linux/spi/spi.h>
29 #include <linux/fsl_devices.h>
30 #include <asm/mpc52xx_psc.h>
32 struct mpc512x_psc_spi {
33 void (*cs_control)(struct spi_device *spi, bool on);
36 /* driver internal data */
37 struct mpc52xx_psc __iomem *psc;
38 struct mpc512x_psc_fifo __iomem *fifo;
45 struct workqueue_struct *workqueue;
46 struct work_struct work;
48 struct list_head queue;
49 spinlock_t lock; /* Message queue lock */
51 struct completion done;
54 /* controller state */
55 struct mpc512x_psc_spi_cs {
60 /* set clock freq, clock ramp, bits per work
61 * if t is NULL then reset the values to the default values
63 static int mpc512x_psc_spi_transfer_setup(struct spi_device *spi,
64 struct spi_transfer *t)
66 struct mpc512x_psc_spi_cs *cs = spi->controller_state;
68 cs->speed_hz = (t && t->speed_hz)
69 ? t->speed_hz : spi->max_speed_hz;
70 cs->bits_per_word = (t && t->bits_per_word)
71 ? t->bits_per_word : spi->bits_per_word;
72 cs->bits_per_word = ((cs->bits_per_word + 7) / 8) * 8;
76 static void mpc512x_psc_spi_activate_cs(struct spi_device *spi)
78 struct mpc512x_psc_spi_cs *cs = spi->controller_state;
79 struct mpc512x_psc_spi *mps = spi_master_get_devdata(spi->master);
80 struct mpc52xx_psc __iomem *psc = mps->psc;
85 sicr = in_be32(&psc->sicr);
87 /* Set clock phase and polarity */
88 if (spi->mode & SPI_CPHA)
93 if (spi->mode & SPI_CPOL)
98 if (spi->mode & SPI_LSB_FIRST)
102 out_be32(&psc->sicr, sicr);
104 ccr = in_be32(&psc->ccr);
107 bclkdiv = (mps->mclk / cs->speed_hz) - 1;
109 bclkdiv = (mps->mclk / 1000000) - 1; /* default 1MHz */
111 ccr |= (((bclkdiv & 0xff) << 16) | (((bclkdiv >> 8) & 0xff) << 8));
112 out_be32(&psc->ccr, ccr);
113 mps->bits_per_word = cs->bits_per_word;
116 mps->cs_control(spi, (spi->mode & SPI_CS_HIGH) ? 1 : 0);
119 static void mpc512x_psc_spi_deactivate_cs(struct spi_device *spi)
121 struct mpc512x_psc_spi *mps = spi_master_get_devdata(spi->master);
124 mps->cs_control(spi, (spi->mode & SPI_CS_HIGH) ? 0 : 1);
128 /* extract and scale size field in txsz or rxsz */
129 #define MPC512x_PSC_FIFO_SZ(sz) ((sz & 0x7ff) << 2);
133 static int mpc512x_psc_spi_transfer_rxtx(struct spi_device *spi,
134 struct spi_transfer *t)
136 struct mpc512x_psc_spi *mps = spi_master_get_devdata(spi->master);
137 struct mpc52xx_psc __iomem *psc = mps->psc;
138 struct mpc512x_psc_fifo __iomem *fifo = mps->fifo;
140 u8 *tx_buf = (u8 *)t->tx_buf;
141 u8 *rx_buf = (u8 *)t->rx_buf;
143 if (!tx_buf && !rx_buf && t->len)
148 out_8(&psc->mode, 0x0);
158 * The number of bytes that can be sent at a time
159 * depends on the fifo size.
161 fifosz = MPC512x_PSC_FIFO_SZ(in_be32(&fifo->txsz));
162 count = min(fifosz, len);
164 for (i = count; i > 0; i--) {
165 data = tx_buf ? *tx_buf++ : 0;
167 setbits32(&fifo->txcmd, MPC512x_PSC_FIFO_EOF);
168 out_8(&fifo->txdata_8, data);
172 INIT_COMPLETION(mps->done);
174 /* interrupt on tx fifo empty */
175 out_be32(&fifo->txisr, MPC512x_PSC_FIFO_EMPTY);
176 out_be32(&fifo->tximr, MPC512x_PSC_FIFO_EMPTY);
178 /* enable transmiter/receiver */
180 MPC52xx_PSC_TX_ENABLE | MPC52xx_PSC_RX_ENABLE);
182 wait_for_completion(&mps->done);
186 /* rx fifo should have count bytes in it */
187 rxcount = in_be32(&fifo->rxcnt);
188 if (rxcount != count)
191 rxcount = in_be32(&fifo->rxcnt);
192 if (rxcount != count) {
193 dev_warn(&spi->dev, "expected %d bytes in rx fifo "
194 "but got %d\n", count, rxcount);
197 rxcount = min(rxcount, count);
198 for (i = rxcount; i > 0; i--) {
199 data = in_8(&fifo->rxdata_8);
203 while (in_be32(&fifo->rxcnt)) {
204 in_8(&fifo->rxdata_8);
208 MPC52xx_PSC_TX_DISABLE | MPC52xx_PSC_RX_DISABLE);
210 /* disable transmiter/receiver and fifo interrupt */
211 out_8(&psc->command, MPC52xx_PSC_TX_DISABLE | MPC52xx_PSC_RX_DISABLE);
212 out_be32(&fifo->tximr, 0);
216 static void mpc512x_psc_spi_work(struct work_struct *work)
218 struct mpc512x_psc_spi *mps = container_of(work,
219 struct mpc512x_psc_spi,
222 spin_lock_irq(&mps->lock);
224 while (!list_empty(&mps->queue)) {
225 struct spi_message *m;
226 struct spi_device *spi;
227 struct spi_transfer *t = NULL;
231 m = container_of(mps->queue.next, struct spi_message, queue);
232 list_del_init(&m->queue);
233 spin_unlock_irq(&mps->lock);
238 list_for_each_entry(t, &m->transfers, transfer_list) {
239 if (t->bits_per_word || t->speed_hz) {
240 status = mpc512x_psc_spi_transfer_setup(spi, t);
246 mpc512x_psc_spi_activate_cs(spi);
247 cs_change = t->cs_change;
249 status = mpc512x_psc_spi_transfer_rxtx(spi, t);
252 m->actual_length += t->len;
255 udelay(t->delay_usecs);
258 mpc512x_psc_spi_deactivate_cs(spi);
262 m->complete(m->context);
264 if (status || !cs_change)
265 mpc512x_psc_spi_deactivate_cs(spi);
267 mpc512x_psc_spi_transfer_setup(spi, NULL);
269 spin_lock_irq(&mps->lock);
272 spin_unlock_irq(&mps->lock);
275 static int mpc512x_psc_spi_setup(struct spi_device *spi)
277 struct mpc512x_psc_spi *mps = spi_master_get_devdata(spi->master);
278 struct mpc512x_psc_spi_cs *cs = spi->controller_state;
281 if (spi->bits_per_word % 8)
285 cs = kzalloc(sizeof *cs, GFP_KERNEL);
288 spi->controller_state = cs;
291 cs->bits_per_word = spi->bits_per_word;
292 cs->speed_hz = spi->max_speed_hz;
294 spin_lock_irqsave(&mps->lock, flags);
296 mpc512x_psc_spi_deactivate_cs(spi);
297 spin_unlock_irqrestore(&mps->lock, flags);
302 static int mpc512x_psc_spi_transfer(struct spi_device *spi,
303 struct spi_message *m)
305 struct mpc512x_psc_spi *mps = spi_master_get_devdata(spi->master);
308 m->actual_length = 0;
309 m->status = -EINPROGRESS;
311 spin_lock_irqsave(&mps->lock, flags);
312 list_add_tail(&m->queue, &mps->queue);
313 queue_work(mps->workqueue, &mps->work);
314 spin_unlock_irqrestore(&mps->lock, flags);
319 static void mpc512x_psc_spi_cleanup(struct spi_device *spi)
321 kfree(spi->controller_state);
324 static int mpc512x_psc_spi_port_config(struct spi_master *master,
325 struct mpc512x_psc_spi *mps)
327 struct mpc52xx_psc __iomem *psc = mps->psc;
328 struct mpc512x_psc_fifo __iomem *fifo = mps->fifo;
336 sprintf(name, "psc%d_mclk", master->bus_num);
337 spiclk = clk_get(&master->dev, name);
339 mps->mclk = clk_get_rate(spiclk);
342 /* Reset the PSC into a known state */
343 out_8(&psc->command, MPC52xx_PSC_RST_RX);
344 out_8(&psc->command, MPC52xx_PSC_RST_TX);
345 out_8(&psc->command, MPC52xx_PSC_TX_DISABLE | MPC52xx_PSC_RX_DISABLE);
347 /* Disable psc interrupts all useful interrupts are in fifo */
348 out_be16(&psc->isr_imr.imr, 0);
350 /* Disable fifo interrupts, will be enabled later */
351 out_be32(&fifo->tximr, 0);
352 out_be32(&fifo->rximr, 0);
354 /* Setup fifo slice address and size */
355 /*out_be32(&fifo->txsz, 0x0fe00004);*/
356 /*out_be32(&fifo->rxsz, 0x0ff00004);*/
358 sicr = 0x01000000 | /* SIM = 0001 -- 8 bit */
359 0x00800000 | /* GenClk = 1 -- internal clk */
360 0x00008000 | /* SPI = 1 */
361 0x00004000 | /* MSTR = 1 -- SPI master */
362 0x00000800; /* UseEOF = 1 -- SS low until EOF */
364 out_be32(&psc->sicr, sicr);
366 ccr = in_be32(&psc->ccr);
368 bclkdiv = (mps->mclk / 1000000) - 1; /* default 1MHz */
369 ccr |= (((bclkdiv & 0xff) << 16) | (((bclkdiv >> 8) & 0xff) << 8));
370 out_be32(&psc->ccr, ccr);
372 /* Set 2ms DTL delay */
373 out_8(&psc->ctur, 0x00);
374 out_8(&psc->ctlr, 0x82);
376 /* we don't use the alarms */
377 out_be32(&fifo->rxalarm, 0xfff);
378 out_be32(&fifo->txalarm, 0);
380 /* Enable FIFO slices for Rx/Tx */
381 out_be32(&fifo->rxcmd,
382 MPC512x_PSC_FIFO_ENABLE_SLICE | MPC512x_PSC_FIFO_ENABLE_DMA);
383 out_be32(&fifo->txcmd,
384 MPC512x_PSC_FIFO_ENABLE_SLICE | MPC512x_PSC_FIFO_ENABLE_DMA);
386 mps->bits_per_word = 8;
391 static irqreturn_t mpc512x_psc_spi_isr(int irq, void *dev_id)
393 struct mpc512x_psc_spi *mps = (struct mpc512x_psc_spi *)dev_id;
394 struct mpc512x_psc_fifo __iomem *fifo = mps->fifo;
396 /* clear interrupt and wake up the work queue */
397 if (in_be32(&fifo->txisr) &
398 in_be32(&fifo->tximr) & MPC512x_PSC_FIFO_EMPTY) {
399 out_be32(&fifo->txisr, MPC512x_PSC_FIFO_EMPTY);
400 out_be32(&fifo->tximr, 0);
401 complete(&mps->done);
407 /* bus_num is used only for the case dev->platform_data == NULL */
408 static int __init mpc512x_psc_spi_do_probe(struct device *dev, u32 regaddr,
409 u32 size, unsigned int irq,
412 struct fsl_spi_platform_data *pdata = dev->platform_data;
413 struct mpc512x_psc_spi *mps;
414 struct spi_master *master;
418 master = spi_alloc_master(dev, sizeof *mps);
422 dev_set_drvdata(dev, master);
423 mps = spi_master_get_devdata(master);
427 dev_err(dev, "probe called without platform data, no "
428 "cs_control function will be called\n");
429 mps->cs_control = NULL;
431 master->bus_num = bus_num;
432 master->num_chipselect = 255;
434 mps->cs_control = pdata->cs_control;
435 mps->sysclk = pdata->sysclk;
436 master->bus_num = pdata->bus_num;
437 master->num_chipselect = pdata->max_chipselect;
440 master->setup = mpc512x_psc_spi_setup;
441 master->transfer = mpc512x_psc_spi_transfer;
442 master->cleanup = mpc512x_psc_spi_cleanup;
444 tempp = ioremap(regaddr, size);
446 dev_err(dev, "could not ioremap I/O port range\n");
452 (struct mpc512x_psc_fifo *)(tempp + sizeof(struct mpc52xx_psc));
454 ret = request_irq(mps->irq, mpc512x_psc_spi_isr, IRQF_SHARED,
455 "mpc512x-psc-spi", mps);
459 ret = mpc512x_psc_spi_port_config(master, mps);
463 spin_lock_init(&mps->lock);
464 init_completion(&mps->done);
465 INIT_WORK(&mps->work, mpc512x_psc_spi_work);
466 INIT_LIST_HEAD(&mps->queue);
469 create_singlethread_workqueue(dev_name(master->dev.parent));
470 if (mps->workqueue == NULL) {
475 ret = spi_register_master(master);
482 destroy_workqueue(mps->workqueue);
484 free_irq(mps->irq, mps);
488 spi_master_put(master);
493 static int __exit mpc512x_psc_spi_do_remove(struct device *dev)
495 struct spi_master *master = dev_get_drvdata(dev);
496 struct mpc512x_psc_spi *mps = spi_master_get_devdata(master);
498 flush_workqueue(mps->workqueue);
499 destroy_workqueue(mps->workqueue);
500 spi_unregister_master(master);
501 free_irq(mps->irq, mps);
508 static int __init mpc512x_psc_spi_of_probe(struct of_device *op,
509 const struct of_device_id *match)
511 const u32 *regaddr_p;
512 u64 regaddr64, size64;
515 regaddr_p = of_get_address(op->dev.of_node, 0, &size64, NULL);
517 dev_err(&op->dev, "Invalid PSC address\n");
520 regaddr64 = of_translate_address(op->dev.of_node, regaddr_p);
522 /* get PSC id (0..11, used by port_config) */
523 if (op->dev.platform_data == NULL) {
526 psc_nump = of_get_property(op->dev.of_node, "cell-index", NULL);
527 if (!psc_nump || *psc_nump > 11) {
528 dev_err(&op->dev, "mpc512x_psc_spi: Device node %s "
529 "has invalid cell-index property\n",
530 op->dev.of_node->full_name);
536 return mpc512x_psc_spi_do_probe(&op->dev, (u32) regaddr64, (u32) size64,
537 irq_of_parse_and_map(op->dev.of_node, 0), id);
540 static int __exit mpc512x_psc_spi_of_remove(struct of_device *op)
542 return mpc512x_psc_spi_do_remove(&op->dev);
545 static struct of_device_id mpc512x_psc_spi_of_match[] = {
546 { .compatible = "fsl,mpc5121-psc-spi", },
550 MODULE_DEVICE_TABLE(of, mpc512x_psc_spi_of_match);
552 static struct of_platform_driver mpc512x_psc_spi_of_driver = {
553 .probe = mpc512x_psc_spi_of_probe,
554 .remove = __exit_p(mpc512x_psc_spi_of_remove),
556 .name = "mpc512x-psc-spi",
557 .owner = THIS_MODULE,
558 .of_match_table = mpc512x_psc_spi_of_match,
562 static int __init mpc512x_psc_spi_init(void)
564 return of_register_platform_driver(&mpc512x_psc_spi_of_driver);
566 module_init(mpc512x_psc_spi_init);
568 static void __exit mpc512x_psc_spi_exit(void)
570 of_unregister_platform_driver(&mpc512x_psc_spi_of_driver);
572 module_exit(mpc512x_psc_spi_exit);
574 MODULE_AUTHOR("John Rigby");
575 MODULE_DESCRIPTION("MPC512x PSC SPI Driver");
576 MODULE_LICENSE("GPL");