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
,
598 xfer
->bits_per_word
))
601 /* Send both scatterlists */
602 rxdesc
= rxchan
->device
->device_prep_slave_sg(rxchan
,
606 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
,
611 txdesc
= txchan
->device
->device_prep_slave_sg(txchan
,
615 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
,
620 dev_dbg(master
->dev
.parent
,
621 " start dma xfer %p: len %u tx %p/%08x rx %p/%08x\n",
622 xfer
, xfer
->len
, xfer
->tx_buf
, xfer
->tx_dma
,
623 xfer
->rx_buf
, xfer
->rx_dma
);
625 /* Enable relevant interrupts */
626 spi_writel(as
, IER
, SPI_BIT(OVRES
));
628 /* Put the callback on the RX transfer only, that should finish last */
629 rxdesc
->callback
= dma_callback
;
630 rxdesc
->callback_param
= master
;
632 /* Submit and fire RX and TX with TX last so we're ready to read! */
633 cookie
= rxdesc
->tx_submit(rxdesc
);
634 if (dma_submit_error(cookie
))
636 cookie
= txdesc
->tx_submit(txdesc
);
637 if (dma_submit_error(cookie
))
639 rxchan
->device
->device_issue_pending(rxchan
);
640 txchan
->device
->device_issue_pending(txchan
);
647 spi_writel(as
, IDR
, SPI_BIT(OVRES
));
648 atmel_spi_stop_dma(as
);
654 static void atmel_spi_next_xfer_data(struct spi_master
*master
,
655 struct spi_transfer
*xfer
,
660 struct atmel_spi
*as
= spi_master_get_devdata(master
);
663 /* use scratch buffer only when rx or tx data is unspecified */
665 *rx_dma
= xfer
->rx_dma
+ xfer
->len
- *plen
;
667 *rx_dma
= as
->buffer_dma
;
668 if (len
> BUFFER_SIZE
)
673 *tx_dma
= xfer
->tx_dma
+ xfer
->len
- *plen
;
675 *tx_dma
= as
->buffer_dma
;
676 if (len
> BUFFER_SIZE
)
678 memset(as
->buffer
, 0, len
);
679 dma_sync_single_for_device(&as
->pdev
->dev
,
680 as
->buffer_dma
, len
, DMA_TO_DEVICE
);
687 * Submit next transfer for PDC.
688 * lock is held, spi irq is blocked
690 static void atmel_spi_pdc_next_xfer(struct spi_master
*master
,
691 struct spi_message
*msg
)
693 struct atmel_spi
*as
= spi_master_get_devdata(master
);
694 struct spi_transfer
*xfer
;
697 dma_addr_t tx_dma
, rx_dma
;
699 if (!as
->current_transfer
)
700 xfer
= list_entry(msg
->transfers
.next
,
701 struct spi_transfer
, transfer_list
);
702 else if (!as
->next_transfer
)
703 xfer
= list_entry(as
->current_transfer
->transfer_list
.next
,
704 struct spi_transfer
, transfer_list
);
709 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
712 atmel_spi_next_xfer_data(master
, xfer
, &tx_dma
, &rx_dma
, &len
);
713 remaining
= xfer
->len
- len
;
715 spi_writel(as
, RPR
, rx_dma
);
716 spi_writel(as
, TPR
, tx_dma
);
718 if (msg
->spi
->bits_per_word
> 8)
720 spi_writel(as
, RCR
, len
);
721 spi_writel(as
, TCR
, len
);
723 dev_dbg(&msg
->spi
->dev
,
724 " start xfer %p: len %u tx %p/%08x rx %p/%08x\n",
725 xfer
, xfer
->len
, xfer
->tx_buf
, xfer
->tx_dma
,
726 xfer
->rx_buf
, xfer
->rx_dma
);
728 xfer
= as
->next_transfer
;
729 remaining
= as
->next_remaining_bytes
;
732 as
->current_transfer
= xfer
;
733 as
->current_remaining_bytes
= remaining
;
737 else if (!atmel_spi_xfer_is_last(msg
, xfer
)
738 && atmel_spi_xfer_can_be_chained(xfer
)) {
739 xfer
= list_entry(xfer
->transfer_list
.next
,
740 struct spi_transfer
, transfer_list
);
745 as
->next_transfer
= xfer
;
751 atmel_spi_next_xfer_data(master
, xfer
, &tx_dma
, &rx_dma
, &len
);
752 as
->next_remaining_bytes
= total
- len
;
754 spi_writel(as
, RNPR
, rx_dma
);
755 spi_writel(as
, TNPR
, tx_dma
);
757 if (msg
->spi
->bits_per_word
> 8)
759 spi_writel(as
, RNCR
, len
);
760 spi_writel(as
, TNCR
, len
);
762 dev_dbg(&msg
->spi
->dev
,
763 " next xfer %p: len %u tx %p/%08x rx %p/%08x\n",
764 xfer
, xfer
->len
, xfer
->tx_buf
, xfer
->tx_dma
,
765 xfer
->rx_buf
, xfer
->rx_dma
);
766 ieval
= SPI_BIT(ENDRX
) | SPI_BIT(OVRES
);
768 spi_writel(as
, RNCR
, 0);
769 spi_writel(as
, TNCR
, 0);
770 ieval
= SPI_BIT(RXBUFF
) | SPI_BIT(ENDRX
) | SPI_BIT(OVRES
);
773 /* REVISIT: We're waiting for ENDRX before we start the next
774 * transfer because we need to handle some difficult timing
775 * issues otherwise. If we wait for ENDTX in one transfer and
776 * then starts waiting for ENDRX in the next, it's difficult
777 * to tell the difference between the ENDRX interrupt we're
778 * actually waiting for and the ENDRX interrupt of the
781 * It should be doable, though. Just not now...
783 spi_writel(as
, IER
, ieval
);
784 spi_writel(as
, PTCR
, SPI_BIT(TXTEN
) | SPI_BIT(RXTEN
));
788 * Choose way to submit next transfer and start it.
789 * lock is held, spi tasklet is blocked
791 static void atmel_spi_dma_next_xfer(struct spi_master
*master
,
792 struct spi_message
*msg
)
794 struct atmel_spi
*as
= spi_master_get_devdata(master
);
795 struct spi_transfer
*xfer
;
798 remaining
= as
->current_remaining_bytes
;
800 xfer
= as
->current_transfer
;
803 if (!as
->current_transfer
)
804 xfer
= list_entry(msg
->transfers
.next
,
805 struct spi_transfer
, transfer_list
);
808 as
->current_transfer
->transfer_list
.next
,
809 struct spi_transfer
, transfer_list
);
811 as
->current_transfer
= xfer
;
815 if (atmel_spi_use_dma(as
, xfer
)) {
817 if (!atmel_spi_next_xfer_dma_submit(master
, xfer
, &len
)) {
818 as
->current_remaining_bytes
= total
- len
;
821 dev_err(&msg
->spi
->dev
, "unable to use DMA, fallback to PIO\n");
825 /* use PIO if error appened using DMA */
826 atmel_spi_next_xfer_pio(master
, xfer
);
829 static void atmel_spi_next_message(struct spi_master
*master
)
831 struct atmel_spi
*as
= spi_master_get_devdata(master
);
832 struct spi_message
*msg
;
833 struct spi_device
*spi
;
835 BUG_ON(as
->current_transfer
);
837 msg
= list_entry(as
->queue
.next
, struct spi_message
, queue
);
840 dev_dbg(master
->dev
.parent
, "start message %p for %s\n",
841 msg
, dev_name(&spi
->dev
));
843 /* select chip if it's not still active */
845 if (as
->stay
!= spi
) {
846 cs_deactivate(as
, as
->stay
);
847 cs_activate(as
, spi
);
851 cs_activate(as
, spi
);
854 atmel_spi_pdc_next_xfer(master
, msg
);
856 atmel_spi_dma_next_xfer(master
, msg
);
860 * For DMA, tx_buf/tx_dma have the same relationship as rx_buf/rx_dma:
861 * - The buffer is either valid for CPU access, else NULL
862 * - If the buffer is valid, so is its DMA address
864 * This driver manages the dma address unless message->is_dma_mapped.
867 atmel_spi_dma_map_xfer(struct atmel_spi
*as
, struct spi_transfer
*xfer
)
869 struct device
*dev
= &as
->pdev
->dev
;
871 xfer
->tx_dma
= xfer
->rx_dma
= INVALID_DMA_ADDRESS
;
873 /* tx_buf is a const void* where we need a void * for the dma
875 void *nonconst_tx
= (void *)xfer
->tx_buf
;
877 xfer
->tx_dma
= dma_map_single(dev
,
878 nonconst_tx
, xfer
->len
,
880 if (dma_mapping_error(dev
, xfer
->tx_dma
))
884 xfer
->rx_dma
= dma_map_single(dev
,
885 xfer
->rx_buf
, xfer
->len
,
887 if (dma_mapping_error(dev
, xfer
->rx_dma
)) {
889 dma_unmap_single(dev
,
890 xfer
->tx_dma
, xfer
->len
,
898 static void atmel_spi_dma_unmap_xfer(struct spi_master
*master
,
899 struct spi_transfer
*xfer
)
901 if (xfer
->tx_dma
!= INVALID_DMA_ADDRESS
)
902 dma_unmap_single(master
->dev
.parent
, xfer
->tx_dma
,
903 xfer
->len
, DMA_TO_DEVICE
);
904 if (xfer
->rx_dma
!= INVALID_DMA_ADDRESS
)
905 dma_unmap_single(master
->dev
.parent
, xfer
->rx_dma
,
906 xfer
->len
, DMA_FROM_DEVICE
);
909 static void atmel_spi_disable_pdc_transfer(struct atmel_spi
*as
)
911 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
915 atmel_spi_msg_done(struct spi_master
*master
, struct atmel_spi
*as
,
916 struct spi_message
*msg
, int stay
)
918 if (!stay
|| as
->done_status
< 0)
919 cs_deactivate(as
, msg
->spi
);
923 list_del(&msg
->queue
);
924 msg
->status
= as
->done_status
;
926 dev_dbg(master
->dev
.parent
,
927 "xfer complete: %u bytes transferred\n",
930 atmel_spi_unlock(as
);
931 msg
->complete(msg
->context
);
934 as
->current_transfer
= NULL
;
935 as
->next_transfer
= NULL
;
938 /* continue if needed */
939 if (list_empty(&as
->queue
) || as
->stopping
) {
941 atmel_spi_disable_pdc_transfer(as
);
943 atmel_spi_next_message(master
);
950 * Must update "current_remaining_bytes" to keep track of data
954 atmel_spi_pump_pio_data(struct atmel_spi
*as
, struct spi_transfer
*xfer
)
960 unsigned long xfer_pos
= xfer
->len
- as
->current_remaining_bytes
;
963 if (xfer
->bits_per_word
> 8) {
964 rxp16
= (u16
*)(((u8
*)xfer
->rx_buf
) + xfer_pos
);
965 *rxp16
= spi_readl(as
, RDR
);
967 rxp
= ((u8
*)xfer
->rx_buf
) + xfer_pos
;
968 *rxp
= spi_readl(as
, RDR
);
973 if (xfer
->bits_per_word
> 8) {
974 as
->current_remaining_bytes
-= 2;
975 if (as
->current_remaining_bytes
< 0)
976 as
->current_remaining_bytes
= 0;
978 as
->current_remaining_bytes
--;
981 if (as
->current_remaining_bytes
) {
983 if (xfer
->bits_per_word
> 8) {
984 txp16
= (u16
*)(((u8
*)xfer
->tx_buf
)
986 spi_writel(as
, TDR
, *txp16
);
988 txp
= ((u8
*)xfer
->tx_buf
) + xfer_pos
+ 1;
989 spi_writel(as
, TDR
, *txp
);
992 spi_writel(as
, TDR
, 0);
998 * Called from DMA callback + pio transfer and overrun IRQ.
1000 static void atmel_spi_tasklet_func(unsigned long data
)
1002 struct spi_master
*master
= (struct spi_master
*)data
;
1003 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1004 struct spi_message
*msg
;
1005 struct spi_transfer
*xfer
;
1007 dev_vdbg(master
->dev
.parent
, "atmel_spi_tasklet_func\n");
1011 xfer
= as
->current_transfer
;
1014 /* already been there */
1017 msg
= list_entry(as
->queue
.next
, struct spi_message
, queue
);
1019 if (as
->current_remaining_bytes
== 0) {
1020 if (as
->done_status
< 0) {
1021 /* error happened (overrun) */
1022 if (atmel_spi_use_dma(as
, xfer
))
1023 atmel_spi_stop_dma(as
);
1025 /* only update length if no error */
1026 msg
->actual_length
+= xfer
->len
;
1029 if (atmel_spi_use_dma(as
, xfer
))
1030 if (!msg
->is_dma_mapped
)
1031 atmel_spi_dma_unmap_xfer(master
, xfer
);
1033 if (xfer
->delay_usecs
)
1034 udelay(xfer
->delay_usecs
);
1036 if (atmel_spi_xfer_is_last(msg
, xfer
) || as
->done_status
< 0) {
1037 /* report completed (or erroneous) message */
1038 atmel_spi_msg_done(master
, as
, msg
, xfer
->cs_change
);
1040 if (xfer
->cs_change
) {
1041 cs_deactivate(as
, msg
->spi
);
1043 cs_activate(as
, msg
->spi
);
1047 * Not done yet. Submit the next transfer.
1049 * FIXME handle protocol options for xfer
1051 atmel_spi_dma_next_xfer(master
, msg
);
1055 * Keep going, we still have data to send in
1056 * the current transfer.
1058 atmel_spi_dma_next_xfer(master
, msg
);
1062 atmel_spi_unlock(as
);
1067 * No need for locking in this Interrupt handler: done_status is the
1068 * only information modified. What we need is the update of this field
1069 * before tasklet runs. This is ensured by using barrier.
1072 atmel_spi_pio_interrupt(int irq
, void *dev_id
)
1074 struct spi_master
*master
= dev_id
;
1075 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1076 u32 status
, pending
, imr
;
1077 struct spi_transfer
*xfer
;
1080 imr
= spi_readl(as
, IMR
);
1081 status
= spi_readl(as
, SR
);
1082 pending
= status
& imr
;
1084 if (pending
& SPI_BIT(OVRES
)) {
1086 spi_writel(as
, IDR
, SPI_BIT(OVRES
));
1087 dev_warn(master
->dev
.parent
, "overrun\n");
1090 * When we get an overrun, we disregard the current
1091 * transfer. Data will not be copied back from any
1092 * bounce buffer and msg->actual_len will not be
1093 * updated with the last xfer.
1095 * We will also not process any remaning transfers in
1098 * All actions are done in tasklet with done_status indication
1100 as
->done_status
= -EIO
;
1103 /* Clear any overrun happening while cleaning up */
1106 tasklet_schedule(&as
->tasklet
);
1108 } else if (pending
& SPI_BIT(RDRF
)) {
1111 if (as
->current_remaining_bytes
) {
1113 xfer
= as
->current_transfer
;
1114 atmel_spi_pump_pio_data(as
, xfer
);
1115 if (!as
->current_remaining_bytes
) {
1116 /* no more data to xfer, kick tasklet */
1117 spi_writel(as
, IDR
, pending
);
1118 tasklet_schedule(&as
->tasklet
);
1122 atmel_spi_unlock(as
);
1124 WARN_ONCE(pending
, "IRQ not handled, pending = %x\n", pending
);
1126 spi_writel(as
, IDR
, pending
);
1133 atmel_spi_pdc_interrupt(int irq
, void *dev_id
)
1135 struct spi_master
*master
= dev_id
;
1136 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1137 struct spi_message
*msg
;
1138 struct spi_transfer
*xfer
;
1139 u32 status
, pending
, imr
;
1144 xfer
= as
->current_transfer
;
1145 msg
= list_entry(as
->queue
.next
, struct spi_message
, queue
);
1147 imr
= spi_readl(as
, IMR
);
1148 status
= spi_readl(as
, SR
);
1149 pending
= status
& imr
;
1151 if (pending
& SPI_BIT(OVRES
)) {
1156 spi_writel(as
, IDR
, (SPI_BIT(RXBUFF
) | SPI_BIT(ENDRX
)
1160 * When we get an overrun, we disregard the current
1161 * transfer. Data will not be copied back from any
1162 * bounce buffer and msg->actual_len will not be
1163 * updated with the last xfer.
1165 * We will also not process any remaning transfers in
1168 * First, stop the transfer and unmap the DMA buffers.
1170 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
1171 if (!msg
->is_dma_mapped
)
1172 atmel_spi_dma_unmap_xfer(master
, xfer
);
1174 /* REVISIT: udelay in irq is unfriendly */
1175 if (xfer
->delay_usecs
)
1176 udelay(xfer
->delay_usecs
);
1178 dev_warn(master
->dev
.parent
, "overrun (%u/%u remaining)\n",
1179 spi_readl(as
, TCR
), spi_readl(as
, RCR
));
1182 * Clean up DMA registers and make sure the data
1183 * registers are empty.
1185 spi_writel(as
, RNCR
, 0);
1186 spi_writel(as
, TNCR
, 0);
1187 spi_writel(as
, RCR
, 0);
1188 spi_writel(as
, TCR
, 0);
1189 for (timeout
= 1000; timeout
; timeout
--)
1190 if (spi_readl(as
, SR
) & SPI_BIT(TXEMPTY
))
1193 dev_warn(master
->dev
.parent
,
1194 "timeout waiting for TXEMPTY");
1195 while (spi_readl(as
, SR
) & SPI_BIT(RDRF
))
1198 /* Clear any overrun happening while cleaning up */
1201 as
->done_status
= -EIO
;
1202 atmel_spi_msg_done(master
, as
, msg
, 0);
1203 } else if (pending
& (SPI_BIT(RXBUFF
) | SPI_BIT(ENDRX
))) {
1206 spi_writel(as
, IDR
, pending
);
1208 if (as
->current_remaining_bytes
== 0) {
1209 msg
->actual_length
+= xfer
->len
;
1211 if (!msg
->is_dma_mapped
)
1212 atmel_spi_dma_unmap_xfer(master
, xfer
);
1214 /* REVISIT: udelay in irq is unfriendly */
1215 if (xfer
->delay_usecs
)
1216 udelay(xfer
->delay_usecs
);
1218 if (atmel_spi_xfer_is_last(msg
, xfer
)) {
1219 /* report completed message */
1220 atmel_spi_msg_done(master
, as
, msg
,
1223 if (xfer
->cs_change
) {
1224 cs_deactivate(as
, msg
->spi
);
1226 cs_activate(as
, msg
->spi
);
1230 * Not done yet. Submit the next transfer.
1232 * FIXME handle protocol options for xfer
1234 atmel_spi_pdc_next_xfer(master
, msg
);
1238 * Keep going, we still have data to send in
1239 * the current transfer.
1241 atmel_spi_pdc_next_xfer(master
, msg
);
1245 atmel_spi_unlock(as
);
1250 static int atmel_spi_setup(struct spi_device
*spi
)
1252 struct atmel_spi
*as
;
1253 struct atmel_spi_device
*asd
;
1255 unsigned int bits
= spi
->bits_per_word
;
1256 unsigned long bus_hz
;
1257 unsigned int npcs_pin
;
1260 as
= spi_master_get_devdata(spi
->master
);
1265 if (spi
->chip_select
> spi
->master
->num_chipselect
) {
1267 "setup: invalid chipselect %u (%u defined)\n",
1268 spi
->chip_select
, spi
->master
->num_chipselect
);
1272 if (bits
< 8 || bits
> 16) {
1274 "setup: invalid bits_per_word %u (8 to 16)\n",
1279 /* see notes above re chipselect */
1280 if (!atmel_spi_is_v2(as
)
1281 && spi
->chip_select
== 0
1282 && (spi
->mode
& SPI_CS_HIGH
)) {
1283 dev_dbg(&spi
->dev
, "setup: can't be active-high\n");
1287 /* v1 chips start out at half the peripheral bus speed. */
1288 bus_hz
= clk_get_rate(as
->clk
);
1289 if (!atmel_spi_is_v2(as
))
1292 if (spi
->max_speed_hz
) {
1294 * Calculate the lowest divider that satisfies the
1295 * constraint, assuming div32/fdiv/mbz == 0.
1297 scbr
= DIV_ROUND_UP(bus_hz
, spi
->max_speed_hz
);
1300 * If the resulting divider doesn't fit into the
1301 * register bitfield, we can't satisfy the constraint.
1303 if (scbr
>= (1 << SPI_SCBR_SIZE
)) {
1305 "setup: %d Hz too slow, scbr %u; min %ld Hz\n",
1306 spi
->max_speed_hz
, scbr
, bus_hz
/255);
1310 /* speed zero means "as slow as possible" */
1313 csr
= SPI_BF(SCBR
, scbr
) | SPI_BF(BITS
, bits
- 8);
1314 if (spi
->mode
& SPI_CPOL
)
1315 csr
|= SPI_BIT(CPOL
);
1316 if (!(spi
->mode
& SPI_CPHA
))
1317 csr
|= SPI_BIT(NCPHA
);
1319 /* DLYBS is mostly irrelevant since we manage chipselect using GPIOs.
1321 * DLYBCT would add delays between words, slowing down transfers.
1322 * It could potentially be useful to cope with DMA bottlenecks, but
1323 * in those cases it's probably best to just use a lower bitrate.
1325 csr
|= SPI_BF(DLYBS
, 0);
1326 csr
|= SPI_BF(DLYBCT
, 0);
1328 /* chipselect must have been muxed as GPIO (e.g. in board setup) */
1329 npcs_pin
= (unsigned int)spi
->controller_data
;
1331 if (gpio_is_valid(spi
->cs_gpio
))
1332 npcs_pin
= spi
->cs_gpio
;
1334 asd
= spi
->controller_state
;
1336 asd
= kzalloc(sizeof(struct atmel_spi_device
), GFP_KERNEL
);
1340 ret
= gpio_request(npcs_pin
, dev_name(&spi
->dev
));
1346 asd
->npcs_pin
= npcs_pin
;
1347 spi
->controller_state
= asd
;
1348 gpio_direction_output(npcs_pin
, !(spi
->mode
& SPI_CS_HIGH
));
1351 if (as
->stay
== spi
)
1353 cs_deactivate(as
, spi
);
1354 atmel_spi_unlock(as
);
1360 "setup: %lu Hz bpw %u mode 0x%x -> csr%d %08x\n",
1361 bus_hz
/ scbr
, bits
, spi
->mode
, spi
->chip_select
, csr
);
1363 if (!atmel_spi_is_v2(as
))
1364 spi_writel(as
, CSR0
+ 4 * spi
->chip_select
, csr
);
1369 static int atmel_spi_transfer(struct spi_device
*spi
, struct spi_message
*msg
)
1371 struct atmel_spi
*as
;
1372 struct spi_transfer
*xfer
;
1373 struct device
*controller
= spi
->master
->dev
.parent
;
1375 struct atmel_spi_device
*asd
;
1377 as
= spi_master_get_devdata(spi
->master
);
1379 dev_dbg(controller
, "new message %p submitted for %s\n",
1380 msg
, dev_name(&spi
->dev
));
1382 if (unlikely(list_empty(&msg
->transfers
)))
1388 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
1389 if (!(xfer
->tx_buf
|| xfer
->rx_buf
) && xfer
->len
) {
1390 dev_dbg(&spi
->dev
, "missing rx or tx buf\n");
1394 if (xfer
->bits_per_word
) {
1395 asd
= spi
->controller_state
;
1396 bits
= (asd
->csr
>> 4) & 0xf;
1397 if (bits
!= xfer
->bits_per_word
- 8) {
1398 dev_dbg(&spi
->dev
, "you can't yet change "
1399 "bits_per_word in transfers\n");
1400 return -ENOPROTOOPT
;
1404 if (xfer
->bits_per_word
> 8) {
1405 if (xfer
->len
% 2) {
1406 dev_dbg(&spi
->dev
, "buffer len should be 16 bits aligned\n");
1411 /* FIXME implement these protocol options!! */
1412 if (xfer
->speed_hz
< spi
->max_speed_hz
) {
1413 dev_dbg(&spi
->dev
, "can't change speed in transfer\n");
1414 return -ENOPROTOOPT
;
1418 * DMA map early, for performance (empties dcache ASAP) and
1419 * better fault reporting.
1421 if ((!msg
->is_dma_mapped
) && (atmel_spi_use_dma(as
, xfer
)
1423 if (atmel_spi_dma_map_xfer(as
, xfer
) < 0)
1429 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
1431 " xfer %p: len %u tx %p/%08x rx %p/%08x\n",
1433 xfer
->tx_buf
, xfer
->tx_dma
,
1434 xfer
->rx_buf
, xfer
->rx_dma
);
1438 msg
->status
= -EINPROGRESS
;
1439 msg
->actual_length
= 0;
1442 list_add_tail(&msg
->queue
, &as
->queue
);
1443 if (!as
->current_transfer
)
1444 atmel_spi_next_message(spi
->master
);
1445 atmel_spi_unlock(as
);
1450 static void atmel_spi_cleanup(struct spi_device
*spi
)
1452 struct atmel_spi
*as
= spi_master_get_devdata(spi
->master
);
1453 struct atmel_spi_device
*asd
= spi
->controller_state
;
1454 unsigned gpio
= (unsigned) spi
->controller_data
;
1460 if (as
->stay
== spi
) {
1462 cs_deactivate(as
, spi
);
1464 atmel_spi_unlock(as
);
1466 spi
->controller_state
= NULL
;
1471 static inline unsigned int atmel_get_version(struct atmel_spi
*as
)
1473 return spi_readl(as
, VERSION
) & 0x00000fff;
1476 static void atmel_get_caps(struct atmel_spi
*as
)
1478 unsigned int version
;
1480 version
= atmel_get_version(as
);
1481 dev_info(&as
->pdev
->dev
, "version: 0x%x\n", version
);
1483 as
->caps
.is_spi2
= version
> 0x121;
1484 as
->caps
.has_wdrbt
= version
>= 0x210;
1485 as
->caps
.has_dma_support
= version
>= 0x212;
1488 /*-------------------------------------------------------------------------*/
1490 static int atmel_spi_probe(struct platform_device
*pdev
)
1492 struct resource
*regs
;
1496 struct spi_master
*master
;
1497 struct atmel_spi
*as
;
1499 regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1503 irq
= platform_get_irq(pdev
, 0);
1507 clk
= clk_get(&pdev
->dev
, "spi_clk");
1509 return PTR_ERR(clk
);
1511 /* setup spi core then atmel-specific driver state */
1513 master
= spi_alloc_master(&pdev
->dev
, sizeof *as
);
1517 /* the spi->mode bits understood by this driver: */
1518 master
->mode_bits
= SPI_CPOL
| SPI_CPHA
| SPI_CS_HIGH
;
1520 master
->dev
.of_node
= pdev
->dev
.of_node
;
1521 master
->bus_num
= pdev
->id
;
1522 master
->num_chipselect
= master
->dev
.of_node
? 0 : 4;
1523 master
->setup
= atmel_spi_setup
;
1524 master
->transfer
= atmel_spi_transfer
;
1525 master
->cleanup
= atmel_spi_cleanup
;
1526 platform_set_drvdata(pdev
, master
);
1528 as
= spi_master_get_devdata(master
);
1531 * Scratch buffer is used for throwaway rx and tx data.
1532 * It's coherent to minimize dcache pollution.
1534 as
->buffer
= dma_alloc_coherent(&pdev
->dev
, BUFFER_SIZE
,
1535 &as
->buffer_dma
, GFP_KERNEL
);
1539 spin_lock_init(&as
->lock
);
1540 INIT_LIST_HEAD(&as
->queue
);
1543 as
->regs
= ioremap(regs
->start
, resource_size(regs
));
1545 goto out_free_buffer
;
1546 as
->phybase
= regs
->start
;
1552 as
->use_dma
= false;
1553 as
->use_pdc
= false;
1554 if (as
->caps
.has_dma_support
) {
1555 if (atmel_spi_configure_dma(as
) == 0)
1561 if (as
->caps
.has_dma_support
&& !as
->use_dma
)
1562 dev_info(&pdev
->dev
, "Atmel SPI Controller using PIO only\n");
1565 ret
= request_irq(irq
, atmel_spi_pdc_interrupt
, 0,
1566 dev_name(&pdev
->dev
), master
);
1568 tasklet_init(&as
->tasklet
, atmel_spi_tasklet_func
,
1569 (unsigned long)master
);
1571 ret
= request_irq(irq
, atmel_spi_pio_interrupt
, 0,
1572 dev_name(&pdev
->dev
), master
);
1575 goto out_unmap_regs
;
1577 /* Initialize the hardware */
1579 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1580 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1581 if (as
->caps
.has_wdrbt
) {
1582 spi_writel(as
, MR
, SPI_BIT(WDRBT
) | SPI_BIT(MODFDIS
)
1585 spi_writel(as
, MR
, SPI_BIT(MSTR
) | SPI_BIT(MODFDIS
));
1589 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
1590 spi_writel(as
, CR
, SPI_BIT(SPIEN
));
1593 dev_info(&pdev
->dev
, "Atmel SPI Controller at 0x%08lx (irq %d)\n",
1594 (unsigned long)regs
->start
, irq
);
1596 ret
= spi_register_master(master
);
1604 atmel_spi_release_dma(as
);
1606 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1607 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1609 free_irq(irq
, master
);
1614 tasklet_kill(&as
->tasklet
);
1615 dma_free_coherent(&pdev
->dev
, BUFFER_SIZE
, as
->buffer
,
1619 spi_master_put(master
);
1623 static int atmel_spi_remove(struct platform_device
*pdev
)
1625 struct spi_master
*master
= platform_get_drvdata(pdev
);
1626 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1627 struct spi_message
*msg
;
1628 struct spi_transfer
*xfer
;
1630 /* reset the hardware and block queue progress */
1631 spin_lock_irq(&as
->lock
);
1634 atmel_spi_stop_dma(as
);
1635 atmel_spi_release_dma(as
);
1638 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1639 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1641 spin_unlock_irq(&as
->lock
);
1643 /* Terminate remaining queued transfers */
1644 list_for_each_entry(msg
, &as
->queue
, queue
) {
1645 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
1646 if (!msg
->is_dma_mapped
1647 && (atmel_spi_use_dma(as
, xfer
)
1649 atmel_spi_dma_unmap_xfer(master
, xfer
);
1651 msg
->status
= -ESHUTDOWN
;
1652 msg
->complete(msg
->context
);
1656 tasklet_kill(&as
->tasklet
);
1657 dma_free_coherent(&pdev
->dev
, BUFFER_SIZE
, as
->buffer
,
1660 clk_disable(as
->clk
);
1662 free_irq(as
->irq
, master
);
1665 spi_unregister_master(master
);
1672 static int atmel_spi_suspend(struct platform_device
*pdev
, pm_message_t mesg
)
1674 struct spi_master
*master
= platform_get_drvdata(pdev
);
1675 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1677 clk_disable(as
->clk
);
1681 static int atmel_spi_resume(struct platform_device
*pdev
)
1683 struct spi_master
*master
= platform_get_drvdata(pdev
);
1684 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1686 clk_enable(as
->clk
);
1691 #define atmel_spi_suspend NULL
1692 #define atmel_spi_resume NULL
1695 #if defined(CONFIG_OF)
1696 static const struct of_device_id atmel_spi_dt_ids
[] = {
1697 { .compatible
= "atmel,at91rm9200-spi" },
1701 MODULE_DEVICE_TABLE(of
, atmel_spi_dt_ids
);
1704 static struct platform_driver atmel_spi_driver
= {
1706 .name
= "atmel_spi",
1707 .owner
= THIS_MODULE
,
1708 .of_match_table
= of_match_ptr(atmel_spi_dt_ids
),
1710 .suspend
= atmel_spi_suspend
,
1711 .resume
= atmel_spi_resume
,
1712 .probe
= atmel_spi_probe
,
1713 .remove
= atmel_spi_remove
,
1715 module_platform_driver(atmel_spi_driver
);
1717 MODULE_DESCRIPTION("Atmel AT32/AT91 SPI Controller driver");
1718 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
1719 MODULE_LICENSE("GPL");
1720 MODULE_ALIAS("platform:atmel_spi");