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/clk.h>
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/delay.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/dmaengine.h>
18 #include <linux/err.h>
19 #include <linux/interrupt.h>
20 #include <linux/spi/spi.h>
21 #include <linux/slab.h>
22 #include <linux/platform_data/atmel.h>
23 #include <linux/platform_data/dma-atmel.h>
27 #include <linux/gpio.h>
28 #include <linux/pinctrl/consumer.h>
29 #include <linux/pm_runtime.h>
31 /* SPI register offsets */
34 #define SPI_RDR 0x0008
35 #define SPI_TDR 0x000c
37 #define SPI_IER 0x0014
38 #define SPI_IDR 0x0018
39 #define SPI_IMR 0x001c
40 #define SPI_CSR0 0x0030
41 #define SPI_CSR1 0x0034
42 #define SPI_CSR2 0x0038
43 #define SPI_CSR3 0x003c
44 #define SPI_VERSION 0x00fc
45 #define SPI_RPR 0x0100
46 #define SPI_RCR 0x0104
47 #define SPI_TPR 0x0108
48 #define SPI_TCR 0x010c
49 #define SPI_RNPR 0x0110
50 #define SPI_RNCR 0x0114
51 #define SPI_TNPR 0x0118
52 #define SPI_TNCR 0x011c
53 #define SPI_PTCR 0x0120
54 #define SPI_PTSR 0x0124
57 #define SPI_SPIEN_OFFSET 0
58 #define SPI_SPIEN_SIZE 1
59 #define SPI_SPIDIS_OFFSET 1
60 #define SPI_SPIDIS_SIZE 1
61 #define SPI_SWRST_OFFSET 7
62 #define SPI_SWRST_SIZE 1
63 #define SPI_LASTXFER_OFFSET 24
64 #define SPI_LASTXFER_SIZE 1
67 #define SPI_MSTR_OFFSET 0
68 #define SPI_MSTR_SIZE 1
69 #define SPI_PS_OFFSET 1
71 #define SPI_PCSDEC_OFFSET 2
72 #define SPI_PCSDEC_SIZE 1
73 #define SPI_FDIV_OFFSET 3
74 #define SPI_FDIV_SIZE 1
75 #define SPI_MODFDIS_OFFSET 4
76 #define SPI_MODFDIS_SIZE 1
77 #define SPI_WDRBT_OFFSET 5
78 #define SPI_WDRBT_SIZE 1
79 #define SPI_LLB_OFFSET 7
80 #define SPI_LLB_SIZE 1
81 #define SPI_PCS_OFFSET 16
82 #define SPI_PCS_SIZE 4
83 #define SPI_DLYBCS_OFFSET 24
84 #define SPI_DLYBCS_SIZE 8
86 /* Bitfields in RDR */
87 #define SPI_RD_OFFSET 0
88 #define SPI_RD_SIZE 16
90 /* Bitfields in TDR */
91 #define SPI_TD_OFFSET 0
92 #define SPI_TD_SIZE 16
95 #define SPI_RDRF_OFFSET 0
96 #define SPI_RDRF_SIZE 1
97 #define SPI_TDRE_OFFSET 1
98 #define SPI_TDRE_SIZE 1
99 #define SPI_MODF_OFFSET 2
100 #define SPI_MODF_SIZE 1
101 #define SPI_OVRES_OFFSET 3
102 #define SPI_OVRES_SIZE 1
103 #define SPI_ENDRX_OFFSET 4
104 #define SPI_ENDRX_SIZE 1
105 #define SPI_ENDTX_OFFSET 5
106 #define SPI_ENDTX_SIZE 1
107 #define SPI_RXBUFF_OFFSET 6
108 #define SPI_RXBUFF_SIZE 1
109 #define SPI_TXBUFE_OFFSET 7
110 #define SPI_TXBUFE_SIZE 1
111 #define SPI_NSSR_OFFSET 8
112 #define SPI_NSSR_SIZE 1
113 #define SPI_TXEMPTY_OFFSET 9
114 #define SPI_TXEMPTY_SIZE 1
115 #define SPI_SPIENS_OFFSET 16
116 #define SPI_SPIENS_SIZE 1
118 /* Bitfields in CSR0 */
119 #define SPI_CPOL_OFFSET 0
120 #define SPI_CPOL_SIZE 1
121 #define SPI_NCPHA_OFFSET 1
122 #define SPI_NCPHA_SIZE 1
123 #define SPI_CSAAT_OFFSET 3
124 #define SPI_CSAAT_SIZE 1
125 #define SPI_BITS_OFFSET 4
126 #define SPI_BITS_SIZE 4
127 #define SPI_SCBR_OFFSET 8
128 #define SPI_SCBR_SIZE 8
129 #define SPI_DLYBS_OFFSET 16
130 #define SPI_DLYBS_SIZE 8
131 #define SPI_DLYBCT_OFFSET 24
132 #define SPI_DLYBCT_SIZE 8
134 /* Bitfields in RCR */
135 #define SPI_RXCTR_OFFSET 0
136 #define SPI_RXCTR_SIZE 16
138 /* Bitfields in TCR */
139 #define SPI_TXCTR_OFFSET 0
140 #define SPI_TXCTR_SIZE 16
142 /* Bitfields in RNCR */
143 #define SPI_RXNCR_OFFSET 0
144 #define SPI_RXNCR_SIZE 16
146 /* Bitfields in TNCR */
147 #define SPI_TXNCR_OFFSET 0
148 #define SPI_TXNCR_SIZE 16
150 /* Bitfields in PTCR */
151 #define SPI_RXTEN_OFFSET 0
152 #define SPI_RXTEN_SIZE 1
153 #define SPI_RXTDIS_OFFSET 1
154 #define SPI_RXTDIS_SIZE 1
155 #define SPI_TXTEN_OFFSET 8
156 #define SPI_TXTEN_SIZE 1
157 #define SPI_TXTDIS_OFFSET 9
158 #define SPI_TXTDIS_SIZE 1
160 /* Constants for BITS */
161 #define SPI_BITS_8_BPT 0
162 #define SPI_BITS_9_BPT 1
163 #define SPI_BITS_10_BPT 2
164 #define SPI_BITS_11_BPT 3
165 #define SPI_BITS_12_BPT 4
166 #define SPI_BITS_13_BPT 5
167 #define SPI_BITS_14_BPT 6
168 #define SPI_BITS_15_BPT 7
169 #define SPI_BITS_16_BPT 8
171 /* Bit manipulation macros */
172 #define SPI_BIT(name) \
173 (1 << SPI_##name##_OFFSET)
174 #define SPI_BF(name, value) \
175 (((value) & ((1 << SPI_##name##_SIZE) - 1)) << SPI_##name##_OFFSET)
176 #define SPI_BFEXT(name, value) \
177 (((value) >> SPI_##name##_OFFSET) & ((1 << SPI_##name##_SIZE) - 1))
178 #define SPI_BFINS(name, value, old) \
179 (((old) & ~(((1 << SPI_##name##_SIZE) - 1) << SPI_##name##_OFFSET)) \
180 | SPI_BF(name, value))
182 /* Register access macros */
184 #define spi_readl(port, reg) \
185 __raw_readl((port)->regs + SPI_##reg)
186 #define spi_writel(port, reg, value) \
187 __raw_writel((value), (port)->regs + SPI_##reg)
189 #define spi_readl(port, reg) \
190 readl_relaxed((port)->regs + SPI_##reg)
191 #define spi_writel(port, reg, value) \
192 writel_relaxed((value), (port)->regs + SPI_##reg)
194 /* use PIO for small transfers, avoiding DMA setup/teardown overhead and
195 * cache operations; better heuristics consider wordsize and bitrate.
197 #define DMA_MIN_BYTES 16
199 #define SPI_DMA_TIMEOUT (msecs_to_jiffies(1000))
201 #define AUTOSUSPEND_TIMEOUT 2000
203 struct atmel_spi_dma
{
204 struct dma_chan
*chan_rx
;
205 struct dma_chan
*chan_tx
;
206 struct scatterlist sgrx
;
207 struct scatterlist sgtx
;
208 struct dma_async_tx_descriptor
*data_desc_rx
;
209 struct dma_async_tx_descriptor
*data_desc_tx
;
211 struct at_dma_slave dma_slave
;
214 struct atmel_spi_caps
{
217 bool has_dma_support
;
221 * The core SPI transfer engine just talks to a register bank to set up
222 * DMA transfers; transfer queue progress is driven by IRQs. The clock
223 * framework provides the base clock, subdivided for each spi_device.
233 struct platform_device
*pdev
;
235 struct spi_transfer
*current_transfer
;
236 int current_remaining_bytes
;
239 struct completion xfer_completion
;
243 dma_addr_t buffer_dma
;
245 struct atmel_spi_caps caps
;
251 struct atmel_spi_dma dma
;
257 /* Controller-specific per-slave state */
258 struct atmel_spi_device
{
259 unsigned int npcs_pin
;
263 #define BUFFER_SIZE PAGE_SIZE
264 #define INVALID_DMA_ADDRESS 0xffffffff
267 * Version 2 of the SPI controller has
269 * - SPI_MR.DIV32 may become FDIV or must-be-zero (here: always zero)
270 * - SPI_SR.TXEMPTY, SPI_SR.NSSR (and corresponding irqs)
272 * - SPI_CSRx.SBCR allows faster clocking
274 static bool atmel_spi_is_v2(struct atmel_spi
*as
)
276 return as
->caps
.is_spi2
;
280 * Earlier SPI controllers (e.g. on at91rm9200) have a design bug whereby
281 * they assume that spi slave device state will not change on deselect, so
282 * that automagic deselection is OK. ("NPCSx rises if no data is to be
283 * transmitted") Not so! Workaround uses nCSx pins as GPIOs; or newer
284 * controllers have CSAAT and friends.
286 * Since the CSAAT functionality is a bit weird on newer controllers as
287 * well, we use GPIO to control nCSx pins on all controllers, updating
288 * MR.PCS to avoid confusing the controller. Using GPIOs also lets us
289 * support active-high chipselects despite the controller's belief that
290 * only active-low devices/systems exists.
292 * However, at91rm9200 has a second erratum whereby nCS0 doesn't work
293 * right when driven with GPIO. ("Mode Fault does not allow more than one
294 * Master on Chip Select 0.") No workaround exists for that ... so for
295 * nCS0 on that chip, we (a) don't use the GPIO, (b) can't support CS_HIGH,
296 * and (c) will trigger that first erratum in some cases.
299 static void cs_activate(struct atmel_spi
*as
, struct spi_device
*spi
)
301 struct atmel_spi_device
*asd
= spi
->controller_state
;
302 unsigned active
= spi
->mode
& SPI_CS_HIGH
;
305 if (atmel_spi_is_v2(as
)) {
306 spi_writel(as
, CSR0
+ 4 * spi
->chip_select
, asd
->csr
);
307 /* For the low SPI version, there is a issue that PDC transfer
308 * on CS1,2,3 needs SPI_CSR0.BITS config as SPI_CSR1,2,3.BITS
310 spi_writel(as
, CSR0
, asd
->csr
);
311 if (as
->caps
.has_wdrbt
) {
313 SPI_BF(PCS
, ~(0x01 << spi
->chip_select
))
319 SPI_BF(PCS
, ~(0x01 << spi
->chip_select
))
324 mr
= spi_readl(as
, MR
);
325 if (as
->use_cs_gpios
)
326 gpio_set_value(asd
->npcs_pin
, active
);
328 u32 cpol
= (spi
->mode
& SPI_CPOL
) ? SPI_BIT(CPOL
) : 0;
332 /* Make sure clock polarity is correct */
333 for (i
= 0; i
< spi
->master
->num_chipselect
; i
++) {
334 csr
= spi_readl(as
, CSR0
+ 4 * i
);
335 if ((csr
^ cpol
) & SPI_BIT(CPOL
))
336 spi_writel(as
, CSR0
+ 4 * i
,
337 csr
^ SPI_BIT(CPOL
));
340 mr
= spi_readl(as
, MR
);
341 mr
= SPI_BFINS(PCS
, ~(1 << spi
->chip_select
), mr
);
342 if (as
->use_cs_gpios
&& spi
->chip_select
!= 0)
343 gpio_set_value(asd
->npcs_pin
, active
);
344 spi_writel(as
, MR
, mr
);
347 dev_dbg(&spi
->dev
, "activate %u%s, mr %08x\n",
348 asd
->npcs_pin
, active
? " (high)" : "",
352 static void cs_deactivate(struct atmel_spi
*as
, struct spi_device
*spi
)
354 struct atmel_spi_device
*asd
= spi
->controller_state
;
355 unsigned active
= spi
->mode
& SPI_CS_HIGH
;
358 /* only deactivate *this* device; sometimes transfers to
359 * another device may be active when this routine is called.
361 mr
= spi_readl(as
, MR
);
362 if (~SPI_BFEXT(PCS
, mr
) & (1 << spi
->chip_select
)) {
363 mr
= SPI_BFINS(PCS
, 0xf, mr
);
364 spi_writel(as
, MR
, mr
);
367 dev_dbg(&spi
->dev
, "DEactivate %u%s, mr %08x\n",
368 asd
->npcs_pin
, active
? " (low)" : "",
371 if (!as
->use_cs_gpios
)
372 spi_writel(as
, CR
, SPI_BIT(LASTXFER
));
373 else if (atmel_spi_is_v2(as
) || spi
->chip_select
!= 0)
374 gpio_set_value(asd
->npcs_pin
, !active
);
377 static void atmel_spi_lock(struct atmel_spi
*as
) __acquires(&as
->lock
)
379 spin_lock_irqsave(&as
->lock
, as
->flags
);
382 static void atmel_spi_unlock(struct atmel_spi
*as
) __releases(&as
->lock
)
384 spin_unlock_irqrestore(&as
->lock
, as
->flags
);
387 static inline bool atmel_spi_use_dma(struct atmel_spi
*as
,
388 struct spi_transfer
*xfer
)
390 return as
->use_dma
&& xfer
->len
>= DMA_MIN_BYTES
;
393 static int atmel_spi_dma_slave_config(struct atmel_spi
*as
,
394 struct dma_slave_config
*slave_config
,
399 if (bits_per_word
> 8) {
400 slave_config
->dst_addr_width
= DMA_SLAVE_BUSWIDTH_2_BYTES
;
401 slave_config
->src_addr_width
= DMA_SLAVE_BUSWIDTH_2_BYTES
;
403 slave_config
->dst_addr_width
= DMA_SLAVE_BUSWIDTH_1_BYTE
;
404 slave_config
->src_addr_width
= DMA_SLAVE_BUSWIDTH_1_BYTE
;
407 slave_config
->dst_addr
= (dma_addr_t
)as
->phybase
+ SPI_TDR
;
408 slave_config
->src_addr
= (dma_addr_t
)as
->phybase
+ SPI_RDR
;
409 slave_config
->src_maxburst
= 1;
410 slave_config
->dst_maxburst
= 1;
411 slave_config
->device_fc
= false;
413 slave_config
->direction
= DMA_MEM_TO_DEV
;
414 if (dmaengine_slave_config(as
->dma
.chan_tx
, slave_config
)) {
415 dev_err(&as
->pdev
->dev
,
416 "failed to configure tx dma channel\n");
420 slave_config
->direction
= DMA_DEV_TO_MEM
;
421 if (dmaengine_slave_config(as
->dma
.chan_rx
, slave_config
)) {
422 dev_err(&as
->pdev
->dev
,
423 "failed to configure rx dma channel\n");
430 static int atmel_spi_configure_dma(struct atmel_spi
*as
)
432 struct dma_slave_config slave_config
;
433 struct device
*dev
= &as
->pdev
->dev
;
438 dma_cap_set(DMA_SLAVE
, mask
);
440 as
->dma
.chan_tx
= dma_request_slave_channel_reason(dev
, "tx");
441 if (IS_ERR(as
->dma
.chan_tx
)) {
442 err
= PTR_ERR(as
->dma
.chan_tx
);
443 if (err
== -EPROBE_DEFER
) {
444 dev_warn(dev
, "no DMA channel available at the moment\n");
448 "DMA TX channel not available, SPI unable to use DMA\n");
454 * No reason to check EPROBE_DEFER here since we have already requested
455 * tx channel. If it fails here, it's for another reason.
457 as
->dma
.chan_rx
= dma_request_slave_channel(dev
, "rx");
459 if (!as
->dma
.chan_rx
) {
461 "DMA RX channel not available, SPI unable to use DMA\n");
466 err
= atmel_spi_dma_slave_config(as
, &slave_config
, 8);
470 dev_info(&as
->pdev
->dev
,
471 "Using %s (tx) and %s (rx) for DMA transfers\n",
472 dma_chan_name(as
->dma
.chan_tx
),
473 dma_chan_name(as
->dma
.chan_rx
));
477 dma_release_channel(as
->dma
.chan_rx
);
478 if (!IS_ERR(as
->dma
.chan_tx
))
479 dma_release_channel(as
->dma
.chan_tx
);
483 static void atmel_spi_stop_dma(struct atmel_spi
*as
)
486 dmaengine_terminate_all(as
->dma
.chan_rx
);
488 dmaengine_terminate_all(as
->dma
.chan_tx
);
491 static void atmel_spi_release_dma(struct atmel_spi
*as
)
494 dma_release_channel(as
->dma
.chan_rx
);
496 dma_release_channel(as
->dma
.chan_tx
);
499 /* This function is called by the DMA driver from tasklet context */
500 static void dma_callback(void *data
)
502 struct spi_master
*master
= data
;
503 struct atmel_spi
*as
= spi_master_get_devdata(master
);
505 complete(&as
->xfer_completion
);
509 * Next transfer using PIO.
511 static void atmel_spi_next_xfer_pio(struct spi_master
*master
,
512 struct spi_transfer
*xfer
)
514 struct atmel_spi
*as
= spi_master_get_devdata(master
);
515 unsigned long xfer_pos
= xfer
->len
- as
->current_remaining_bytes
;
517 dev_vdbg(master
->dev
.parent
, "atmel_spi_next_xfer_pio\n");
519 /* Make sure data is not remaining in RDR */
521 while (spi_readl(as
, SR
) & SPI_BIT(RDRF
)) {
527 if (xfer
->bits_per_word
> 8)
528 spi_writel(as
, TDR
, *(u16
*)(xfer
->tx_buf
+ xfer_pos
));
530 spi_writel(as
, TDR
, *(u8
*)(xfer
->tx_buf
+ xfer_pos
));
532 spi_writel(as
, TDR
, 0);
535 dev_dbg(master
->dev
.parent
,
536 " start pio xfer %p: len %u tx %p rx %p bitpw %d\n",
537 xfer
, xfer
->len
, xfer
->tx_buf
, xfer
->rx_buf
,
538 xfer
->bits_per_word
);
540 /* Enable relevant interrupts */
541 spi_writel(as
, IER
, SPI_BIT(RDRF
) | SPI_BIT(OVRES
));
545 * Submit next transfer for DMA.
547 static int atmel_spi_next_xfer_dma_submit(struct spi_master
*master
,
548 struct spi_transfer
*xfer
,
551 struct atmel_spi
*as
= spi_master_get_devdata(master
);
552 struct dma_chan
*rxchan
= as
->dma
.chan_rx
;
553 struct dma_chan
*txchan
= as
->dma
.chan_tx
;
554 struct dma_async_tx_descriptor
*rxdesc
;
555 struct dma_async_tx_descriptor
*txdesc
;
556 struct dma_slave_config slave_config
;
560 dev_vdbg(master
->dev
.parent
, "atmel_spi_next_xfer_dma_submit\n");
562 /* Check that the channels are available */
563 if (!rxchan
|| !txchan
)
566 /* release lock for DMA operations */
567 atmel_spi_unlock(as
);
569 /* prepare the RX dma transfer */
570 sg_init_table(&as
->dma
.sgrx
, 1);
572 as
->dma
.sgrx
.dma_address
= xfer
->rx_dma
+ xfer
->len
- *plen
;
574 as
->dma
.sgrx
.dma_address
= as
->buffer_dma
;
575 if (len
> BUFFER_SIZE
)
579 /* prepare the TX dma transfer */
580 sg_init_table(&as
->dma
.sgtx
, 1);
582 as
->dma
.sgtx
.dma_address
= xfer
->tx_dma
+ xfer
->len
- *plen
;
584 as
->dma
.sgtx
.dma_address
= as
->buffer_dma
;
585 if (len
> BUFFER_SIZE
)
587 memset(as
->buffer
, 0, len
);
590 sg_dma_len(&as
->dma
.sgtx
) = len
;
591 sg_dma_len(&as
->dma
.sgrx
) = len
;
595 if (atmel_spi_dma_slave_config(as
, &slave_config
, 8))
598 /* Send both scatterlists */
599 rxdesc
= dmaengine_prep_slave_sg(rxchan
, &as
->dma
.sgrx
, 1,
601 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
605 txdesc
= dmaengine_prep_slave_sg(txchan
, &as
->dma
.sgtx
, 1,
607 DMA_PREP_INTERRUPT
| DMA_CTRL_ACK
);
611 dev_dbg(master
->dev
.parent
,
612 " start dma xfer %p: len %u tx %p/%08llx rx %p/%08llx\n",
613 xfer
, xfer
->len
, xfer
->tx_buf
, (unsigned long long)xfer
->tx_dma
,
614 xfer
->rx_buf
, (unsigned long long)xfer
->rx_dma
);
616 /* Enable relevant interrupts */
617 spi_writel(as
, IER
, SPI_BIT(OVRES
));
619 /* Put the callback on the RX transfer only, that should finish last */
620 rxdesc
->callback
= dma_callback
;
621 rxdesc
->callback_param
= master
;
623 /* Submit and fire RX and TX with TX last so we're ready to read! */
624 cookie
= rxdesc
->tx_submit(rxdesc
);
625 if (dma_submit_error(cookie
))
627 cookie
= txdesc
->tx_submit(txdesc
);
628 if (dma_submit_error(cookie
))
630 rxchan
->device
->device_issue_pending(rxchan
);
631 txchan
->device
->device_issue_pending(txchan
);
638 spi_writel(as
, IDR
, SPI_BIT(OVRES
));
639 atmel_spi_stop_dma(as
);
645 static void atmel_spi_next_xfer_data(struct spi_master
*master
,
646 struct spi_transfer
*xfer
,
651 struct atmel_spi
*as
= spi_master_get_devdata(master
);
654 /* use scratch buffer only when rx or tx data is unspecified */
656 *rx_dma
= xfer
->rx_dma
+ xfer
->len
- *plen
;
658 *rx_dma
= as
->buffer_dma
;
659 if (len
> BUFFER_SIZE
)
664 *tx_dma
= xfer
->tx_dma
+ xfer
->len
- *plen
;
666 *tx_dma
= as
->buffer_dma
;
667 if (len
> BUFFER_SIZE
)
669 memset(as
->buffer
, 0, len
);
670 dma_sync_single_for_device(&as
->pdev
->dev
,
671 as
->buffer_dma
, len
, DMA_TO_DEVICE
);
677 static int atmel_spi_set_xfer_speed(struct atmel_spi
*as
,
678 struct spi_device
*spi
,
679 struct spi_transfer
*xfer
)
682 unsigned long bus_hz
;
684 /* v1 chips start out at half the peripheral bus speed. */
685 bus_hz
= clk_get_rate(as
->clk
);
686 if (!atmel_spi_is_v2(as
))
690 * Calculate the lowest divider that satisfies the
691 * constraint, assuming div32/fdiv/mbz == 0.
694 scbr
= DIV_ROUND_UP(bus_hz
, xfer
->speed_hz
);
697 * This can happend if max_speed is null.
698 * In this case, we set the lowest possible speed
703 * If the resulting divider doesn't fit into the
704 * register bitfield, we can't satisfy the constraint.
706 if (scbr
>= (1 << SPI_SCBR_SIZE
)) {
708 "setup: %d Hz too slow, scbr %u; min %ld Hz\n",
709 xfer
->speed_hz
, scbr
, bus_hz
/255);
714 "setup: %d Hz too high, scbr %u; max %ld Hz\n",
715 xfer
->speed_hz
, scbr
, bus_hz
);
718 csr
= spi_readl(as
, CSR0
+ 4 * spi
->chip_select
);
719 csr
= SPI_BFINS(SCBR
, scbr
, csr
);
720 spi_writel(as
, CSR0
+ 4 * spi
->chip_select
, csr
);
726 * Submit next transfer for PDC.
727 * lock is held, spi irq is blocked
729 static void atmel_spi_pdc_next_xfer(struct spi_master
*master
,
730 struct spi_message
*msg
,
731 struct spi_transfer
*xfer
)
733 struct atmel_spi
*as
= spi_master_get_devdata(master
);
735 dma_addr_t tx_dma
, rx_dma
;
737 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
739 len
= as
->current_remaining_bytes
;
740 atmel_spi_next_xfer_data(master
, xfer
, &tx_dma
, &rx_dma
, &len
);
741 as
->current_remaining_bytes
-= len
;
743 spi_writel(as
, RPR
, rx_dma
);
744 spi_writel(as
, TPR
, tx_dma
);
746 if (msg
->spi
->bits_per_word
> 8)
748 spi_writel(as
, RCR
, len
);
749 spi_writel(as
, TCR
, len
);
751 dev_dbg(&msg
->spi
->dev
,
752 " start xfer %p: len %u tx %p/%08llx rx %p/%08llx\n",
753 xfer
, xfer
->len
, xfer
->tx_buf
,
754 (unsigned long long)xfer
->tx_dma
, xfer
->rx_buf
,
755 (unsigned long long)xfer
->rx_dma
);
757 if (as
->current_remaining_bytes
) {
758 len
= as
->current_remaining_bytes
;
759 atmel_spi_next_xfer_data(master
, xfer
, &tx_dma
, &rx_dma
, &len
);
760 as
->current_remaining_bytes
-= len
;
762 spi_writel(as
, RNPR
, rx_dma
);
763 spi_writel(as
, TNPR
, tx_dma
);
765 if (msg
->spi
->bits_per_word
> 8)
767 spi_writel(as
, RNCR
, len
);
768 spi_writel(as
, TNCR
, len
);
770 dev_dbg(&msg
->spi
->dev
,
771 " next xfer %p: len %u tx %p/%08llx rx %p/%08llx\n",
772 xfer
, xfer
->len
, xfer
->tx_buf
,
773 (unsigned long long)xfer
->tx_dma
, xfer
->rx_buf
,
774 (unsigned long long)xfer
->rx_dma
);
777 /* REVISIT: We're waiting for RXBUFF before we start the next
778 * transfer because we need to handle some difficult timing
779 * issues otherwise. If we wait for TXBUFE in one transfer and
780 * then starts waiting for RXBUFF in the next, it's difficult
781 * to tell the difference between the RXBUFF interrupt we're
782 * actually waiting for and the RXBUFF interrupt of the
785 * It should be doable, though. Just not now...
787 spi_writel(as
, IER
, SPI_BIT(RXBUFF
) | SPI_BIT(OVRES
));
788 spi_writel(as
, PTCR
, SPI_BIT(TXTEN
) | SPI_BIT(RXTEN
));
792 * For DMA, tx_buf/tx_dma have the same relationship as rx_buf/rx_dma:
793 * - The buffer is either valid for CPU access, else NULL
794 * - If the buffer is valid, so is its DMA address
796 * This driver manages the dma address unless message->is_dma_mapped.
799 atmel_spi_dma_map_xfer(struct atmel_spi
*as
, struct spi_transfer
*xfer
)
801 struct device
*dev
= &as
->pdev
->dev
;
803 xfer
->tx_dma
= xfer
->rx_dma
= INVALID_DMA_ADDRESS
;
805 /* tx_buf is a const void* where we need a void * for the dma
807 void *nonconst_tx
= (void *)xfer
->tx_buf
;
809 xfer
->tx_dma
= dma_map_single(dev
,
810 nonconst_tx
, xfer
->len
,
812 if (dma_mapping_error(dev
, xfer
->tx_dma
))
816 xfer
->rx_dma
= dma_map_single(dev
,
817 xfer
->rx_buf
, xfer
->len
,
819 if (dma_mapping_error(dev
, xfer
->rx_dma
)) {
821 dma_unmap_single(dev
,
822 xfer
->tx_dma
, xfer
->len
,
830 static void atmel_spi_dma_unmap_xfer(struct spi_master
*master
,
831 struct spi_transfer
*xfer
)
833 if (xfer
->tx_dma
!= INVALID_DMA_ADDRESS
)
834 dma_unmap_single(master
->dev
.parent
, xfer
->tx_dma
,
835 xfer
->len
, DMA_TO_DEVICE
);
836 if (xfer
->rx_dma
!= INVALID_DMA_ADDRESS
)
837 dma_unmap_single(master
->dev
.parent
, xfer
->rx_dma
,
838 xfer
->len
, DMA_FROM_DEVICE
);
841 static void atmel_spi_disable_pdc_transfer(struct atmel_spi
*as
)
843 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
848 * Must update "current_remaining_bytes" to keep track of data
852 atmel_spi_pump_pio_data(struct atmel_spi
*as
, struct spi_transfer
*xfer
)
856 unsigned long xfer_pos
= xfer
->len
- as
->current_remaining_bytes
;
859 if (xfer
->bits_per_word
> 8) {
860 rxp16
= (u16
*)(((u8
*)xfer
->rx_buf
) + xfer_pos
);
861 *rxp16
= spi_readl(as
, RDR
);
863 rxp
= ((u8
*)xfer
->rx_buf
) + xfer_pos
;
864 *rxp
= spi_readl(as
, RDR
);
869 if (xfer
->bits_per_word
> 8) {
870 if (as
->current_remaining_bytes
> 2)
871 as
->current_remaining_bytes
-= 2;
873 as
->current_remaining_bytes
= 0;
875 as
->current_remaining_bytes
--;
881 * No need for locking in this Interrupt handler: done_status is the
882 * only information modified.
885 atmel_spi_pio_interrupt(int irq
, void *dev_id
)
887 struct spi_master
*master
= dev_id
;
888 struct atmel_spi
*as
= spi_master_get_devdata(master
);
889 u32 status
, pending
, imr
;
890 struct spi_transfer
*xfer
;
893 imr
= spi_readl(as
, IMR
);
894 status
= spi_readl(as
, SR
);
895 pending
= status
& imr
;
897 if (pending
& SPI_BIT(OVRES
)) {
899 spi_writel(as
, IDR
, SPI_BIT(OVRES
));
900 dev_warn(master
->dev
.parent
, "overrun\n");
903 * When we get an overrun, we disregard the current
904 * transfer. Data will not be copied back from any
905 * bounce buffer and msg->actual_len will not be
906 * updated with the last xfer.
908 * We will also not process any remaning transfers in
911 as
->done_status
= -EIO
;
914 /* Clear any overrun happening while cleaning up */
917 complete(&as
->xfer_completion
);
919 } else if (pending
& SPI_BIT(RDRF
)) {
922 if (as
->current_remaining_bytes
) {
924 xfer
= as
->current_transfer
;
925 atmel_spi_pump_pio_data(as
, xfer
);
926 if (!as
->current_remaining_bytes
)
927 spi_writel(as
, IDR
, pending
);
929 complete(&as
->xfer_completion
);
932 atmel_spi_unlock(as
);
934 WARN_ONCE(pending
, "IRQ not handled, pending = %x\n", pending
);
936 spi_writel(as
, IDR
, pending
);
943 atmel_spi_pdc_interrupt(int irq
, void *dev_id
)
945 struct spi_master
*master
= dev_id
;
946 struct atmel_spi
*as
= spi_master_get_devdata(master
);
947 u32 status
, pending
, imr
;
950 imr
= spi_readl(as
, IMR
);
951 status
= spi_readl(as
, SR
);
952 pending
= status
& imr
;
954 if (pending
& SPI_BIT(OVRES
)) {
958 spi_writel(as
, IDR
, (SPI_BIT(RXBUFF
) | SPI_BIT(ENDRX
)
961 /* Clear any overrun happening while cleaning up */
964 as
->done_status
= -EIO
;
966 complete(&as
->xfer_completion
);
968 } else if (pending
& (SPI_BIT(RXBUFF
) | SPI_BIT(ENDRX
))) {
971 spi_writel(as
, IDR
, pending
);
973 complete(&as
->xfer_completion
);
979 static int atmel_spi_setup(struct spi_device
*spi
)
981 struct atmel_spi
*as
;
982 struct atmel_spi_device
*asd
;
984 unsigned int bits
= spi
->bits_per_word
;
985 unsigned int npcs_pin
;
988 as
= spi_master_get_devdata(spi
->master
);
990 /* see notes above re chipselect */
991 if (!atmel_spi_is_v2(as
)
992 && spi
->chip_select
== 0
993 && (spi
->mode
& SPI_CS_HIGH
)) {
994 dev_dbg(&spi
->dev
, "setup: can't be active-high\n");
998 csr
= SPI_BF(BITS
, bits
- 8);
999 if (spi
->mode
& SPI_CPOL
)
1000 csr
|= SPI_BIT(CPOL
);
1001 if (!(spi
->mode
& SPI_CPHA
))
1002 csr
|= SPI_BIT(NCPHA
);
1003 if (!as
->use_cs_gpios
)
1004 csr
|= SPI_BIT(CSAAT
);
1006 /* DLYBS is mostly irrelevant since we manage chipselect using GPIOs.
1008 * DLYBCT would add delays between words, slowing down transfers.
1009 * It could potentially be useful to cope with DMA bottlenecks, but
1010 * in those cases it's probably best to just use a lower bitrate.
1012 csr
|= SPI_BF(DLYBS
, 0);
1013 csr
|= SPI_BF(DLYBCT
, 0);
1015 /* chipselect must have been muxed as GPIO (e.g. in board setup) */
1016 npcs_pin
= (unsigned long)spi
->controller_data
;
1018 if (!as
->use_cs_gpios
)
1019 npcs_pin
= spi
->chip_select
;
1020 else if (gpio_is_valid(spi
->cs_gpio
))
1021 npcs_pin
= spi
->cs_gpio
;
1023 asd
= spi
->controller_state
;
1025 asd
= kzalloc(sizeof(struct atmel_spi_device
), GFP_KERNEL
);
1029 if (as
->use_cs_gpios
) {
1030 ret
= gpio_request(npcs_pin
, dev_name(&spi
->dev
));
1036 gpio_direction_output(npcs_pin
,
1037 !(spi
->mode
& SPI_CS_HIGH
));
1040 asd
->npcs_pin
= npcs_pin
;
1041 spi
->controller_state
= asd
;
1047 "setup: bpw %u mode 0x%x -> csr%d %08x\n",
1048 bits
, spi
->mode
, spi
->chip_select
, csr
);
1050 if (!atmel_spi_is_v2(as
))
1051 spi_writel(as
, CSR0
+ 4 * spi
->chip_select
, csr
);
1056 static int atmel_spi_one_transfer(struct spi_master
*master
,
1057 struct spi_message
*msg
,
1058 struct spi_transfer
*xfer
)
1060 struct atmel_spi
*as
;
1061 struct spi_device
*spi
= msg
->spi
;
1064 struct atmel_spi_device
*asd
;
1067 unsigned long dma_timeout
;
1069 as
= spi_master_get_devdata(master
);
1071 if (!(xfer
->tx_buf
|| xfer
->rx_buf
) && xfer
->len
) {
1072 dev_dbg(&spi
->dev
, "missing rx or tx buf\n");
1076 if (xfer
->bits_per_word
) {
1077 asd
= spi
->controller_state
;
1078 bits
= (asd
->csr
>> 4) & 0xf;
1079 if (bits
!= xfer
->bits_per_word
- 8) {
1081 "you can't yet change bits_per_word in transfers\n");
1082 return -ENOPROTOOPT
;
1087 * DMA map early, for performance (empties dcache ASAP) and
1088 * better fault reporting.
1090 if ((!msg
->is_dma_mapped
)
1091 && (atmel_spi_use_dma(as
, xfer
) || as
->use_pdc
)) {
1092 if (atmel_spi_dma_map_xfer(as
, xfer
) < 0)
1096 atmel_spi_set_xfer_speed(as
, msg
->spi
, xfer
);
1098 as
->done_status
= 0;
1099 as
->current_transfer
= xfer
;
1100 as
->current_remaining_bytes
= xfer
->len
;
1101 while (as
->current_remaining_bytes
) {
1102 reinit_completion(&as
->xfer_completion
);
1105 atmel_spi_pdc_next_xfer(master
, msg
, xfer
);
1106 } else if (atmel_spi_use_dma(as
, xfer
)) {
1107 len
= as
->current_remaining_bytes
;
1108 ret
= atmel_spi_next_xfer_dma_submit(master
,
1112 "unable to use DMA, fallback to PIO\n");
1113 atmel_spi_next_xfer_pio(master
, xfer
);
1115 as
->current_remaining_bytes
-= len
;
1116 if (as
->current_remaining_bytes
< 0)
1117 as
->current_remaining_bytes
= 0;
1120 atmel_spi_next_xfer_pio(master
, xfer
);
1123 /* interrupts are disabled, so free the lock for schedule */
1124 atmel_spi_unlock(as
);
1125 dma_timeout
= wait_for_completion_timeout(&as
->xfer_completion
,
1128 if (WARN_ON(dma_timeout
== 0)) {
1129 dev_err(&spi
->dev
, "spi transfer timeout\n");
1130 as
->done_status
= -EIO
;
1133 if (as
->done_status
)
1137 if (as
->done_status
) {
1139 dev_warn(master
->dev
.parent
,
1140 "overrun (%u/%u remaining)\n",
1141 spi_readl(as
, TCR
), spi_readl(as
, RCR
));
1144 * Clean up DMA registers and make sure the data
1145 * registers are empty.
1147 spi_writel(as
, RNCR
, 0);
1148 spi_writel(as
, TNCR
, 0);
1149 spi_writel(as
, RCR
, 0);
1150 spi_writel(as
, TCR
, 0);
1151 for (timeout
= 1000; timeout
; timeout
--)
1152 if (spi_readl(as
, SR
) & SPI_BIT(TXEMPTY
))
1155 dev_warn(master
->dev
.parent
,
1156 "timeout waiting for TXEMPTY");
1157 while (spi_readl(as
, SR
) & SPI_BIT(RDRF
))
1160 /* Clear any overrun happening while cleaning up */
1163 } else if (atmel_spi_use_dma(as
, xfer
)) {
1164 atmel_spi_stop_dma(as
);
1167 if (!msg
->is_dma_mapped
1168 && (atmel_spi_use_dma(as
, xfer
) || as
->use_pdc
))
1169 atmel_spi_dma_unmap_xfer(master
, xfer
);
1174 /* only update length if no error */
1175 msg
->actual_length
+= xfer
->len
;
1178 if (!msg
->is_dma_mapped
1179 && (atmel_spi_use_dma(as
, xfer
) || as
->use_pdc
))
1180 atmel_spi_dma_unmap_xfer(master
, xfer
);
1182 if (xfer
->delay_usecs
)
1183 udelay(xfer
->delay_usecs
);
1185 if (xfer
->cs_change
) {
1186 if (list_is_last(&xfer
->transfer_list
,
1190 as
->cs_active
= !as
->cs_active
;
1192 cs_activate(as
, msg
->spi
);
1194 cs_deactivate(as
, msg
->spi
);
1201 static int atmel_spi_transfer_one_message(struct spi_master
*master
,
1202 struct spi_message
*msg
)
1204 struct atmel_spi
*as
;
1205 struct spi_transfer
*xfer
;
1206 struct spi_device
*spi
= msg
->spi
;
1209 as
= spi_master_get_devdata(master
);
1211 dev_dbg(&spi
->dev
, "new message %p submitted for %s\n",
1212 msg
, dev_name(&spi
->dev
));
1215 cs_activate(as
, spi
);
1217 as
->cs_active
= true;
1218 as
->keep_cs
= false;
1221 msg
->actual_length
= 0;
1223 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
1224 ret
= atmel_spi_one_transfer(master
, msg
, xfer
);
1230 atmel_spi_disable_pdc_transfer(as
);
1232 list_for_each_entry(xfer
, &msg
->transfers
, transfer_list
) {
1234 " xfer %p: len %u tx %p/%pad rx %p/%pad\n",
1236 xfer
->tx_buf
, &xfer
->tx_dma
,
1237 xfer
->rx_buf
, &xfer
->rx_dma
);
1242 cs_deactivate(as
, msg
->spi
);
1244 atmel_spi_unlock(as
);
1246 msg
->status
= as
->done_status
;
1247 spi_finalize_current_message(spi
->master
);
1252 static void atmel_spi_cleanup(struct spi_device
*spi
)
1254 struct atmel_spi_device
*asd
= spi
->controller_state
;
1255 unsigned gpio
= (unsigned long) spi
->controller_data
;
1260 spi
->controller_state
= NULL
;
1265 static inline unsigned int atmel_get_version(struct atmel_spi
*as
)
1267 return spi_readl(as
, VERSION
) & 0x00000fff;
1270 static void atmel_get_caps(struct atmel_spi
*as
)
1272 unsigned int version
;
1274 version
= atmel_get_version(as
);
1275 dev_info(&as
->pdev
->dev
, "version: 0x%x\n", version
);
1277 as
->caps
.is_spi2
= version
> 0x121;
1278 as
->caps
.has_wdrbt
= version
>= 0x210;
1279 as
->caps
.has_dma_support
= version
>= 0x212;
1282 /*-------------------------------------------------------------------------*/
1284 static int atmel_spi_probe(struct platform_device
*pdev
)
1286 struct resource
*regs
;
1290 struct spi_master
*master
;
1291 struct atmel_spi
*as
;
1293 /* Select default pin state */
1294 pinctrl_pm_select_default_state(&pdev
->dev
);
1296 regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1300 irq
= platform_get_irq(pdev
, 0);
1304 clk
= devm_clk_get(&pdev
->dev
, "spi_clk");
1306 return PTR_ERR(clk
);
1308 /* setup spi core then atmel-specific driver state */
1310 master
= spi_alloc_master(&pdev
->dev
, sizeof(*as
));
1314 /* the spi->mode bits understood by this driver: */
1315 master
->mode_bits
= SPI_CPOL
| SPI_CPHA
| SPI_CS_HIGH
;
1316 master
->bits_per_word_mask
= SPI_BPW_RANGE_MASK(8, 16);
1317 master
->dev
.of_node
= pdev
->dev
.of_node
;
1318 master
->bus_num
= pdev
->id
;
1319 master
->num_chipselect
= master
->dev
.of_node
? 0 : 4;
1320 master
->setup
= atmel_spi_setup
;
1321 master
->transfer_one_message
= atmel_spi_transfer_one_message
;
1322 master
->cleanup
= atmel_spi_cleanup
;
1323 master
->auto_runtime_pm
= true;
1324 platform_set_drvdata(pdev
, master
);
1326 as
= spi_master_get_devdata(master
);
1329 * Scratch buffer is used for throwaway rx and tx data.
1330 * It's coherent to minimize dcache pollution.
1332 as
->buffer
= dma_alloc_coherent(&pdev
->dev
, BUFFER_SIZE
,
1333 &as
->buffer_dma
, GFP_KERNEL
);
1337 spin_lock_init(&as
->lock
);
1340 as
->regs
= devm_ioremap_resource(&pdev
->dev
, regs
);
1341 if (IS_ERR(as
->regs
)) {
1342 ret
= PTR_ERR(as
->regs
);
1343 goto out_free_buffer
;
1345 as
->phybase
= regs
->start
;
1349 init_completion(&as
->xfer_completion
);
1353 as
->use_cs_gpios
= true;
1354 if (atmel_spi_is_v2(as
) &&
1355 !of_get_property(pdev
->dev
.of_node
, "cs-gpios", NULL
)) {
1356 as
->use_cs_gpios
= false;
1357 master
->num_chipselect
= 4;
1360 as
->use_dma
= false;
1361 as
->use_pdc
= false;
1362 if (as
->caps
.has_dma_support
) {
1363 ret
= atmel_spi_configure_dma(as
);
1366 else if (ret
== -EPROBE_DEFER
)
1372 if (as
->caps
.has_dma_support
&& !as
->use_dma
)
1373 dev_info(&pdev
->dev
, "Atmel SPI Controller using PIO only\n");
1376 ret
= devm_request_irq(&pdev
->dev
, irq
, atmel_spi_pdc_interrupt
,
1377 0, dev_name(&pdev
->dev
), master
);
1379 ret
= devm_request_irq(&pdev
->dev
, irq
, atmel_spi_pio_interrupt
,
1380 0, dev_name(&pdev
->dev
), master
);
1383 goto out_unmap_regs
;
1385 /* Initialize the hardware */
1386 ret
= clk_prepare_enable(clk
);
1389 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1390 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1391 if (as
->caps
.has_wdrbt
) {
1392 spi_writel(as
, MR
, SPI_BIT(WDRBT
) | SPI_BIT(MODFDIS
)
1395 spi_writel(as
, MR
, SPI_BIT(MSTR
) | SPI_BIT(MODFDIS
));
1399 spi_writel(as
, PTCR
, SPI_BIT(RXTDIS
) | SPI_BIT(TXTDIS
));
1400 spi_writel(as
, CR
, SPI_BIT(SPIEN
));
1403 dev_info(&pdev
->dev
, "Atmel SPI Controller at 0x%08lx (irq %d)\n",
1404 (unsigned long)regs
->start
, irq
);
1406 pm_runtime_set_autosuspend_delay(&pdev
->dev
, AUTOSUSPEND_TIMEOUT
);
1407 pm_runtime_use_autosuspend(&pdev
->dev
);
1408 pm_runtime_set_active(&pdev
->dev
);
1409 pm_runtime_enable(&pdev
->dev
);
1411 ret
= devm_spi_register_master(&pdev
->dev
, master
);
1418 pm_runtime_disable(&pdev
->dev
);
1419 pm_runtime_set_suspended(&pdev
->dev
);
1422 atmel_spi_release_dma(as
);
1424 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1425 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1426 clk_disable_unprepare(clk
);
1430 dma_free_coherent(&pdev
->dev
, BUFFER_SIZE
, as
->buffer
,
1433 spi_master_put(master
);
1437 static int atmel_spi_remove(struct platform_device
*pdev
)
1439 struct spi_master
*master
= platform_get_drvdata(pdev
);
1440 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1442 pm_runtime_get_sync(&pdev
->dev
);
1444 /* reset the hardware and block queue progress */
1445 spin_lock_irq(&as
->lock
);
1447 atmel_spi_stop_dma(as
);
1448 atmel_spi_release_dma(as
);
1451 spi_writel(as
, CR
, SPI_BIT(SWRST
));
1452 spi_writel(as
, CR
, SPI_BIT(SWRST
)); /* AT91SAM9263 Rev B workaround */
1454 spin_unlock_irq(&as
->lock
);
1456 dma_free_coherent(&pdev
->dev
, BUFFER_SIZE
, as
->buffer
,
1459 clk_disable_unprepare(as
->clk
);
1461 pm_runtime_put_noidle(&pdev
->dev
);
1462 pm_runtime_disable(&pdev
->dev
);
1468 static int atmel_spi_runtime_suspend(struct device
*dev
)
1470 struct spi_master
*master
= dev_get_drvdata(dev
);
1471 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1473 clk_disable_unprepare(as
->clk
);
1474 pinctrl_pm_select_sleep_state(dev
);
1479 static int atmel_spi_runtime_resume(struct device
*dev
)
1481 struct spi_master
*master
= dev_get_drvdata(dev
);
1482 struct atmel_spi
*as
= spi_master_get_devdata(master
);
1484 pinctrl_pm_select_default_state(dev
);
1486 return clk_prepare_enable(as
->clk
);
1489 static int atmel_spi_suspend(struct device
*dev
)
1491 struct spi_master
*master
= dev_get_drvdata(dev
);
1494 /* Stop the queue running */
1495 ret
= spi_master_suspend(master
);
1497 dev_warn(dev
, "cannot suspend master\n");
1501 if (!pm_runtime_suspended(dev
))
1502 atmel_spi_runtime_suspend(dev
);
1507 static int atmel_spi_resume(struct device
*dev
)
1509 struct spi_master
*master
= dev_get_drvdata(dev
);
1512 if (!pm_runtime_suspended(dev
)) {
1513 ret
= atmel_spi_runtime_resume(dev
);
1518 /* Start the queue running */
1519 ret
= spi_master_resume(master
);
1521 dev_err(dev
, "problem starting queue (%d)\n", ret
);
1526 static const struct dev_pm_ops atmel_spi_pm_ops
= {
1527 SET_SYSTEM_SLEEP_PM_OPS(atmel_spi_suspend
, atmel_spi_resume
)
1528 SET_RUNTIME_PM_OPS(atmel_spi_runtime_suspend
,
1529 atmel_spi_runtime_resume
, NULL
)
1531 #define ATMEL_SPI_PM_OPS (&atmel_spi_pm_ops)
1533 #define ATMEL_SPI_PM_OPS NULL
1536 #if defined(CONFIG_OF)
1537 static const struct of_device_id atmel_spi_dt_ids
[] = {
1538 { .compatible
= "atmel,at91rm9200-spi" },
1542 MODULE_DEVICE_TABLE(of
, atmel_spi_dt_ids
);
1545 static struct platform_driver atmel_spi_driver
= {
1547 .name
= "atmel_spi",
1548 .pm
= ATMEL_SPI_PM_OPS
,
1549 .of_match_table
= of_match_ptr(atmel_spi_dt_ids
),
1551 .probe
= atmel_spi_probe
,
1552 .remove
= atmel_spi_remove
,
1554 module_platform_driver(atmel_spi_driver
);
1556 MODULE_DESCRIPTION("Atmel AT32/AT91 SPI Controller driver");
1557 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
1558 MODULE_LICENSE("GPL");
1559 MODULE_ALIAS("platform:atmel_spi");