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_address.h>
23 #include <linux/of_platform.h>
24 #include <linux/workqueue.h>
25 #include <linux/completion.h>
27 #include <linux/delay.h>
28 #include <linux/clk.h>
29 #include <linux/spi/spi.h>
30 #include <linux/fsl_devices.h>
31 #include <linux/gpio.h>
32 #include <asm/mpc52xx_psc.h>
34 struct mpc512x_psc_spi
{
35 void (*cs_control
)(struct spi_device
*spi
, bool on
);
38 /* driver internal data */
39 struct mpc52xx_psc __iomem
*psc
;
40 struct mpc512x_psc_fifo __iomem
*fifo
;
47 struct workqueue_struct
*workqueue
;
48 struct work_struct work
;
50 struct list_head queue
;
51 spinlock_t lock
; /* Message queue lock */
53 struct completion done
;
56 /* controller state */
57 struct mpc512x_psc_spi_cs
{
62 /* set clock freq, clock ramp, bits per work
63 * if t is NULL then reset the values to the default values
65 static int mpc512x_psc_spi_transfer_setup(struct spi_device
*spi
,
66 struct spi_transfer
*t
)
68 struct mpc512x_psc_spi_cs
*cs
= spi
->controller_state
;
70 cs
->speed_hz
= (t
&& t
->speed_hz
)
71 ? t
->speed_hz
: spi
->max_speed_hz
;
72 cs
->bits_per_word
= (t
&& t
->bits_per_word
)
73 ? t
->bits_per_word
: spi
->bits_per_word
;
74 cs
->bits_per_word
= ((cs
->bits_per_word
+ 7) / 8) * 8;
78 static void mpc512x_psc_spi_activate_cs(struct spi_device
*spi
)
80 struct mpc512x_psc_spi_cs
*cs
= spi
->controller_state
;
81 struct mpc512x_psc_spi
*mps
= spi_master_get_devdata(spi
->master
);
82 struct mpc52xx_psc __iomem
*psc
= mps
->psc
;
87 sicr
= in_be32(&psc
->sicr
);
89 /* Set clock phase and polarity */
90 if (spi
->mode
& SPI_CPHA
)
95 if (spi
->mode
& SPI_CPOL
)
100 if (spi
->mode
& SPI_LSB_FIRST
)
104 out_be32(&psc
->sicr
, sicr
);
106 ccr
= in_be32(&psc
->ccr
);
109 bclkdiv
= (mps
->mclk
/ cs
->speed_hz
) - 1;
111 bclkdiv
= (mps
->mclk
/ 1000000) - 1; /* default 1MHz */
113 ccr
|= (((bclkdiv
& 0xff) << 16) | (((bclkdiv
>> 8) & 0xff) << 8));
114 out_be32(&psc
->ccr
, ccr
);
115 mps
->bits_per_word
= cs
->bits_per_word
;
117 if (mps
->cs_control
&& gpio_is_valid(spi
->cs_gpio
))
118 mps
->cs_control(spi
, (spi
->mode
& SPI_CS_HIGH
) ? 1 : 0);
121 static void mpc512x_psc_spi_deactivate_cs(struct spi_device
*spi
)
123 struct mpc512x_psc_spi
*mps
= spi_master_get_devdata(spi
->master
);
125 if (mps
->cs_control
&& gpio_is_valid(spi
->cs_gpio
))
126 mps
->cs_control(spi
, (spi
->mode
& SPI_CS_HIGH
) ? 0 : 1);
130 /* extract and scale size field in txsz or rxsz */
131 #define MPC512x_PSC_FIFO_SZ(sz) ((sz & 0x7ff) << 2);
135 static int mpc512x_psc_spi_transfer_rxtx(struct spi_device
*spi
,
136 struct spi_transfer
*t
)
138 struct mpc512x_psc_spi
*mps
= spi_master_get_devdata(spi
->master
);
139 struct mpc52xx_psc __iomem
*psc
= mps
->psc
;
140 struct mpc512x_psc_fifo __iomem
*fifo
= mps
->fifo
;
142 u8
*tx_buf
= (u8
*)t
->tx_buf
;
143 u8
*rx_buf
= (u8
*)t
->rx_buf
;
145 if (!tx_buf
&& !rx_buf
&& t
->len
)
150 out_8(&psc
->mode
, 0x0);
152 /* enable transmiter/receiver */
153 out_8(&psc
->command
, MPC52xx_PSC_TX_ENABLE
| MPC52xx_PSC_RX_ENABLE
);
163 * The number of bytes that can be sent at a time
164 * depends on the fifo size.
166 fifosz
= MPC512x_PSC_FIFO_SZ(in_be32(&fifo
->txsz
));
167 count
= min(fifosz
, len
);
169 for (i
= count
; i
> 0; i
--) {
170 data
= tx_buf
? *tx_buf
++ : 0;
171 if (len
== EOFBYTE
&& t
->cs_change
)
172 setbits32(&fifo
->txcmd
, MPC512x_PSC_FIFO_EOF
);
173 out_8(&fifo
->txdata_8
, data
);
177 INIT_COMPLETION(mps
->done
);
179 /* interrupt on tx fifo empty */
180 out_be32(&fifo
->txisr
, MPC512x_PSC_FIFO_EMPTY
);
181 out_be32(&fifo
->tximr
, MPC512x_PSC_FIFO_EMPTY
);
183 wait_for_completion(&mps
->done
);
187 /* rx fifo should have count bytes in it */
188 rxcount
= in_be32(&fifo
->rxcnt
);
189 if (rxcount
!= count
)
192 rxcount
= in_be32(&fifo
->rxcnt
);
193 if (rxcount
!= count
) {
194 dev_warn(&spi
->dev
, "expected %d bytes in rx fifo "
195 "but got %d\n", count
, rxcount
);
198 rxcount
= min(rxcount
, count
);
199 for (i
= rxcount
; i
> 0; i
--) {
200 data
= in_8(&fifo
->rxdata_8
);
204 while (in_be32(&fifo
->rxcnt
)) {
205 in_8(&fifo
->rxdata_8
);
208 /* disable transmiter/receiver and fifo interrupt */
209 out_8(&psc
->command
, MPC52xx_PSC_TX_DISABLE
| MPC52xx_PSC_RX_DISABLE
);
210 out_be32(&fifo
->tximr
, 0);
214 static void mpc512x_psc_spi_work(struct work_struct
*work
)
216 struct mpc512x_psc_spi
*mps
= container_of(work
,
217 struct mpc512x_psc_spi
,
220 spin_lock_irq(&mps
->lock
);
222 while (!list_empty(&mps
->queue
)) {
223 struct spi_message
*m
;
224 struct spi_device
*spi
;
225 struct spi_transfer
*t
= NULL
;
229 m
= container_of(mps
->queue
.next
, struct spi_message
, queue
);
230 list_del_init(&m
->queue
);
231 spin_unlock_irq(&mps
->lock
);
236 list_for_each_entry(t
, &m
->transfers
, transfer_list
) {
237 if (t
->bits_per_word
|| t
->speed_hz
) {
238 status
= mpc512x_psc_spi_transfer_setup(spi
, t
);
244 mpc512x_psc_spi_activate_cs(spi
);
245 cs_change
= t
->cs_change
;
247 status
= mpc512x_psc_spi_transfer_rxtx(spi
, t
);
250 m
->actual_length
+= t
->len
;
253 udelay(t
->delay_usecs
);
256 mpc512x_psc_spi_deactivate_cs(spi
);
260 m
->complete(m
->context
);
262 if (status
|| !cs_change
)
263 mpc512x_psc_spi_deactivate_cs(spi
);
265 mpc512x_psc_spi_transfer_setup(spi
, NULL
);
267 spin_lock_irq(&mps
->lock
);
270 spin_unlock_irq(&mps
->lock
);
273 static int mpc512x_psc_spi_setup(struct spi_device
*spi
)
275 struct mpc512x_psc_spi
*mps
= spi_master_get_devdata(spi
->master
);
276 struct mpc512x_psc_spi_cs
*cs
= spi
->controller_state
;
280 if (spi
->bits_per_word
% 8)
284 cs
= kzalloc(sizeof *cs
, GFP_KERNEL
);
288 if (gpio_is_valid(spi
->cs_gpio
)) {
289 ret
= gpio_request(spi
->cs_gpio
, dev_name(&spi
->dev
));
291 dev_err(&spi
->dev
, "can't get CS gpio: %d\n",
296 gpio_direction_output(spi
->cs_gpio
,
297 spi
->mode
& SPI_CS_HIGH
? 0 : 1);
300 spi
->controller_state
= cs
;
303 cs
->bits_per_word
= spi
->bits_per_word
;
304 cs
->speed_hz
= spi
->max_speed_hz
;
306 spin_lock_irqsave(&mps
->lock
, flags
);
308 mpc512x_psc_spi_deactivate_cs(spi
);
309 spin_unlock_irqrestore(&mps
->lock
, flags
);
314 static int mpc512x_psc_spi_transfer(struct spi_device
*spi
,
315 struct spi_message
*m
)
317 struct mpc512x_psc_spi
*mps
= spi_master_get_devdata(spi
->master
);
320 m
->actual_length
= 0;
321 m
->status
= -EINPROGRESS
;
323 spin_lock_irqsave(&mps
->lock
, flags
);
324 list_add_tail(&m
->queue
, &mps
->queue
);
325 queue_work(mps
->workqueue
, &mps
->work
);
326 spin_unlock_irqrestore(&mps
->lock
, flags
);
331 static void mpc512x_psc_spi_cleanup(struct spi_device
*spi
)
333 if (gpio_is_valid(spi
->cs_gpio
))
334 gpio_free(spi
->cs_gpio
);
335 kfree(spi
->controller_state
);
338 static int mpc512x_psc_spi_port_config(struct spi_master
*master
,
339 struct mpc512x_psc_spi
*mps
)
341 struct mpc52xx_psc __iomem
*psc
= mps
->psc
;
342 struct mpc512x_psc_fifo __iomem
*fifo
= mps
->fifo
;
350 sprintf(name
, "psc%d_mclk", master
->bus_num
);
351 spiclk
= clk_get(&master
->dev
, name
);
353 mps
->mclk
= clk_get_rate(spiclk
);
356 /* Reset the PSC into a known state */
357 out_8(&psc
->command
, MPC52xx_PSC_RST_RX
);
358 out_8(&psc
->command
, MPC52xx_PSC_RST_TX
);
359 out_8(&psc
->command
, MPC52xx_PSC_TX_DISABLE
| MPC52xx_PSC_RX_DISABLE
);
361 /* Disable psc interrupts all useful interrupts are in fifo */
362 out_be16(&psc
->isr_imr
.imr
, 0);
364 /* Disable fifo interrupts, will be enabled later */
365 out_be32(&fifo
->tximr
, 0);
366 out_be32(&fifo
->rximr
, 0);
368 /* Setup fifo slice address and size */
369 /*out_be32(&fifo->txsz, 0x0fe00004);*/
370 /*out_be32(&fifo->rxsz, 0x0ff00004);*/
372 sicr
= 0x01000000 | /* SIM = 0001 -- 8 bit */
373 0x00800000 | /* GenClk = 1 -- internal clk */
374 0x00008000 | /* SPI = 1 */
375 0x00004000 | /* MSTR = 1 -- SPI master */
376 0x00000800; /* UseEOF = 1 -- SS low until EOF */
378 out_be32(&psc
->sicr
, sicr
);
380 ccr
= in_be32(&psc
->ccr
);
382 bclkdiv
= (mps
->mclk
/ 1000000) - 1; /* default 1MHz */
383 ccr
|= (((bclkdiv
& 0xff) << 16) | (((bclkdiv
>> 8) & 0xff) << 8));
384 out_be32(&psc
->ccr
, ccr
);
386 /* Set 2ms DTL delay */
387 out_8(&psc
->ctur
, 0x00);
388 out_8(&psc
->ctlr
, 0x82);
390 /* we don't use the alarms */
391 out_be32(&fifo
->rxalarm
, 0xfff);
392 out_be32(&fifo
->txalarm
, 0);
394 /* Enable FIFO slices for Rx/Tx */
395 out_be32(&fifo
->rxcmd
,
396 MPC512x_PSC_FIFO_ENABLE_SLICE
| MPC512x_PSC_FIFO_ENABLE_DMA
);
397 out_be32(&fifo
->txcmd
,
398 MPC512x_PSC_FIFO_ENABLE_SLICE
| MPC512x_PSC_FIFO_ENABLE_DMA
);
400 mps
->bits_per_word
= 8;
405 static irqreturn_t
mpc512x_psc_spi_isr(int irq
, void *dev_id
)
407 struct mpc512x_psc_spi
*mps
= (struct mpc512x_psc_spi
*)dev_id
;
408 struct mpc512x_psc_fifo __iomem
*fifo
= mps
->fifo
;
410 /* clear interrupt and wake up the work queue */
411 if (in_be32(&fifo
->txisr
) &
412 in_be32(&fifo
->tximr
) & MPC512x_PSC_FIFO_EMPTY
) {
413 out_be32(&fifo
->txisr
, MPC512x_PSC_FIFO_EMPTY
);
414 out_be32(&fifo
->tximr
, 0);
415 complete(&mps
->done
);
421 static void mpc512x_spi_cs_control(struct spi_device
*spi
, bool onoff
)
423 gpio_set_value(spi
->cs_gpio
, onoff
);
426 /* bus_num is used only for the case dev->platform_data == NULL */
427 static int mpc512x_psc_spi_do_probe(struct device
*dev
, u32 regaddr
,
428 u32 size
, unsigned int irq
,
431 struct fsl_spi_platform_data
*pdata
= dev
->platform_data
;
432 struct mpc512x_psc_spi
*mps
;
433 struct spi_master
*master
;
437 master
= spi_alloc_master(dev
, sizeof *mps
);
441 dev_set_drvdata(dev
, master
);
442 mps
= spi_master_get_devdata(master
);
446 mps
->cs_control
= mpc512x_spi_cs_control
;
448 master
->bus_num
= bus_num
;
450 mps
->cs_control
= pdata
->cs_control
;
451 mps
->sysclk
= pdata
->sysclk
;
452 master
->bus_num
= pdata
->bus_num
;
453 master
->num_chipselect
= pdata
->max_chipselect
;
456 master
->mode_bits
= SPI_CPOL
| SPI_CPHA
| SPI_CS_HIGH
| SPI_LSB_FIRST
;
457 master
->setup
= mpc512x_psc_spi_setup
;
458 master
->transfer
= mpc512x_psc_spi_transfer
;
459 master
->cleanup
= mpc512x_psc_spi_cleanup
;
460 master
->dev
.of_node
= dev
->of_node
;
462 tempp
= ioremap(regaddr
, size
);
464 dev_err(dev
, "could not ioremap I/O port range\n");
470 (struct mpc512x_psc_fifo
*)(tempp
+ sizeof(struct mpc52xx_psc
));
472 ret
= request_irq(mps
->irq
, mpc512x_psc_spi_isr
, IRQF_SHARED
,
473 "mpc512x-psc-spi", mps
);
477 ret
= mpc512x_psc_spi_port_config(master
, mps
);
481 spin_lock_init(&mps
->lock
);
482 init_completion(&mps
->done
);
483 INIT_WORK(&mps
->work
, mpc512x_psc_spi_work
);
484 INIT_LIST_HEAD(&mps
->queue
);
487 create_singlethread_workqueue(dev_name(master
->dev
.parent
));
488 if (mps
->workqueue
== NULL
) {
493 ret
= spi_register_master(master
);
500 destroy_workqueue(mps
->workqueue
);
502 free_irq(mps
->irq
, mps
);
506 spi_master_put(master
);
511 static int mpc512x_psc_spi_do_remove(struct device
*dev
)
513 struct spi_master
*master
= spi_master_get(dev_get_drvdata(dev
));
514 struct mpc512x_psc_spi
*mps
= spi_master_get_devdata(master
);
516 flush_workqueue(mps
->workqueue
);
517 destroy_workqueue(mps
->workqueue
);
518 spi_unregister_master(master
);
519 free_irq(mps
->irq
, mps
);
522 spi_master_put(master
);
527 static int mpc512x_psc_spi_of_probe(struct platform_device
*op
)
529 const u32
*regaddr_p
;
530 u64 regaddr64
, size64
;
533 regaddr_p
= of_get_address(op
->dev
.of_node
, 0, &size64
, NULL
);
535 dev_err(&op
->dev
, "Invalid PSC address\n");
538 regaddr64
= of_translate_address(op
->dev
.of_node
, regaddr_p
);
540 /* get PSC id (0..11, used by port_config) */
541 id
= of_alias_get_id(op
->dev
.of_node
, "spi");
543 dev_err(&op
->dev
, "no alias id for %s\n",
544 op
->dev
.of_node
->full_name
);
548 return mpc512x_psc_spi_do_probe(&op
->dev
, (u32
) regaddr64
, (u32
) size64
,
549 irq_of_parse_and_map(op
->dev
.of_node
, 0), id
);
552 static int mpc512x_psc_spi_of_remove(struct platform_device
*op
)
554 return mpc512x_psc_spi_do_remove(&op
->dev
);
557 static struct of_device_id mpc512x_psc_spi_of_match
[] = {
558 { .compatible
= "fsl,mpc5121-psc-spi", },
562 MODULE_DEVICE_TABLE(of
, mpc512x_psc_spi_of_match
);
564 static struct platform_driver mpc512x_psc_spi_of_driver
= {
565 .probe
= mpc512x_psc_spi_of_probe
,
566 .remove
= mpc512x_psc_spi_of_remove
,
568 .name
= "mpc512x-psc-spi",
569 .owner
= THIS_MODULE
,
570 .of_match_table
= mpc512x_psc_spi_of_match
,
573 module_platform_driver(mpc512x_psc_spi_of_driver
);
575 MODULE_AUTHOR("John Rigby");
576 MODULE_DESCRIPTION("MPC512x PSC SPI Driver");
577 MODULE_LICENSE("GPL");