2 * Driver for Atmel AT32 and AT91 SPI Controllers
4 * Copyright (C) 2006 Atmel Corporation
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/clk.h>
14 #include <linux/module.h>
15 #include <linux/platform_device.h>
16 #include <linux/delay.h>
17 #include <linux/dma-mapping.h>
18 #include <linux/dmaengine.h>
19 #include <linux/err.h>
20 #include <linux/interrupt.h>
21 #include <linux/spi/spi.h>
22 #include <linux/slab.h>
23 #include <linux/platform_data/atmel.h>
24 #include <linux/platform_data/dma-atmel.h>
28 #include <linux/gpio.h>
30 /* SPI register offsets */
33 #define SPI_RDR 0x0008
34 #define SPI_TDR 0x000c
36 #define SPI_IER 0x0014
37 #define SPI_IDR 0x0018
38 #define SPI_IMR 0x001c
39 #define SPI_CSR0 0x0030
40 #define SPI_CSR1 0x0034
41 #define SPI_CSR2 0x0038
42 #define SPI_CSR3 0x003c
43 #define SPI_VERSION 0x00fc
44 #define SPI_RPR 0x0100
45 #define SPI_RCR 0x0104
46 #define SPI_TPR 0x0108
47 #define SPI_TCR 0x010c
48 #define SPI_RNPR 0x0110
49 #define SPI_RNCR 0x0114
50 #define SPI_TNPR 0x0118
51 #define SPI_TNCR 0x011c
52 #define SPI_PTCR 0x0120
53 #define SPI_PTSR 0x0124
56 #define SPI_SPIEN_OFFSET 0
57 #define SPI_SPIEN_SIZE 1
58 #define SPI_SPIDIS_OFFSET 1
59 #define SPI_SPIDIS_SIZE 1
60 #define SPI_SWRST_OFFSET 7
61 #define SPI_SWRST_SIZE 1
62 #define SPI_LASTXFER_OFFSET 24
63 #define SPI_LASTXFER_SIZE 1
66 #define SPI_MSTR_OFFSET 0
67 #define SPI_MSTR_SIZE 1
68 #define SPI_PS_OFFSET 1
70 #define SPI_PCSDEC_OFFSET 2
71 #define SPI_PCSDEC_SIZE 1
72 #define SPI_FDIV_OFFSET 3
73 #define SPI_FDIV_SIZE 1
74 #define SPI_MODFDIS_OFFSET 4
75 #define SPI_MODFDIS_SIZE 1
76 #define SPI_WDRBT_OFFSET 5
77 #define SPI_WDRBT_SIZE 1
78 #define SPI_LLB_OFFSET 7
79 #define SPI_LLB_SIZE 1
80 #define SPI_PCS_OFFSET 16
81 #define SPI_PCS_SIZE 4
82 #define SPI_DLYBCS_OFFSET 24
83 #define SPI_DLYBCS_SIZE 8
85 /* Bitfields in RDR */
86 #define SPI_RD_OFFSET 0
87 #define SPI_RD_SIZE 16
89 /* Bitfields in TDR */
90 #define SPI_TD_OFFSET 0
91 #define SPI_TD_SIZE 16
94 #define SPI_RDRF_OFFSET 0
95 #define SPI_RDRF_SIZE 1
96 #define SPI_TDRE_OFFSET 1
97 #define SPI_TDRE_SIZE 1
98 #define SPI_MODF_OFFSET 2
99 #define SPI_MODF_SIZE 1
100 #define SPI_OVRES_OFFSET 3
101 #define SPI_OVRES_SIZE 1
102 #define SPI_ENDRX_OFFSET 4
103 #define SPI_ENDRX_SIZE 1
104 #define SPI_ENDTX_OFFSET 5
105 #define SPI_ENDTX_SIZE 1
106 #define SPI_RXBUFF_OFFSET 6
107 #define SPI_RXBUFF_SIZE 1
108 #define SPI_TXBUFE_OFFSET 7
109 #define SPI_TXBUFE_SIZE 1
110 #define SPI_NSSR_OFFSET 8
111 #define SPI_NSSR_SIZE 1
112 #define SPI_TXEMPTY_OFFSET 9
113 #define SPI_TXEMPTY_SIZE 1
114 #define SPI_SPIENS_OFFSET 16
115 #define SPI_SPIENS_SIZE 1
117 /* Bitfields in CSR0 */
118 #define SPI_CPOL_OFFSET 0
119 #define SPI_CPOL_SIZE 1
120 #define SPI_NCPHA_OFFSET 1
121 #define SPI_NCPHA_SIZE 1
122 #define SPI_CSAAT_OFFSET 3
123 #define SPI_CSAAT_SIZE 1
124 #define SPI_BITS_OFFSET 4
125 #define SPI_BITS_SIZE 4
126 #define SPI_SCBR_OFFSET 8
127 #define SPI_SCBR_SIZE 8
128 #define SPI_DLYBS_OFFSET 16
129 #define SPI_DLYBS_SIZE 8
130 #define SPI_DLYBCT_OFFSET 24
131 #define SPI_DLYBCT_SIZE 8
133 /* Bitfields in RCR */
134 #define SPI_RXCTR_OFFSET 0
135 #define SPI_RXCTR_SIZE 16
137 /* Bitfields in TCR */
138 #define SPI_TXCTR_OFFSET 0
139 #define SPI_TXCTR_SIZE 16
141 /* Bitfields in RNCR */
142 #define SPI_RXNCR_OFFSET 0
143 #define SPI_RXNCR_SIZE 16
145 /* Bitfields in TNCR */
146 #define SPI_TXNCR_OFFSET 0
147 #define SPI_TXNCR_SIZE 16
149 /* Bitfields in PTCR */
150 #define SPI_RXTEN_OFFSET 0
151 #define SPI_RXTEN_SIZE 1
152 #define SPI_RXTDIS_OFFSET 1
153 #define SPI_RXTDIS_SIZE 1
154 #define SPI_TXTEN_OFFSET 8
155 #define SPI_TXTEN_SIZE 1
156 #define SPI_TXTDIS_OFFSET 9
157 #define SPI_TXTDIS_SIZE 1
159 /* Constants for BITS */
160 #define SPI_BITS_8_BPT 0
161 #define SPI_BITS_9_BPT 1
162 #define SPI_BITS_10_BPT 2
163 #define SPI_BITS_11_BPT 3
164 #define SPI_BITS_12_BPT 4
165 #define SPI_BITS_13_BPT 5
166 #define SPI_BITS_14_BPT 6
167 #define SPI_BITS_15_BPT 7
168 #define SPI_BITS_16_BPT 8
170 /* Bit manipulation macros */
171 #define SPI_BIT(name) \
172 (1 << SPI_##name##_OFFSET)
173 #define SPI_BF(name,value) \
174 (((value) & ((1 << SPI_##name##_SIZE) - 1)) << SPI_##name##_OFFSET)
175 #define SPI_BFEXT(name,value) \
176 (((value) >> SPI_##name##_OFFSET) & ((1 << SPI_##name##_SIZE) - 1))
177 #define SPI_BFINS(name,value,old) \
178 ( ((old) & ~(((1 << SPI_##name##_SIZE) - 1) << SPI_##name##_OFFSET)) \
179 | SPI_BF(name,value))
181 /* Register access macros */
182 #define spi_readl(port,reg) \
183 __raw_readl((port)->regs + SPI_##reg)
184 #define spi_writel(port,reg,value) \
185 __raw_writel((value), (port)->regs + SPI_##reg)
187 /* use PIO for small transfers, avoiding DMA setup/teardown overhead and
188 * cache operations; better heuristics consider wordsize and bitrate.
190 #define DMA_MIN_BYTES 16
192 struct atmel_spi_dma
{
193 struct dma_chan
*chan_rx
;
194 struct dma_chan
*chan_tx
;
195 struct scatterlist sgrx
;
196 struct scatterlist sgtx
;
197 struct dma_async_tx_descriptor
*data_desc_rx
;
198 struct dma_async_tx_descriptor
*data_desc_tx
;
200 struct at_dma_slave dma_slave
;
203 struct atmel_spi_caps
{
206 bool has_dma_support
;
210 * The core SPI transfer engine just talks to a register bank to set up
211 * DMA transfers; transfer queue progress is driven by IRQs. The clock
212 * framework provides the base clock, subdivided for each spi_device.
222 struct platform_device
*pdev
;
223 struct spi_device
*stay
;
226 struct list_head queue
;
227 struct tasklet_struct tasklet
;
228 struct spi_transfer
*current_transfer
;
229 unsigned long current_remaining_bytes
;
230 struct spi_transfer
*next_transfer
;
231 unsigned long next_remaining_bytes
;
236 dma_addr_t buffer_dma
;
238 struct atmel_spi_caps caps
;
243 struct atmel_spi_dma dma
;
246 /* Controller-specific per-slave state */
247 struct atmel_spi_device
{
248 unsigned int npcs_pin
;
252 #define BUFFER_SIZE PAGE_SIZE
253 #define INVALID_DMA_ADDRESS 0xffffffff
256 * Version 2 of the SPI controller has
258 * - SPI_MR.DIV32 may become FDIV or must-be-zero (here: always zero)
259 * - SPI_SR.TXEMPTY, SPI_SR.NSSR (and corresponding irqs)
261 * - SPI_CSRx.SBCR allows faster clocking
263 static bool atmel_spi_is_v2(struct atmel_spi
*as
)
265 return as
->caps
.is_spi2
;
269 * Earlier SPI controllers (e.g. on at91rm9200) have a design bug whereby
270 * they assume that spi slave device state will not change on deselect, so
271 * that automagic deselection is OK. ("NPCSx rises if no data is to be
272 * transmitted") Not so! Workaround uses nCSx pins as GPIOs; or newer
273 * controllers have CSAAT and friends.
275 * Since the CSAAT functionality is a bit weird on newer controllers as
276 * well, we use GPIO to control nCSx pins on all controllers, updating
277 * MR.PCS to avoid confusing the controller. Using GPIOs also lets us
278 * support active-high chipselects despite the controller's belief that
279 * only active-low devices/systems exists.
281 * However, at91rm9200 has a second erratum whereby nCS0 doesn't work
282 * right when driven with GPIO. ("Mode Fault does not allow more than one
283 * Master on Chip Select 0.") No workaround exists for that ... so for
284 * nCS0 on that chip, we (a) don't use the GPIO, (b) can't support CS_HIGH,
285 * and (c) will trigger that first erratum in some cases.
288 static void cs_activate(struct atmel_spi
*as
, struct spi_device
*spi
)
290 struct atmel_spi_device
*asd
= spi
->controller_state
;
291 unsigned active
= spi
->mode
& SPI_CS_HIGH
;
294 if (atmel_spi_is_v2(as
)) {
295 spi_writel(as
, CSR0
+ 4 * spi
->chip_select
, asd
->csr
);
296 /* For the low SPI version, there is a issue that PDC transfer
297 * on CS1,2,3 needs SPI_CSR0.BITS config as SPI_CSR1,2,3.BITS
299 spi_writel(as
, CSR0
, asd
->csr
);
300 if (as
->caps
.has_wdrbt
) {
302 SPI_BF(PCS
, ~(0x01 << spi
->chip_select
))
308 SPI_BF(PCS
, ~(0x01 << spi
->chip_select
))
313 mr
= spi_readl(as
, MR
);
314 gpio_set_value(asd
->npcs_pin
, active
);
316 u32 cpol
= (spi
->mode
& SPI_CPOL
) ? SPI_BIT(CPOL
) : 0;
320 /* Make sure clock polarity is correct */
321 for (i
= 0; i
< spi
->master
->num_chipselect
; i
++) {
322 csr
= spi_readl(as
, CSR0
+ 4 * i
);
323 if ((csr
^ cpol
) & SPI_BIT(CPOL
))
324 spi_writel(as
, CSR0
+ 4 * i
,
325 csr
^ SPI_BIT(CPOL
));
328 mr
= spi_readl(as
, MR
);
329 mr
= SPI_BFINS(PCS
, ~(1 << spi
->chip_select
), mr
);
330 if (spi
->chip_select
!= 0)
331 gpio_set_value(asd
->npcs_pin
, active
);
332 spi_writel(as
, MR
, mr
);
335 dev_dbg(&spi
->dev
, "activate %u%s, mr %08x\n",
336 asd
->npcs_pin
, active
? " (high)" : "",
340 static void cs_deactivate(struct atmel_spi
*as
, struct spi_device
*spi
)
342 struct atmel_spi_device
*asd
= spi
->controller_state
;
343 unsigned active
= spi
->mode
& SPI_CS_HIGH
;
346 /* only deactivate *this* device; sometimes transfers to
347 * another device may be active when this routine is called.
349 mr
= spi_readl(as
, MR
);
350 if (~SPI_BFEXT(PCS
, mr
) & (1 << spi
->chip_select
)) {
351 mr
= SPI_BFINS(PCS
, 0xf, mr
);
352 spi_writel(as
, MR
, mr
);
355 dev_dbg(&spi
->dev
, "DEactivate %u%s, mr %08x\n",
356 asd
->npcs_pin
, active
? " (low)" : "",
359 if (atmel_spi_is_v2(as
) || spi
->chip_select
!= 0)
360 gpio_set_value(asd
->npcs_pin
, !active
);
363 static void atmel_spi_lock(struct atmel_spi
*as
)
365 spin_lock_irqsave(&as
->lock
, as
->flags
);
368 static void atmel_spi_unlock(struct atmel_spi
*as
)
370 spin_unlock_irqrestore(&as
->lock
, as
->flags
);
373 static inline bool atmel_spi_use_dma(struct atmel_spi
*as
,
374 struct spi_transfer
*xfer
)
376 return as
->use_dma
&& xfer
->len
>= DMA_MIN_BYTES
;
379 static inline int atmel_spi_xfer_is_last(struct spi_message
*msg
,
380 struct spi_transfer
*xfer
)
382 return msg
->transfers
.prev
== &xfer
->transfer_list
;
385 static inline int atmel_spi_xfer_can_be_chained(struct spi_transfer
*xfer
)
387 return xfer
->delay_usecs
== 0 && !xfer
->cs_change
;
390 static int atmel_spi_dma_slave_config(struct atmel_spi
*as
,
391 struct dma_slave_config
*slave_config
,
396 if (bits_per_word
> 8) {
397 slave_config
->dst_addr_width
= DMA_SLAVE_BUSWIDTH_2_BYTES
;
398 slave_config
->src_addr_width
= DMA_SLAVE_BUSWIDTH_2_BYTES
;
400 slave_config
->dst_addr_width
= DMA_SLAVE_BUSWIDTH_1_BYTE
;
401 slave_config
->src_addr_width
= DMA_SLAVE_BUSWIDTH_1_BYTE
;
404 slave_config
->dst_addr
= (dma_addr_t
)as
->phybase
+ SPI_TDR
;
405 slave_config
->src_addr
= (dma_addr_t
)as
->phybase
+ SPI_RDR
;
406 slave_config
->src_maxburst
= 1;
407 slave_config
->dst_maxburst
= 1;
408 slave_config
->device_fc
= false;
410 slave_config
->direction
= DMA_MEM_TO_DEV
;
411 if (dmaengine_slave_config(as
->dma
.chan_tx
, slave_config
)) {
412 dev_err(&as
->pdev
->dev
,
413 "failed to configure tx dma channel\n");
417 slave_config
->direction
= DMA_DEV_TO_MEM
;
418 if (dmaengine_slave_config(as
->dma
.chan_rx
, slave_config
)) {
419 dev_err(&as
->pdev
->dev
,
420 "failed to configure rx dma channel\n");
427 static bool filter(struct dma_chan
*chan
, void *slave
)
429 struct at_dma_slave
*sl
= slave
;
431 if (sl
->dma_dev
== chan
->device
->dev
) {
439 static int atmel_spi_configure_dma(struct atmel_spi
*as
)
441 struct at_dma_slave
*sdata
= &as
->dma
.dma_slave
;
442 struct dma_slave_config slave_config
;
445 if (sdata
&& sdata
->dma_dev
) {
448 /* Try to grab two DMA channels */
450 dma_cap_set(DMA_SLAVE
, mask
);
451 as
->dma
.chan_tx
= dma_request_channel(mask
, filter
, sdata
);
454 dma_request_channel(mask
, filter
, sdata
);
456 if (!as
->dma
.chan_rx
|| !as
->dma
.chan_tx
) {
457 dev_err(&as
->pdev
->dev
,
458 "DMA channel not available, SPI unable to use DMA\n");
463 err
= atmel_spi_dma_slave_config(as
, &slave_config
, 8);
467 dev_info(&as
->pdev
->dev
,
468 "Using %s (tx) and %s (rx) for DMA transfers\n",
469 dma_chan_name(as
->dma
.chan_tx
),
470 dma_chan_name(as
->dma
.chan_rx
));
474 dma_release_channel(as
->dma
.chan_rx
);
476 dma_release_channel(as
->dma
.chan_tx
);
480 static void atmel_spi_stop_dma(struct atmel_spi
*as
)
483 as
->dma
.chan_rx
->device
->device_control(as
->dma
.chan_rx
,
484 DMA_TERMINATE_ALL
, 0);
486 as
->dma
.chan_tx
->device
->device_control(as
->dma
.chan_tx
,
487 DMA_TERMINATE_ALL
, 0);
490 static void atmel_spi_release_dma(struct atmel_spi
*as
)
493 dma_release_channel(as
->dma
.chan_rx
);
495 dma_release_channel(as
->dma
.chan_tx
);
498 /* This function is called by the DMA driver from tasklet context */
499 static void dma_callback(void *data
)
501 struct spi_master
*master
= data
;
502 struct atmel_spi
*as
= spi_master_get_devdata(master
);
504 /* trigger SPI tasklet */
505 tasklet_schedule(&as
->tasklet
);
509 * Next transfer using PIO.
510 * lock is held, spi tasklet is blocked
512 static void atmel_spi_next_xfer_pio(struct spi_master
*master
,
513 struct spi_transfer
*xfer
)
515 struct atmel_spi
*as
= spi_master_get_devdata(master
);
517 dev_vdbg(master
->dev
.parent
, "atmel_spi_next_xfer_pio\n");
519 as
->current_remaining_bytes
= xfer
->len
;
521 /* Make sure data is not remaining in RDR */
523 while (spi_readl(as
, SR
) & SPI_BIT(RDRF
)) {
529 if (xfer
->bits_per_word
> 8)
530 spi_writel(as
, TDR
, *(u16
*)(xfer
->tx_buf
));
532 spi_writel(as
, TDR
, *(u8
*)(xfer
->tx_buf
));
534 spi_writel(as
, TDR
, 0);
536 dev_dbg(master
->dev
.parent
,
537 " start pio xfer %p: len %u tx %p rx %p bitpw %d\n",
538 xfer
, xfer
->len
, xfer
->tx_buf
, xfer
->rx_buf
,
539 xfer
->bits_per_word
);
541 /* Enable relevant interrupts */
542 spi_writel(as
, IER
, SPI_BIT(RDRF
) | SPI_BIT(OVRES
));
546 * Submit next transfer for DMA.
547 * lock is held, spi tasklet is blocked
549 static int atmel_spi_next_xfer_dma_submit(struct spi_master
*master
,
550 struct spi_transfer
*xfer
,
553 struct atmel_spi
*as
= spi_master_get_devdata(master
);
554 struct dma_chan
*rxchan
= as
->dma
.chan_rx
;
555 struct dma_chan
*txchan
= as
->dma
.chan_tx
;
556 struct dma_async_tx_descriptor
*rxdesc
;
557 struct dma_async_tx_descriptor
*txdesc
;
558 struct dma_slave_config slave_config
;
562 dev_vdbg(master
->dev
.parent
, "atmel_spi_next_xfer_dma_submit\n");
564 /* Check that the channels are available */
565 if (!rxchan
|| !txchan
)
568 /* release lock for DMA operations */
569 atmel_spi_unlock(as
);
571 /* prepare the RX dma transfer */
572 sg_init_table(&as
->dma
.sgrx
, 1);
574 as
->dma
.sgrx
.dma_address
= xfer
->rx_dma
+ xfer
->len
- *plen
;
576 as
->dma
.sgrx
.dma_address
= as
->buffer_dma
;
577 if (len
> BUFFER_SIZE
)
581 /* prepare the TX dma transfer */
582 sg_init_table(&as
->dma
.sgtx
, 1);
584 as
->dma
.sgtx
.dma_address
= xfer
->tx_dma
+ xfer
->len
- *plen
;
586 as
->dma
.sgtx
.dma_address
= as
->buffer_dma
;
587 if (len
> BUFFER_SIZE
)
589 memset(as
->buffer
, 0, len
);
592 sg_dma_len(&as
->dma
.sgtx
) = len
;
593 sg_dma_len(&as
->dma
.sgrx
) = len
;
597 if (atmel_spi_dma_slave_config(as
, &slave_config
, 8))
600 /* Send both scatterlists */
601 rxdesc
= rxchan
->device
->device_prep_slave_sg(rxchan
,
605 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
,
610 txdesc
= txchan
->device
->device_prep_slave_sg(txchan
,
614 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
,
619 dev_dbg(master
->dev
.parent
,
620 " start dma xfer %p: len %u tx %p/%08x rx %p/%08x\n",
621 xfer
, xfer
->len
, xfer
->tx_buf
, xfer
->tx_dma
,
622 xfer
->rx_buf
, xfer
->rx_dma
);
624 /* Enable relevant interrupts */
625 spi_writel(as
, IER
, SPI_BIT(OVRES
));
627 /* Put the callback on the RX transfer only, that should finish last */
628 rxdesc
->callback
= dma_callback
;
629 rxdesc
->callback_param
= master
;
631 /* Submit and fire RX and TX with TX last so we're ready to read! */
632 cookie
= rxdesc
->tx_submit(rxdesc
);
633 if (dma_submit_error(cookie
))
635 cookie
= txdesc
->tx_submit(txdesc
);
636 if (dma_submit_error(cookie
))
638 rxchan
->device
->device_issue_pending(rxchan
);
639 txchan
->device
->device_issue_pending(txchan
);
646 spi_writel(as
, IDR
, SPI_BIT(OVRES
));
647 atmel_spi_stop_dma(as
);
653 static void atmel_spi_next_xfer_data(struct spi_master
*master
,
654 struct spi_transfer
*xfer
,
659 struct atmel_spi
*as
= spi_master_get_devdata(master
);
662 /* use scratch buffer only when rx or tx data is unspecified */
664 *rx_dma
= xfer
->rx_dma
+ xfer
->len
- *plen
;
666 *rx_dma
= as
->buffer_dma
;
667 if (len
> BUFFER_SIZE
)
672 *tx_dma
= xfer
->tx_dma
+ xfer
->len
- *plen
;
674 *tx_dma
= as
->buffer_dma
;
675 if (len
> BUFFER_SIZE
)
677 memset(as
->buffer
, 0, len
);
678 dma_sync_single_for_device(&as
->pdev
->dev
,
679 as
->buffer_dma
, len
, DMA_TO_DEVICE
);
686 * Submit next transfer for PDC.
687 * lock is held, spi irq is blocked
689 static void atmel_spi_pdc_next_xfer(struct spi_master
*master
,
690 struct spi_message
*msg
)
692 struct atmel_spi
*as
= spi_master_get_devdata(master
);
693 struct spi_transfer
*xfer
;
696 dma_addr_t tx_dma
, rx_dma
;
698 if (!as
->current_transfer
)
699 xfer
= list_entry(msg
->transfers
.next
,
700 struct spi_transfer
, transfer_list
);
701 else if (!as
->next_transfer
)
702 xfer
= list_entry(as
->current_transfer
->transfer_list
.next
,
703 struct spi_transfer
, transfer_list
);
708 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
711 atmel_spi_next_xfer_data(master
, xfer
, &tx_dma
, &rx_dma
, &len
);
712 remaining
= xfer
->len
- len
;
714 spi_writel(as
, RPR
, rx_dma
);
715 spi_writel(as
, TPR
, tx_dma
);
717 if (msg
->spi
->bits_per_word
> 8)
719 spi_writel(as
, RCR
, len
);
720 spi_writel(as
, TCR
, len
);
722 dev_dbg(&msg
->spi
->dev
,
723 " start xfer %p: len %u tx %p/%08x rx %p/%08x\n",
724 xfer
, xfer
->len
, xfer
->tx_buf
, xfer
->tx_dma
,
725 xfer
->rx_buf
, xfer
->rx_dma
);
727 xfer
= as
->next_transfer
;
728 remaining
= as
->next_remaining_bytes
;
731 as
->current_transfer
= xfer
;
732 as
->current_remaining_bytes
= remaining
;
736 else if (!atmel_spi_xfer_is_last(msg
, xfer
)
737 && atmel_spi_xfer_can_be_chained(xfer
)) {
738 xfer
= list_entry(xfer
->transfer_list
.next
,
739 struct spi_transfer
, transfer_list
);
744 as
->next_transfer
= xfer
;
750 atmel_spi_next_xfer_data(master
, xfer
, &tx_dma
, &rx_dma
, &len
);
751 as
->next_remaining_bytes
= total
- len
;
753 spi_writel(as
, RNPR
, rx_dma
);
754 spi_writel(as
, TNPR
, tx_dma
);
756 if (msg
->spi
->bits_per_word
> 8)
758 spi_writel(as
, RNCR
, len
);
759 spi_writel(as
, TNCR
, len
);
761 dev_dbg(&msg
->spi
->dev
,
762 " next xfer %p: len %u tx %p/%08x rx %p/%08x\n",
763 xfer
, xfer
->len
, xfer
->tx_buf
, xfer
->tx_dma
,
764 xfer
->rx_buf
, xfer
->rx_dma
);
765 ieval
= SPI_BIT(ENDRX
) | SPI_BIT(OVRES
);
767 spi_writel(as
, RNCR
, 0);
768 spi_writel(as
, TNCR
, 0);
769 ieval
= SPI_BIT(RXBUFF
) | SPI_BIT(ENDRX
) | SPI_BIT(OVRES
);
772 /* REVISIT: We're waiting for ENDRX before we start the next
773 * transfer because we need to handle some difficult timing
774 * issues otherwise. If we wait for ENDTX in one transfer and
775 * then starts waiting for ENDRX in the next, it's difficult
776 * to tell the difference between the ENDRX interrupt we're
777 * actually waiting for and the ENDRX interrupt of the
780 * It should be doable, though. Just not now...
782 spi_writel(as
, IER
, ieval
);
783 spi_writel(as
, PTCR
, SPI_BIT(TXTEN
) | SPI_BIT(RXTEN
));
787 * Choose way to submit next transfer and start it.
788 * lock is held, spi tasklet is blocked
790 static void atmel_spi_dma_next_xfer(struct spi_master
*master
,
791 struct spi_message
*msg
)
793 struct atmel_spi
*as
= spi_master_get_devdata(master
);
794 struct spi_transfer
*xfer
;
797 remaining
= as
->current_remaining_bytes
;
799 xfer
= as
->current_transfer
;
802 if (!as
->current_transfer
)
803 xfer
= list_entry(msg
->transfers
.next
,
804 struct spi_transfer
, transfer_list
);
807 as
->current_transfer
->transfer_list
.next
,
808 struct spi_transfer
, transfer_list
);
810 as
->current_transfer
= xfer
;
814 if (atmel_spi_use_dma(as
, xfer
)) {
816 if (!atmel_spi_next_xfer_dma_submit(master
, xfer
, &len
)) {
817 as
->current_remaining_bytes
= total
- len
;
820 dev_err(&msg
->spi
->dev
, "unable to use DMA, fallback to PIO\n");
824 /* use PIO if error appened using DMA */
825 atmel_spi_next_xfer_pio(master
, xfer
);
828 static void atmel_spi_next_message(struct spi_master
*master
)
830 struct atmel_spi
*as
= spi_master_get_devdata(master
);
831 struct spi_message
*msg
;
832 struct spi_device
*spi
;
834 BUG_ON(as
->current_transfer
);
836 msg
= list_entry(as
->queue
.next
, struct spi_message
, queue
);
839 dev_dbg(master
->dev
.parent
, "start message %p for %s\n",
840 msg
, dev_name(&spi
->dev
));
842 /* select chip if it's not still active */
844 if (as
->stay
!= spi
) {
845 cs_deactivate(as
, as
->stay
);
846 cs_activate(as
, spi
);
850 cs_activate(as
, spi
);
853 atmel_spi_pdc_next_xfer(master
, msg
);
855 atmel_spi_dma_next_xfer(master
, msg
);
859 * For DMA, tx_buf/tx_dma have the same relationship as rx_buf/rx_dma:
860 * - The buffer is either valid for CPU access, else NULL
861 * - If the buffer is valid, so is its DMA address
863 * This driver manages the dma address unless message->is_dma_mapped.
866 atmel_spi_dma_map_xfer(struct atmel_spi
*as
, struct spi_transfer
*xfer
)
868 struct device
*dev
= &as
->pdev
->dev
;
870 xfer
->tx_dma
= xfer
->rx_dma
= INVALID_DMA_ADDRESS
;
872 /* tx_buf is a const void* where we need a void * for the dma
874 void *nonconst_tx
= (void *)xfer
->tx_buf
;
876 xfer
->tx_dma
= dma_map_single(dev
,
877 nonconst_tx
, xfer
->len
,
879 if (dma_mapping_error(dev
, xfer
->tx_dma
))
883 xfer
->rx_dma
= dma_map_single(dev
,
884 xfer
->rx_buf
, xfer
->len
,
886 if (dma_mapping_error(dev
, xfer
->rx_dma
)) {
888 dma_unmap_single(dev
,
889 xfer
->tx_dma
, xfer
->len
,
897 static void atmel_spi_dma_unmap_xfer(struct spi_master
*master
,
898 struct spi_transfer
*xfer
)
900 if (xfer
->tx_dma
!= INVALID_DMA_ADDRESS
)
901 dma_unmap_single(master
->dev
.parent
, xfer
->tx_dma
,
902 xfer
->len
, DMA_TO_DEVICE
);
903 if (xfer
->rx_dma
!= INVALID_DMA_ADDRESS
)
904 dma_unmap_single(master
->dev
.parent
, xfer
->rx_dma
,
905 xfer
->len
, DMA_FROM_DEVICE
);
908 static void atmel_spi_disable_pdc_transfer(struct atmel_spi
*as
)
910 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
914 atmel_spi_msg_done(struct spi_master
*master
, struct atmel_spi
*as
,
915 struct spi_message
*msg
, int stay
)
917 if (!stay
|| as
->done_status
< 0)
918 cs_deactivate(as
, msg
->spi
);
922 list_del(&msg
->queue
);
923 msg
->status
= as
->done_status
;
925 dev_dbg(master
->dev
.parent
,
926 "xfer complete: %u bytes transferred\n",
929 atmel_spi_unlock(as
);
930 msg
->complete(msg
->context
);
933 as
->current_transfer
= NULL
;
934 as
->next_transfer
= NULL
;
937 /* continue if needed */
938 if (list_empty(&as
->queue
) || as
->stopping
) {
940 atmel_spi_disable_pdc_transfer(as
);
942 atmel_spi_next_message(master
);
949 * Must update "current_remaining_bytes" to keep track of data
953 atmel_spi_pump_pio_data(struct atmel_spi
*as
, struct spi_transfer
*xfer
)
959 unsigned long xfer_pos
= xfer
->len
- as
->current_remaining_bytes
;
962 if (xfer
->bits_per_word
> 8) {
963 rxp16
= (u16
*)(((u8
*)xfer
->rx_buf
) + xfer_pos
);
964 *rxp16
= spi_readl(as
, RDR
);
966 rxp
= ((u8
*)xfer
->rx_buf
) + xfer_pos
;
967 *rxp
= spi_readl(as
, RDR
);
972 if (xfer
->bits_per_word
> 8) {
973 as
->current_remaining_bytes
-= 2;
974 if (as
->current_remaining_bytes
< 0)
975 as
->current_remaining_bytes
= 0;
977 as
->current_remaining_bytes
--;
980 if (as
->current_remaining_bytes
) {
982 if (xfer
->bits_per_word
> 8) {
983 txp16
= (u16
*)(((u8
*)xfer
->tx_buf
)
985 spi_writel(as
, TDR
, *txp16
);
987 txp
= ((u8
*)xfer
->tx_buf
) + xfer_pos
+ 1;
988 spi_writel(as
, TDR
, *txp
);
991 spi_writel(as
, TDR
, 0);
997 * Called from DMA callback + pio transfer and overrun IRQ.
999 static void atmel_spi_tasklet_func(unsigned long data
)
1001 struct spi_master
*master
= (struct spi_master
*)data
;
1002 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1003 struct spi_message
*msg
;
1004 struct spi_transfer
*xfer
;
1006 dev_vdbg(master
->dev
.parent
, "atmel_spi_tasklet_func\n");
1010 xfer
= as
->current_transfer
;
1013 /* already been there */
1016 msg
= list_entry(as
->queue
.next
, struct spi_message
, queue
);
1018 if (as
->current_remaining_bytes
== 0) {
1019 if (as
->done_status
< 0) {
1020 /* error happened (overrun) */
1021 if (atmel_spi_use_dma(as
, xfer
))
1022 atmel_spi_stop_dma(as
);
1024 /* only update length if no error */
1025 msg
->actual_length
+= xfer
->len
;
1028 if (atmel_spi_use_dma(as
, xfer
))
1029 if (!msg
->is_dma_mapped
)
1030 atmel_spi_dma_unmap_xfer(master
, xfer
);
1032 if (xfer
->delay_usecs
)
1033 udelay(xfer
->delay_usecs
);
1035 if (atmel_spi_xfer_is_last(msg
, xfer
) || as
->done_status
< 0) {
1036 /* report completed (or erroneous) message */
1037 atmel_spi_msg_done(master
, as
, msg
, xfer
->cs_change
);
1039 if (xfer
->cs_change
) {
1040 cs_deactivate(as
, msg
->spi
);
1042 cs_activate(as
, msg
->spi
);
1046 * Not done yet. Submit the next transfer.
1048 * FIXME handle protocol options for xfer
1050 atmel_spi_dma_next_xfer(master
, msg
);
1054 * Keep going, we still have data to send in
1055 * the current transfer.
1057 atmel_spi_dma_next_xfer(master
, msg
);
1061 atmel_spi_unlock(as
);
1066 * No need for locking in this Interrupt handler: done_status is the
1067 * only information modified. What we need is the update of this field
1068 * before tasklet runs. This is ensured by using barrier.
1071 atmel_spi_pio_interrupt(int irq
, void *dev_id
)
1073 struct spi_master
*master
= dev_id
;
1074 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1075 u32 status
, pending
, imr
;
1076 struct spi_transfer
*xfer
;
1079 imr
= spi_readl(as
, IMR
);
1080 status
= spi_readl(as
, SR
);
1081 pending
= status
& imr
;
1083 if (pending
& SPI_BIT(OVRES
)) {
1085 spi_writel(as
, IDR
, SPI_BIT(OVRES
));
1086 dev_warn(master
->dev
.parent
, "overrun\n");
1089 * When we get an overrun, we disregard the current
1090 * transfer. Data will not be copied back from any
1091 * bounce buffer and msg->actual_len will not be
1092 * updated with the last xfer.
1094 * We will also not process any remaning transfers in
1097 * All actions are done in tasklet with done_status indication
1099 as
->done_status
= -EIO
;
1102 /* Clear any overrun happening while cleaning up */
1105 tasklet_schedule(&as
->tasklet
);
1107 } else if (pending
& SPI_BIT(RDRF
)) {
1110 if (as
->current_remaining_bytes
) {
1112 xfer
= as
->current_transfer
;
1113 atmel_spi_pump_pio_data(as
, xfer
);
1114 if (!as
->current_remaining_bytes
) {
1115 /* no more data to xfer, kick tasklet */
1116 spi_writel(as
, IDR
, pending
);
1117 tasklet_schedule(&as
->tasklet
);
1121 atmel_spi_unlock(as
);
1123 WARN_ONCE(pending
, "IRQ not handled, pending = %x\n", pending
);
1125 spi_writel(as
, IDR
, pending
);
1132 atmel_spi_pdc_interrupt(int irq
, void *dev_id
)
1134 struct spi_master
*master
= dev_id
;
1135 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1136 struct spi_message
*msg
;
1137 struct spi_transfer
*xfer
;
1138 u32 status
, pending
, imr
;
1143 xfer
= as
->current_transfer
;
1144 msg
= list_entry(as
->queue
.next
, struct spi_message
, queue
);
1146 imr
= spi_readl(as
, IMR
);
1147 status
= spi_readl(as
, SR
);
1148 pending
= status
& imr
;
1150 if (pending
& SPI_BIT(OVRES
)) {
1155 spi_writel(as
, IDR
, (SPI_BIT(RXBUFF
) | SPI_BIT(ENDRX
)
1159 * When we get an overrun, we disregard the current
1160 * transfer. Data will not be copied back from any
1161 * bounce buffer and msg->actual_len will not be
1162 * updated with the last xfer.
1164 * We will also not process any remaning transfers in
1167 * First, stop the transfer and unmap the DMA buffers.
1169 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
1170 if (!msg
->is_dma_mapped
)
1171 atmel_spi_dma_unmap_xfer(master
, xfer
);
1173 /* REVISIT: udelay in irq is unfriendly */
1174 if (xfer
->delay_usecs
)
1175 udelay(xfer
->delay_usecs
);
1177 dev_warn(master
->dev
.parent
, "overrun (%u/%u remaining)\n",
1178 spi_readl(as
, TCR
), spi_readl(as
, RCR
));
1181 * Clean up DMA registers and make sure the data
1182 * registers are empty.
1184 spi_writel(as
, RNCR
, 0);
1185 spi_writel(as
, TNCR
, 0);
1186 spi_writel(as
, RCR
, 0);
1187 spi_writel(as
, TCR
, 0);
1188 for (timeout
= 1000; timeout
; timeout
--)
1189 if (spi_readl(as
, SR
) & SPI_BIT(TXEMPTY
))
1192 dev_warn(master
->dev
.parent
,
1193 "timeout waiting for TXEMPTY");
1194 while (spi_readl(as
, SR
) & SPI_BIT(RDRF
))
1197 /* Clear any overrun happening while cleaning up */
1200 as
->done_status
= -EIO
;
1201 atmel_spi_msg_done(master
, as
, msg
, 0);
1202 } else if (pending
& (SPI_BIT(RXBUFF
) | SPI_BIT(ENDRX
))) {
1205 spi_writel(as
, IDR
, pending
);
1207 if (as
->current_remaining_bytes
== 0) {
1208 msg
->actual_length
+= xfer
->len
;
1210 if (!msg
->is_dma_mapped
)
1211 atmel_spi_dma_unmap_xfer(master
, xfer
);
1213 /* REVISIT: udelay in irq is unfriendly */
1214 if (xfer
->delay_usecs
)
1215 udelay(xfer
->delay_usecs
);
1217 if (atmel_spi_xfer_is_last(msg
, xfer
)) {
1218 /* report completed message */
1219 atmel_spi_msg_done(master
, as
, msg
,
1222 if (xfer
->cs_change
) {
1223 cs_deactivate(as
, msg
->spi
);
1225 cs_activate(as
, msg
->spi
);
1229 * Not done yet. Submit the next transfer.
1231 * FIXME handle protocol options for xfer
1233 atmel_spi_pdc_next_xfer(master
, msg
);
1237 * Keep going, we still have data to send in
1238 * the current transfer.
1240 atmel_spi_pdc_next_xfer(master
, msg
);
1244 atmel_spi_unlock(as
);
1249 static int atmel_spi_setup(struct spi_device
*spi
)
1251 struct atmel_spi
*as
;
1252 struct atmel_spi_device
*asd
;
1254 unsigned int bits
= spi
->bits_per_word
;
1255 unsigned long bus_hz
;
1256 unsigned int npcs_pin
;
1259 as
= spi_master_get_devdata(spi
->master
);
1264 if (spi
->chip_select
> spi
->master
->num_chipselect
) {
1266 "setup: invalid chipselect %u (%u defined)\n",
1267 spi
->chip_select
, spi
->master
->num_chipselect
);
1271 if (bits
< 8 || bits
> 16) {
1273 "setup: invalid bits_per_word %u (8 to 16)\n",
1278 /* see notes above re chipselect */
1279 if (!atmel_spi_is_v2(as
)
1280 && spi
->chip_select
== 0
1281 && (spi
->mode
& SPI_CS_HIGH
)) {
1282 dev_dbg(&spi
->dev
, "setup: can't be active-high\n");
1286 /* v1 chips start out at half the peripheral bus speed. */
1287 bus_hz
= clk_get_rate(as
->clk
);
1288 if (!atmel_spi_is_v2(as
))
1291 if (spi
->max_speed_hz
) {
1293 * Calculate the lowest divider that satisfies the
1294 * constraint, assuming div32/fdiv/mbz == 0.
1296 scbr
= DIV_ROUND_UP(bus_hz
, spi
->max_speed_hz
);
1299 * If the resulting divider doesn't fit into the
1300 * register bitfield, we can't satisfy the constraint.
1302 if (scbr
>= (1 << SPI_SCBR_SIZE
)) {
1304 "setup: %d Hz too slow, scbr %u; min %ld Hz\n",
1305 spi
->max_speed_hz
, scbr
, bus_hz
/255);
1309 /* speed zero means "as slow as possible" */
1312 csr
= SPI_BF(SCBR
, scbr
) | SPI_BF(BITS
, bits
- 8);
1313 if (spi
->mode
& SPI_CPOL
)
1314 csr
|= SPI_BIT(CPOL
);
1315 if (!(spi
->mode
& SPI_CPHA
))
1316 csr
|= SPI_BIT(NCPHA
);
1318 /* DLYBS is mostly irrelevant since we manage chipselect using GPIOs.
1320 * DLYBCT would add delays between words, slowing down transfers.
1321 * It could potentially be useful to cope with DMA bottlenecks, but
1322 * in those cases it's probably best to just use a lower bitrate.
1324 csr
|= SPI_BF(DLYBS
, 0);
1325 csr
|= SPI_BF(DLYBCT
, 0);
1327 /* chipselect must have been muxed as GPIO (e.g. in board setup) */
1328 npcs_pin
= (unsigned int)spi
->controller_data
;
1330 if (gpio_is_valid(spi
->cs_gpio
))
1331 npcs_pin
= spi
->cs_gpio
;
1333 asd
= spi
->controller_state
;
1335 asd
= kzalloc(sizeof(struct atmel_spi_device
), GFP_KERNEL
);
1339 ret
= gpio_request(npcs_pin
, dev_name(&spi
->dev
));
1345 asd
->npcs_pin
= npcs_pin
;
1346 spi
->controller_state
= asd
;
1347 gpio_direction_output(npcs_pin
, !(spi
->mode
& SPI_CS_HIGH
));
1350 if (as
->stay
== spi
)
1352 cs_deactivate(as
, spi
);
1353 atmel_spi_unlock(as
);
1359 "setup: %lu Hz bpw %u mode 0x%x -> csr%d %08x\n",
1360 bus_hz
/ scbr
, bits
, spi
->mode
, spi
->chip_select
, csr
);
1362 if (!atmel_spi_is_v2(as
))
1363 spi_writel(as
, CSR0
+ 4 * spi
->chip_select
, csr
);
1368 static int atmel_spi_transfer(struct spi_device
*spi
, struct spi_message
*msg
)
1370 struct atmel_spi
*as
;
1371 struct spi_transfer
*xfer
;
1372 struct device
*controller
= spi
->master
->dev
.parent
;
1374 struct atmel_spi_device
*asd
;
1376 as
= spi_master_get_devdata(spi
->master
);
1378 dev_dbg(controller
, "new message %p submitted for %s\n",
1379 msg
, dev_name(&spi
->dev
));
1381 if (unlikely(list_empty(&msg
->transfers
)))
1387 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
1388 if (!(xfer
->tx_buf
|| xfer
->rx_buf
) && xfer
->len
) {
1389 dev_dbg(&spi
->dev
, "missing rx or tx buf\n");
1393 if (xfer
->bits_per_word
) {
1394 asd
= spi
->controller_state
;
1395 bits
= (asd
->csr
>> 4) & 0xf;
1396 if (bits
!= xfer
->bits_per_word
- 8) {
1397 dev_dbg(&spi
->dev
, "you can't yet change "
1398 "bits_per_word in transfers\n");
1399 return -ENOPROTOOPT
;
1403 if (xfer
->bits_per_word
> 8) {
1404 if (xfer
->len
% 2) {
1405 dev_dbg(&spi
->dev
, "buffer len should be 16 bits aligned\n");
1410 /* FIXME implement these protocol options!! */
1411 if (xfer
->speed_hz
< spi
->max_speed_hz
) {
1412 dev_dbg(&spi
->dev
, "can't change speed in transfer\n");
1413 return -ENOPROTOOPT
;
1417 * DMA map early, for performance (empties dcache ASAP) and
1418 * better fault reporting.
1420 if ((!msg
->is_dma_mapped
) && (atmel_spi_use_dma(as
, xfer
)
1422 if (atmel_spi_dma_map_xfer(as
, xfer
) < 0)
1428 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
1430 " xfer %p: len %u tx %p/%08x rx %p/%08x\n",
1432 xfer
->tx_buf
, xfer
->tx_dma
,
1433 xfer
->rx_buf
, xfer
->rx_dma
);
1437 msg
->status
= -EINPROGRESS
;
1438 msg
->actual_length
= 0;
1441 list_add_tail(&msg
->queue
, &as
->queue
);
1442 if (!as
->current_transfer
)
1443 atmel_spi_next_message(spi
->master
);
1444 atmel_spi_unlock(as
);
1449 static void atmel_spi_cleanup(struct spi_device
*spi
)
1451 struct atmel_spi
*as
= spi_master_get_devdata(spi
->master
);
1452 struct atmel_spi_device
*asd
= spi
->controller_state
;
1453 unsigned gpio
= (unsigned) spi
->controller_data
;
1459 if (as
->stay
== spi
) {
1461 cs_deactivate(as
, spi
);
1463 atmel_spi_unlock(as
);
1465 spi
->controller_state
= NULL
;
1470 static inline unsigned int atmel_get_version(struct atmel_spi
*as
)
1472 return spi_readl(as
, VERSION
) & 0x00000fff;
1475 static void atmel_get_caps(struct atmel_spi
*as
)
1477 unsigned int version
;
1479 version
= atmel_get_version(as
);
1480 dev_info(&as
->pdev
->dev
, "version: 0x%x\n", version
);
1482 as
->caps
.is_spi2
= version
> 0x121;
1483 as
->caps
.has_wdrbt
= version
>= 0x210;
1484 as
->caps
.has_dma_support
= version
>= 0x212;
1487 /*-------------------------------------------------------------------------*/
1489 static int atmel_spi_probe(struct platform_device
*pdev
)
1491 struct resource
*regs
;
1495 struct spi_master
*master
;
1496 struct atmel_spi
*as
;
1498 regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1502 irq
= platform_get_irq(pdev
, 0);
1506 clk
= clk_get(&pdev
->dev
, "spi_clk");
1508 return PTR_ERR(clk
);
1510 /* setup spi core then atmel-specific driver state */
1512 master
= spi_alloc_master(&pdev
->dev
, sizeof *as
);
1516 /* the spi->mode bits understood by this driver: */
1517 master
->mode_bits
= SPI_CPOL
| SPI_CPHA
| SPI_CS_HIGH
;
1519 master
->dev
.of_node
= pdev
->dev
.of_node
;
1520 master
->bus_num
= pdev
->id
;
1521 master
->num_chipselect
= master
->dev
.of_node
? 0 : 4;
1522 master
->setup
= atmel_spi_setup
;
1523 master
->transfer
= atmel_spi_transfer
;
1524 master
->cleanup
= atmel_spi_cleanup
;
1525 platform_set_drvdata(pdev
, master
);
1527 as
= spi_master_get_devdata(master
);
1530 * Scratch buffer is used for throwaway rx and tx data.
1531 * It's coherent to minimize dcache pollution.
1533 as
->buffer
= dma_alloc_coherent(&pdev
->dev
, BUFFER_SIZE
,
1534 &as
->buffer_dma
, GFP_KERNEL
);
1538 spin_lock_init(&as
->lock
);
1539 INIT_LIST_HEAD(&as
->queue
);
1542 as
->regs
= ioremap(regs
->start
, resource_size(regs
));
1544 goto out_free_buffer
;
1545 as
->phybase
= regs
->start
;
1551 as
->use_dma
= false;
1552 as
->use_pdc
= false;
1553 if (as
->caps
.has_dma_support
) {
1554 if (atmel_spi_configure_dma(as
) == 0)
1560 if (as
->caps
.has_dma_support
&& !as
->use_dma
)
1561 dev_info(&pdev
->dev
, "Atmel SPI Controller using PIO only\n");
1564 ret
= request_irq(irq
, atmel_spi_pdc_interrupt
, 0,
1565 dev_name(&pdev
->dev
), master
);
1567 tasklet_init(&as
->tasklet
, atmel_spi_tasklet_func
,
1568 (unsigned long)master
);
1570 ret
= request_irq(irq
, atmel_spi_pio_interrupt
, 0,
1571 dev_name(&pdev
->dev
), master
);
1574 goto out_unmap_regs
;
1576 /* Initialize the hardware */
1578 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1579 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1580 if (as
->caps
.has_wdrbt
) {
1581 spi_writel(as
, MR
, SPI_BIT(WDRBT
) | SPI_BIT(MODFDIS
)
1584 spi_writel(as
, MR
, SPI_BIT(MSTR
) | SPI_BIT(MODFDIS
));
1588 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
1589 spi_writel(as
, CR
, SPI_BIT(SPIEN
));
1592 dev_info(&pdev
->dev
, "Atmel SPI Controller at 0x%08lx (irq %d)\n",
1593 (unsigned long)regs
->start
, irq
);
1595 ret
= spi_register_master(master
);
1603 atmel_spi_release_dma(as
);
1605 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1606 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1608 free_irq(irq
, master
);
1613 tasklet_kill(&as
->tasklet
);
1614 dma_free_coherent(&pdev
->dev
, BUFFER_SIZE
, as
->buffer
,
1618 spi_master_put(master
);
1622 static int atmel_spi_remove(struct platform_device
*pdev
)
1624 struct spi_master
*master
= platform_get_drvdata(pdev
);
1625 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1626 struct spi_message
*msg
;
1627 struct spi_transfer
*xfer
;
1629 /* reset the hardware and block queue progress */
1630 spin_lock_irq(&as
->lock
);
1633 atmel_spi_stop_dma(as
);
1634 atmel_spi_release_dma(as
);
1637 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1638 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1640 spin_unlock_irq(&as
->lock
);
1642 /* Terminate remaining queued transfers */
1643 list_for_each_entry(msg
, &as
->queue
, queue
) {
1644 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
1645 if (!msg
->is_dma_mapped
1646 && (atmel_spi_use_dma(as
, xfer
)
1648 atmel_spi_dma_unmap_xfer(master
, xfer
);
1650 msg
->status
= -ESHUTDOWN
;
1651 msg
->complete(msg
->context
);
1655 tasklet_kill(&as
->tasklet
);
1656 dma_free_coherent(&pdev
->dev
, BUFFER_SIZE
, as
->buffer
,
1659 clk_disable(as
->clk
);
1661 free_irq(as
->irq
, master
);
1664 spi_unregister_master(master
);
1671 static int atmel_spi_suspend(struct platform_device
*pdev
, pm_message_t mesg
)
1673 struct spi_master
*master
= platform_get_drvdata(pdev
);
1674 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1676 clk_disable(as
->clk
);
1680 static int atmel_spi_resume(struct platform_device
*pdev
)
1682 struct spi_master
*master
= platform_get_drvdata(pdev
);
1683 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1685 clk_enable(as
->clk
);
1690 #define atmel_spi_suspend NULL
1691 #define atmel_spi_resume NULL
1694 #if defined(CONFIG_OF)
1695 static const struct of_device_id atmel_spi_dt_ids
[] = {
1696 { .compatible
= "atmel,at91rm9200-spi" },
1700 MODULE_DEVICE_TABLE(of
, atmel_spi_dt_ids
);
1703 static struct platform_driver atmel_spi_driver
= {
1705 .name
= "atmel_spi",
1706 .owner
= THIS_MODULE
,
1707 .of_match_table
= of_match_ptr(atmel_spi_dt_ids
),
1709 .suspend
= atmel_spi_suspend
,
1710 .resume
= atmel_spi_resume
,
1711 .probe
= atmel_spi_probe
,
1712 .remove
= atmel_spi_remove
,
1714 module_platform_driver(atmel_spi_driver
);
1716 MODULE_DESCRIPTION("Atmel AT32/AT91 SPI Controller driver");
1717 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
1718 MODULE_LICENSE("GPL");
1719 MODULE_ALIAS("platform:atmel_spi");