2 * OMAP2 McSPI controller driver
4 * Copyright (C) 2005, 2006 Nokia Corporation
5 * Author: Samuel Ortiz <samuel.ortiz@nokia.com> and
6 * Juha Yrjölä <juha.yrjola@nokia.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/kernel.h>
25 #include <linux/init.h>
26 #include <linux/interrupt.h>
27 #include <linux/module.h>
28 #include <linux/device.h>
29 #include <linux/delay.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/platform_device.h>
32 #include <linux/err.h>
33 #include <linux/clk.h>
36 #include <linux/spi/spi.h>
39 #include <plat/clock.h>
42 #define OMAP2_MCSPI_MAX_FREQ 48000000
44 /* OMAP2 has 3 SPI controllers, while OMAP3 has 4 */
45 #define OMAP2_MCSPI_MAX_CTRL 4
47 #define OMAP2_MCSPI_REVISION 0x00
48 #define OMAP2_MCSPI_SYSCONFIG 0x10
49 #define OMAP2_MCSPI_SYSSTATUS 0x14
50 #define OMAP2_MCSPI_IRQSTATUS 0x18
51 #define OMAP2_MCSPI_IRQENABLE 0x1c
52 #define OMAP2_MCSPI_WAKEUPENABLE 0x20
53 #define OMAP2_MCSPI_SYST 0x24
54 #define OMAP2_MCSPI_MODULCTRL 0x28
56 /* per-channel banks, 0x14 bytes each, first is: */
57 #define OMAP2_MCSPI_CHCONF0 0x2c
58 #define OMAP2_MCSPI_CHSTAT0 0x30
59 #define OMAP2_MCSPI_CHCTRL0 0x34
60 #define OMAP2_MCSPI_TX0 0x38
61 #define OMAP2_MCSPI_RX0 0x3c
63 /* per-register bitmasks: */
65 #define OMAP2_MCSPI_SYSCONFIG_SMARTIDLE BIT(4)
66 #define OMAP2_MCSPI_SYSCONFIG_ENAWAKEUP BIT(2)
67 #define OMAP2_MCSPI_SYSCONFIG_AUTOIDLE BIT(0)
68 #define OMAP2_MCSPI_SYSCONFIG_SOFTRESET BIT(1)
70 #define OMAP2_MCSPI_SYSSTATUS_RESETDONE BIT(0)
72 #define OMAP2_MCSPI_MODULCTRL_SINGLE BIT(0)
73 #define OMAP2_MCSPI_MODULCTRL_MS BIT(2)
74 #define OMAP2_MCSPI_MODULCTRL_STEST BIT(3)
76 #define OMAP2_MCSPI_CHCONF_PHA BIT(0)
77 #define OMAP2_MCSPI_CHCONF_POL BIT(1)
78 #define OMAP2_MCSPI_CHCONF_CLKD_MASK (0x0f << 2)
79 #define OMAP2_MCSPI_CHCONF_EPOL BIT(6)
80 #define OMAP2_MCSPI_CHCONF_WL_MASK (0x1f << 7)
81 #define OMAP2_MCSPI_CHCONF_TRM_RX_ONLY BIT(12)
82 #define OMAP2_MCSPI_CHCONF_TRM_TX_ONLY BIT(13)
83 #define OMAP2_MCSPI_CHCONF_TRM_MASK (0x03 << 12)
84 #define OMAP2_MCSPI_CHCONF_DMAW BIT(14)
85 #define OMAP2_MCSPI_CHCONF_DMAR BIT(15)
86 #define OMAP2_MCSPI_CHCONF_DPE0 BIT(16)
87 #define OMAP2_MCSPI_CHCONF_DPE1 BIT(17)
88 #define OMAP2_MCSPI_CHCONF_IS BIT(18)
89 #define OMAP2_MCSPI_CHCONF_TURBO BIT(19)
90 #define OMAP2_MCSPI_CHCONF_FORCE BIT(20)
92 #define OMAP2_MCSPI_CHSTAT_RXS BIT(0)
93 #define OMAP2_MCSPI_CHSTAT_TXS BIT(1)
94 #define OMAP2_MCSPI_CHSTAT_EOT BIT(2)
96 #define OMAP2_MCSPI_CHCTRL_EN BIT(0)
98 #define OMAP2_MCSPI_WAKEUPENABLE_WKEN BIT(0)
100 /* We have 2 DMA channels per CS, one for RX and one for TX */
101 struct omap2_mcspi_dma
{
108 struct completion dma_tx_completion
;
109 struct completion dma_rx_completion
;
112 /* use PIO for small transfers, avoiding DMA setup/teardown overhead and
113 * cache operations; better heuristics consider wordsize and bitrate.
115 #define DMA_MIN_BYTES 8
119 struct work_struct work
;
120 /* lock protects queue and registers */
122 struct list_head msg_queue
;
123 struct spi_master
*master
;
126 /* Virtual base address of the controller */
129 /* SPI1 has 4 channels, while SPI2 has 2 */
130 struct omap2_mcspi_dma
*dma_channels
;
133 struct omap2_mcspi_cs
{
137 struct list_head node
;
138 /* Context save and restore shadow register */
142 /* used for context save and restore, structure members to be updated whenever
143 * corresponding registers are modified.
145 struct omap2_mcspi_regs
{
152 static struct omap2_mcspi_regs omap2_mcspi_ctx
[OMAP2_MCSPI_MAX_CTRL
];
154 static struct workqueue_struct
*omap2_mcspi_wq
;
156 #define MOD_REG_BIT(val, mask, set) do { \
163 static inline void mcspi_write_reg(struct spi_master
*master
,
166 struct omap2_mcspi
*mcspi
= spi_master_get_devdata(master
);
168 __raw_writel(val
, mcspi
->base
+ idx
);
171 static inline u32
mcspi_read_reg(struct spi_master
*master
, int idx
)
173 struct omap2_mcspi
*mcspi
= spi_master_get_devdata(master
);
175 return __raw_readl(mcspi
->base
+ idx
);
178 static inline void mcspi_write_cs_reg(const struct spi_device
*spi
,
181 struct omap2_mcspi_cs
*cs
= spi
->controller_state
;
183 __raw_writel(val
, cs
->base
+ idx
);
186 static inline u32
mcspi_read_cs_reg(const struct spi_device
*spi
, int idx
)
188 struct omap2_mcspi_cs
*cs
= spi
->controller_state
;
190 return __raw_readl(cs
->base
+ idx
);
193 static inline u32
mcspi_cached_chconf0(const struct spi_device
*spi
)
195 struct omap2_mcspi_cs
*cs
= spi
->controller_state
;
200 static inline void mcspi_write_chconf0(const struct spi_device
*spi
, u32 val
)
202 struct omap2_mcspi_cs
*cs
= spi
->controller_state
;
205 mcspi_write_cs_reg(spi
, OMAP2_MCSPI_CHCONF0
, val
);
208 static void omap2_mcspi_set_dma_req(const struct spi_device
*spi
,
209 int is_read
, int enable
)
213 l
= mcspi_cached_chconf0(spi
);
215 if (is_read
) /* 1 is read, 0 write */
216 rw
= OMAP2_MCSPI_CHCONF_DMAR
;
218 rw
= OMAP2_MCSPI_CHCONF_DMAW
;
220 MOD_REG_BIT(l
, rw
, enable
);
221 mcspi_write_chconf0(spi
, l
);
224 static void omap2_mcspi_set_enable(const struct spi_device
*spi
, int enable
)
228 l
= enable
? OMAP2_MCSPI_CHCTRL_EN
: 0;
229 mcspi_write_cs_reg(spi
, OMAP2_MCSPI_CHCTRL0
, l
);
232 static void omap2_mcspi_force_cs(struct spi_device
*spi
, int cs_active
)
236 l
= mcspi_cached_chconf0(spi
);
237 MOD_REG_BIT(l
, OMAP2_MCSPI_CHCONF_FORCE
, cs_active
);
238 mcspi_write_chconf0(spi
, l
);
241 static void omap2_mcspi_set_master_mode(struct spi_master
*master
)
245 /* setup when switching from (reset default) slave mode
246 * to single-channel master mode
248 l
= mcspi_read_reg(master
, OMAP2_MCSPI_MODULCTRL
);
249 MOD_REG_BIT(l
, OMAP2_MCSPI_MODULCTRL_STEST
, 0);
250 MOD_REG_BIT(l
, OMAP2_MCSPI_MODULCTRL_MS
, 0);
251 MOD_REG_BIT(l
, OMAP2_MCSPI_MODULCTRL_SINGLE
, 1);
252 mcspi_write_reg(master
, OMAP2_MCSPI_MODULCTRL
, l
);
254 omap2_mcspi_ctx
[master
->bus_num
- 1].modulctrl
= l
;
257 static void omap2_mcspi_restore_ctx(struct omap2_mcspi
*mcspi
)
259 struct spi_master
*spi_cntrl
;
260 struct omap2_mcspi_cs
*cs
;
261 spi_cntrl
= mcspi
->master
;
263 /* McSPI: context restore */
264 mcspi_write_reg(spi_cntrl
, OMAP2_MCSPI_MODULCTRL
,
265 omap2_mcspi_ctx
[spi_cntrl
->bus_num
- 1].modulctrl
);
267 mcspi_write_reg(spi_cntrl
, OMAP2_MCSPI_SYSCONFIG
,
268 omap2_mcspi_ctx
[spi_cntrl
->bus_num
- 1].sysconfig
);
270 mcspi_write_reg(spi_cntrl
, OMAP2_MCSPI_WAKEUPENABLE
,
271 omap2_mcspi_ctx
[spi_cntrl
->bus_num
- 1].wakeupenable
);
273 list_for_each_entry(cs
, &omap2_mcspi_ctx
[spi_cntrl
->bus_num
- 1].cs
,
275 __raw_writel(cs
->chconf0
, cs
->base
+ OMAP2_MCSPI_CHCONF0
);
277 static void omap2_mcspi_disable_clocks(struct omap2_mcspi
*mcspi
)
279 clk_disable(mcspi
->ick
);
280 clk_disable(mcspi
->fck
);
283 static int omap2_mcspi_enable_clocks(struct omap2_mcspi
*mcspi
)
285 if (clk_enable(mcspi
->ick
))
287 if (clk_enable(mcspi
->fck
))
290 omap2_mcspi_restore_ctx(mcspi
);
296 omap2_mcspi_txrx_dma(struct spi_device
*spi
, struct spi_transfer
*xfer
)
298 struct omap2_mcspi
*mcspi
;
299 struct omap2_mcspi_cs
*cs
= spi
->controller_state
;
300 struct omap2_mcspi_dma
*mcspi_dma
;
301 unsigned int count
, c
;
302 unsigned long base
, tx_reg
, rx_reg
;
303 int word_len
, data_type
, element_count
;
307 mcspi
= spi_master_get_devdata(spi
->master
);
308 mcspi_dma
= &mcspi
->dma_channels
[spi
->chip_select
];
312 word_len
= cs
->word_len
;
315 tx_reg
= base
+ OMAP2_MCSPI_TX0
;
316 rx_reg
= base
+ OMAP2_MCSPI_RX0
;
321 data_type
= OMAP_DMA_DATA_TYPE_S8
;
322 element_count
= count
;
323 } else if (word_len
<= 16) {
324 data_type
= OMAP_DMA_DATA_TYPE_S16
;
325 element_count
= count
>> 1;
326 } else /* word_len <= 32 */ {
327 data_type
= OMAP_DMA_DATA_TYPE_S32
;
328 element_count
= count
>> 2;
332 omap_set_dma_transfer_params(mcspi_dma
->dma_tx_channel
,
333 data_type
, element_count
, 1,
334 OMAP_DMA_SYNC_ELEMENT
,
335 mcspi_dma
->dma_tx_sync_dev
, 0);
337 omap_set_dma_dest_params(mcspi_dma
->dma_tx_channel
, 0,
338 OMAP_DMA_AMODE_CONSTANT
,
341 omap_set_dma_src_params(mcspi_dma
->dma_tx_channel
, 0,
342 OMAP_DMA_AMODE_POST_INC
,
347 omap_set_dma_transfer_params(mcspi_dma
->dma_rx_channel
,
348 data_type
, element_count
- 1, 1,
349 OMAP_DMA_SYNC_ELEMENT
,
350 mcspi_dma
->dma_rx_sync_dev
, 1);
352 omap_set_dma_src_params(mcspi_dma
->dma_rx_channel
, 0,
353 OMAP_DMA_AMODE_CONSTANT
,
356 omap_set_dma_dest_params(mcspi_dma
->dma_rx_channel
, 0,
357 OMAP_DMA_AMODE_POST_INC
,
362 omap_start_dma(mcspi_dma
->dma_tx_channel
);
363 omap2_mcspi_set_dma_req(spi
, 0, 1);
367 omap_start_dma(mcspi_dma
->dma_rx_channel
);
368 omap2_mcspi_set_dma_req(spi
, 1, 1);
372 wait_for_completion(&mcspi_dma
->dma_tx_completion
);
373 dma_unmap_single(NULL
, xfer
->tx_dma
, count
, DMA_TO_DEVICE
);
377 wait_for_completion(&mcspi_dma
->dma_rx_completion
);
378 dma_unmap_single(NULL
, xfer
->rx_dma
, count
, DMA_FROM_DEVICE
);
379 omap2_mcspi_set_enable(spi
, 0);
380 if (likely(mcspi_read_cs_reg(spi
, OMAP2_MCSPI_CHSTAT0
)
381 & OMAP2_MCSPI_CHSTAT_RXS
)) {
384 w
= mcspi_read_cs_reg(spi
, OMAP2_MCSPI_RX0
);
386 ((u8
*)xfer
->rx_buf
)[element_count
- 1] = w
;
387 else if (word_len
<= 16)
388 ((u16
*)xfer
->rx_buf
)[element_count
- 1] = w
;
389 else /* word_len <= 32 */
390 ((u32
*)xfer
->rx_buf
)[element_count
- 1] = w
;
392 dev_err(&spi
->dev
, "DMA RX last word empty");
393 count
-= (word_len
<= 8) ? 1 :
394 (word_len
<= 16) ? 2 :
395 /* word_len <= 32 */ 4;
397 omap2_mcspi_set_enable(spi
, 1);
402 static int mcspi_wait_for_reg_bit(void __iomem
*reg
, unsigned long bit
)
404 unsigned long timeout
;
406 timeout
= jiffies
+ msecs_to_jiffies(1000);
407 while (!(__raw_readl(reg
) & bit
)) {
408 if (time_after(jiffies
, timeout
))
416 omap2_mcspi_txrx_pio(struct spi_device
*spi
, struct spi_transfer
*xfer
)
418 struct omap2_mcspi
*mcspi
;
419 struct omap2_mcspi_cs
*cs
= spi
->controller_state
;
420 unsigned int count
, c
;
422 void __iomem
*base
= cs
->base
;
423 void __iomem
*tx_reg
;
424 void __iomem
*rx_reg
;
425 void __iomem
*chstat_reg
;
428 mcspi
= spi_master_get_devdata(spi
->master
);
431 word_len
= cs
->word_len
;
433 l
= mcspi_cached_chconf0(spi
);
434 l
&= ~OMAP2_MCSPI_CHCONF_TRM_MASK
;
436 /* We store the pre-calculated register addresses on stack to speed
437 * up the transfer loop. */
438 tx_reg
= base
+ OMAP2_MCSPI_TX0
;
439 rx_reg
= base
+ OMAP2_MCSPI_RX0
;
440 chstat_reg
= base
+ OMAP2_MCSPI_CHSTAT0
;
452 if (mcspi_wait_for_reg_bit(chstat_reg
,
453 OMAP2_MCSPI_CHSTAT_TXS
) < 0) {
454 dev_err(&spi
->dev
, "TXS timed out\n");
458 dev_dbg(&spi
->dev
, "write-%d %02x\n",
461 __raw_writel(*tx
++, tx_reg
);
464 if (mcspi_wait_for_reg_bit(chstat_reg
,
465 OMAP2_MCSPI_CHSTAT_RXS
) < 0) {
466 dev_err(&spi
->dev
, "RXS timed out\n");
469 /* prevent last RX_ONLY read from triggering
470 * more word i/o: switch to rx+tx
472 if (c
== 0 && tx
== NULL
)
473 mcspi_write_chconf0(spi
, l
);
474 *rx
++ = __raw_readl(rx_reg
);
476 dev_dbg(&spi
->dev
, "read-%d %02x\n",
477 word_len
, *(rx
- 1));
481 } else if (word_len
<= 16) {
490 if (mcspi_wait_for_reg_bit(chstat_reg
,
491 OMAP2_MCSPI_CHSTAT_TXS
) < 0) {
492 dev_err(&spi
->dev
, "TXS timed out\n");
496 dev_dbg(&spi
->dev
, "write-%d %04x\n",
499 __raw_writel(*tx
++, tx_reg
);
502 if (mcspi_wait_for_reg_bit(chstat_reg
,
503 OMAP2_MCSPI_CHSTAT_RXS
) < 0) {
504 dev_err(&spi
->dev
, "RXS timed out\n");
507 /* prevent last RX_ONLY read from triggering
508 * more word i/o: switch to rx+tx
510 if (c
== 0 && tx
== NULL
)
511 mcspi_write_chconf0(spi
, l
);
512 *rx
++ = __raw_readl(rx_reg
);
514 dev_dbg(&spi
->dev
, "read-%d %04x\n",
515 word_len
, *(rx
- 1));
519 } else if (word_len
<= 32) {
528 if (mcspi_wait_for_reg_bit(chstat_reg
,
529 OMAP2_MCSPI_CHSTAT_TXS
) < 0) {
530 dev_err(&spi
->dev
, "TXS timed out\n");
534 dev_dbg(&spi
->dev
, "write-%d %04x\n",
537 __raw_writel(*tx
++, tx_reg
);
540 if (mcspi_wait_for_reg_bit(chstat_reg
,
541 OMAP2_MCSPI_CHSTAT_RXS
) < 0) {
542 dev_err(&spi
->dev
, "RXS timed out\n");
545 /* prevent last RX_ONLY read from triggering
546 * more word i/o: switch to rx+tx
548 if (c
== 0 && tx
== NULL
)
549 mcspi_write_chconf0(spi
, l
);
550 *rx
++ = __raw_readl(rx_reg
);
552 dev_dbg(&spi
->dev
, "read-%d %04x\n",
553 word_len
, *(rx
- 1));
559 /* for TX_ONLY mode, be sure all words have shifted out */
560 if (xfer
->rx_buf
== NULL
) {
561 if (mcspi_wait_for_reg_bit(chstat_reg
,
562 OMAP2_MCSPI_CHSTAT_TXS
) < 0) {
563 dev_err(&spi
->dev
, "TXS timed out\n");
564 } else if (mcspi_wait_for_reg_bit(chstat_reg
,
565 OMAP2_MCSPI_CHSTAT_EOT
) < 0)
566 dev_err(&spi
->dev
, "EOT timed out\n");
572 /* called only when no transfer is active to this device */
573 static int omap2_mcspi_setup_transfer(struct spi_device
*spi
,
574 struct spi_transfer
*t
)
576 struct omap2_mcspi_cs
*cs
= spi
->controller_state
;
577 struct omap2_mcspi
*mcspi
;
578 struct spi_master
*spi_cntrl
;
580 u8 word_len
= spi
->bits_per_word
;
581 u32 speed_hz
= spi
->max_speed_hz
;
583 mcspi
= spi_master_get_devdata(spi
->master
);
584 spi_cntrl
= mcspi
->master
;
586 if (t
!= NULL
&& t
->bits_per_word
)
587 word_len
= t
->bits_per_word
;
589 cs
->word_len
= word_len
;
591 if (t
&& t
->speed_hz
)
592 speed_hz
= t
->speed_hz
;
595 while (div
<= 15 && (OMAP2_MCSPI_MAX_FREQ
/ (1 << div
))
601 l
= mcspi_cached_chconf0(spi
);
603 /* standard 4-wire master mode: SCK, MOSI/out, MISO/in, nCS
604 * REVISIT: this controller could support SPI_3WIRE mode.
606 l
&= ~(OMAP2_MCSPI_CHCONF_IS
|OMAP2_MCSPI_CHCONF_DPE1
);
607 l
|= OMAP2_MCSPI_CHCONF_DPE0
;
610 l
&= ~OMAP2_MCSPI_CHCONF_WL_MASK
;
611 l
|= (word_len
- 1) << 7;
613 /* set chipselect polarity; manage with FORCE */
614 if (!(spi
->mode
& SPI_CS_HIGH
))
615 l
|= OMAP2_MCSPI_CHCONF_EPOL
; /* active-low; normal */
617 l
&= ~OMAP2_MCSPI_CHCONF_EPOL
;
619 /* set clock divisor */
620 l
&= ~OMAP2_MCSPI_CHCONF_CLKD_MASK
;
623 /* set SPI mode 0..3 */
624 if (spi
->mode
& SPI_CPOL
)
625 l
|= OMAP2_MCSPI_CHCONF_POL
;
627 l
&= ~OMAP2_MCSPI_CHCONF_POL
;
628 if (spi
->mode
& SPI_CPHA
)
629 l
|= OMAP2_MCSPI_CHCONF_PHA
;
631 l
&= ~OMAP2_MCSPI_CHCONF_PHA
;
633 mcspi_write_chconf0(spi
, l
);
635 dev_dbg(&spi
->dev
, "setup: speed %d, sample %s edge, clk %s\n",
636 OMAP2_MCSPI_MAX_FREQ
/ (1 << div
),
637 (spi
->mode
& SPI_CPHA
) ? "trailing" : "leading",
638 (spi
->mode
& SPI_CPOL
) ? "inverted" : "normal");
643 static void omap2_mcspi_dma_rx_callback(int lch
, u16 ch_status
, void *data
)
645 struct spi_device
*spi
= data
;
646 struct omap2_mcspi
*mcspi
;
647 struct omap2_mcspi_dma
*mcspi_dma
;
649 mcspi
= spi_master_get_devdata(spi
->master
);
650 mcspi_dma
= &(mcspi
->dma_channels
[spi
->chip_select
]);
652 complete(&mcspi_dma
->dma_rx_completion
);
654 /* We must disable the DMA RX request */
655 omap2_mcspi_set_dma_req(spi
, 1, 0);
658 static void omap2_mcspi_dma_tx_callback(int lch
, u16 ch_status
, void *data
)
660 struct spi_device
*spi
= data
;
661 struct omap2_mcspi
*mcspi
;
662 struct omap2_mcspi_dma
*mcspi_dma
;
664 mcspi
= spi_master_get_devdata(spi
->master
);
665 mcspi_dma
= &(mcspi
->dma_channels
[spi
->chip_select
]);
667 complete(&mcspi_dma
->dma_tx_completion
);
669 /* We must disable the DMA TX request */
670 omap2_mcspi_set_dma_req(spi
, 0, 0);
673 static int omap2_mcspi_request_dma(struct spi_device
*spi
)
675 struct spi_master
*master
= spi
->master
;
676 struct omap2_mcspi
*mcspi
;
677 struct omap2_mcspi_dma
*mcspi_dma
;
679 mcspi
= spi_master_get_devdata(master
);
680 mcspi_dma
= mcspi
->dma_channels
+ spi
->chip_select
;
682 if (omap_request_dma(mcspi_dma
->dma_rx_sync_dev
, "McSPI RX",
683 omap2_mcspi_dma_rx_callback
, spi
,
684 &mcspi_dma
->dma_rx_channel
)) {
685 dev_err(&spi
->dev
, "no RX DMA channel for McSPI\n");
689 if (omap_request_dma(mcspi_dma
->dma_tx_sync_dev
, "McSPI TX",
690 omap2_mcspi_dma_tx_callback
, spi
,
691 &mcspi_dma
->dma_tx_channel
)) {
692 omap_free_dma(mcspi_dma
->dma_rx_channel
);
693 mcspi_dma
->dma_rx_channel
= -1;
694 dev_err(&spi
->dev
, "no TX DMA channel for McSPI\n");
698 init_completion(&mcspi_dma
->dma_rx_completion
);
699 init_completion(&mcspi_dma
->dma_tx_completion
);
704 static int omap2_mcspi_setup(struct spi_device
*spi
)
707 struct omap2_mcspi
*mcspi
;
708 struct omap2_mcspi_dma
*mcspi_dma
;
709 struct omap2_mcspi_cs
*cs
= spi
->controller_state
;
711 if (spi
->bits_per_word
< 4 || spi
->bits_per_word
> 32) {
712 dev_dbg(&spi
->dev
, "setup: unsupported %d bit words\n",
717 mcspi
= spi_master_get_devdata(spi
->master
);
718 mcspi_dma
= &mcspi
->dma_channels
[spi
->chip_select
];
721 cs
= kzalloc(sizeof *cs
, GFP_KERNEL
);
724 cs
->base
= mcspi
->base
+ spi
->chip_select
* 0x14;
725 cs
->phys
= mcspi
->phys
+ spi
->chip_select
* 0x14;
727 spi
->controller_state
= cs
;
728 /* Link this to context save list */
729 list_add_tail(&cs
->node
,
730 &omap2_mcspi_ctx
[mcspi
->master
->bus_num
- 1].cs
);
733 if (mcspi_dma
->dma_rx_channel
== -1
734 || mcspi_dma
->dma_tx_channel
== -1) {
735 ret
= omap2_mcspi_request_dma(spi
);
740 if (omap2_mcspi_enable_clocks(mcspi
))
743 ret
= omap2_mcspi_setup_transfer(spi
, NULL
);
744 omap2_mcspi_disable_clocks(mcspi
);
749 static void omap2_mcspi_cleanup(struct spi_device
*spi
)
751 struct omap2_mcspi
*mcspi
;
752 struct omap2_mcspi_dma
*mcspi_dma
;
753 struct omap2_mcspi_cs
*cs
;
755 mcspi
= spi_master_get_devdata(spi
->master
);
756 mcspi_dma
= &mcspi
->dma_channels
[spi
->chip_select
];
758 if (spi
->controller_state
) {
759 /* Unlink controller state from context save list */
760 cs
= spi
->controller_state
;
763 kfree(spi
->controller_state
);
766 if (mcspi_dma
->dma_rx_channel
!= -1) {
767 omap_free_dma(mcspi_dma
->dma_rx_channel
);
768 mcspi_dma
->dma_rx_channel
= -1;
770 if (mcspi_dma
->dma_tx_channel
!= -1) {
771 omap_free_dma(mcspi_dma
->dma_tx_channel
);
772 mcspi_dma
->dma_tx_channel
= -1;
776 static void omap2_mcspi_work(struct work_struct
*work
)
778 struct omap2_mcspi
*mcspi
;
780 mcspi
= container_of(work
, struct omap2_mcspi
, work
);
781 spin_lock_irq(&mcspi
->lock
);
783 if (omap2_mcspi_enable_clocks(mcspi
))
786 /* We only enable one channel at a time -- the one whose message is
787 * at the head of the queue -- although this controller would gladly
788 * arbitrate among multiple channels. This corresponds to "single
789 * channel" master mode. As a side effect, we need to manage the
790 * chipselect with the FORCE bit ... CS != channel enable.
792 while (!list_empty(&mcspi
->msg_queue
)) {
793 struct spi_message
*m
;
794 struct spi_device
*spi
;
795 struct spi_transfer
*t
= NULL
;
797 struct omap2_mcspi_cs
*cs
;
798 int par_override
= 0;
802 m
= container_of(mcspi
->msg_queue
.next
, struct spi_message
,
805 list_del_init(&m
->queue
);
806 spin_unlock_irq(&mcspi
->lock
);
809 cs
= spi
->controller_state
;
811 omap2_mcspi_set_enable(spi
, 1);
812 list_for_each_entry(t
, &m
->transfers
, transfer_list
) {
813 if (t
->tx_buf
== NULL
&& t
->rx_buf
== NULL
&& t
->len
) {
817 if (par_override
|| t
->speed_hz
|| t
->bits_per_word
) {
819 status
= omap2_mcspi_setup_transfer(spi
, t
);
822 if (!t
->speed_hz
&& !t
->bits_per_word
)
827 omap2_mcspi_force_cs(spi
, 1);
831 chconf
= mcspi_cached_chconf0(spi
);
832 chconf
&= ~OMAP2_MCSPI_CHCONF_TRM_MASK
;
833 if (t
->tx_buf
== NULL
)
834 chconf
|= OMAP2_MCSPI_CHCONF_TRM_RX_ONLY
;
835 else if (t
->rx_buf
== NULL
)
836 chconf
|= OMAP2_MCSPI_CHCONF_TRM_TX_ONLY
;
837 mcspi_write_chconf0(spi
, chconf
);
842 /* RX_ONLY mode needs dummy data in TX reg */
843 if (t
->tx_buf
== NULL
)
844 __raw_writel(0, cs
->base
847 if (m
->is_dma_mapped
|| t
->len
>= DMA_MIN_BYTES
)
848 count
= omap2_mcspi_txrx_dma(spi
, t
);
850 count
= omap2_mcspi_txrx_pio(spi
, t
);
851 m
->actual_length
+= count
;
853 if (count
!= t
->len
) {
860 udelay(t
->delay_usecs
);
862 /* ignore the "leave it on after last xfer" hint */
864 omap2_mcspi_force_cs(spi
, 0);
869 /* Restore defaults if they were overriden */
872 status
= omap2_mcspi_setup_transfer(spi
, NULL
);
876 omap2_mcspi_force_cs(spi
, 0);
878 omap2_mcspi_set_enable(spi
, 0);
881 m
->complete(m
->context
);
883 spin_lock_irq(&mcspi
->lock
);
886 omap2_mcspi_disable_clocks(mcspi
);
889 spin_unlock_irq(&mcspi
->lock
);
892 static int omap2_mcspi_transfer(struct spi_device
*spi
, struct spi_message
*m
)
894 struct omap2_mcspi
*mcspi
;
896 struct spi_transfer
*t
;
898 m
->actual_length
= 0;
901 /* reject invalid messages and transfers */
902 if (list_empty(&m
->transfers
) || !m
->complete
)
904 list_for_each_entry(t
, &m
->transfers
, transfer_list
) {
905 const void *tx_buf
= t
->tx_buf
;
906 void *rx_buf
= t
->rx_buf
;
907 unsigned len
= t
->len
;
909 if (t
->speed_hz
> OMAP2_MCSPI_MAX_FREQ
910 || (len
&& !(rx_buf
|| tx_buf
))
911 || (t
->bits_per_word
&&
912 ( t
->bits_per_word
< 4
913 || t
->bits_per_word
> 32))) {
914 dev_dbg(&spi
->dev
, "transfer: %d Hz, %d %s%s, %d bpw\n",
922 if (t
->speed_hz
&& t
->speed_hz
< OMAP2_MCSPI_MAX_FREQ
/(1<<16)) {
923 dev_dbg(&spi
->dev
, "%d Hz max exceeds %d\n",
925 OMAP2_MCSPI_MAX_FREQ
/(1<<16));
929 if (m
->is_dma_mapped
|| len
< DMA_MIN_BYTES
)
932 /* Do DMA mapping "early" for better error reporting and
933 * dcache use. Note that if dma_unmap_single() ever starts
934 * to do real work on ARM, we'd need to clean up mappings
935 * for previous transfers on *ALL* exits of this loop...
937 if (tx_buf
!= NULL
) {
938 t
->tx_dma
= dma_map_single(&spi
->dev
, (void *) tx_buf
,
940 if (dma_mapping_error(&spi
->dev
, t
->tx_dma
)) {
941 dev_dbg(&spi
->dev
, "dma %cX %d bytes error\n",
946 if (rx_buf
!= NULL
) {
947 t
->rx_dma
= dma_map_single(&spi
->dev
, rx_buf
, t
->len
,
949 if (dma_mapping_error(&spi
->dev
, t
->rx_dma
)) {
950 dev_dbg(&spi
->dev
, "dma %cX %d bytes error\n",
953 dma_unmap_single(NULL
, t
->tx_dma
,
960 mcspi
= spi_master_get_devdata(spi
->master
);
962 spin_lock_irqsave(&mcspi
->lock
, flags
);
963 list_add_tail(&m
->queue
, &mcspi
->msg_queue
);
964 queue_work(omap2_mcspi_wq
, &mcspi
->work
);
965 spin_unlock_irqrestore(&mcspi
->lock
, flags
);
970 static int __init
omap2_mcspi_reset(struct omap2_mcspi
*mcspi
)
972 struct spi_master
*master
= mcspi
->master
;
975 if (omap2_mcspi_enable_clocks(mcspi
))
978 mcspi_write_reg(master
, OMAP2_MCSPI_SYSCONFIG
,
979 OMAP2_MCSPI_SYSCONFIG_SOFTRESET
);
981 tmp
= mcspi_read_reg(master
, OMAP2_MCSPI_SYSSTATUS
);
982 } while (!(tmp
& OMAP2_MCSPI_SYSSTATUS_RESETDONE
));
984 tmp
= OMAP2_MCSPI_SYSCONFIG_AUTOIDLE
|
985 OMAP2_MCSPI_SYSCONFIG_ENAWAKEUP
|
986 OMAP2_MCSPI_SYSCONFIG_SMARTIDLE
;
987 mcspi_write_reg(master
, OMAP2_MCSPI_SYSCONFIG
, tmp
);
988 omap2_mcspi_ctx
[master
->bus_num
- 1].sysconfig
= tmp
;
990 tmp
= OMAP2_MCSPI_WAKEUPENABLE_WKEN
;
991 mcspi_write_reg(master
, OMAP2_MCSPI_WAKEUPENABLE
, tmp
);
992 omap2_mcspi_ctx
[master
->bus_num
- 1].wakeupenable
= tmp
;
994 omap2_mcspi_set_master_mode(master
);
995 omap2_mcspi_disable_clocks(mcspi
);
999 static u8 __initdata spi1_rxdma_id
[] = {
1000 OMAP24XX_DMA_SPI1_RX0
,
1001 OMAP24XX_DMA_SPI1_RX1
,
1002 OMAP24XX_DMA_SPI1_RX2
,
1003 OMAP24XX_DMA_SPI1_RX3
,
1006 static u8 __initdata spi1_txdma_id
[] = {
1007 OMAP24XX_DMA_SPI1_TX0
,
1008 OMAP24XX_DMA_SPI1_TX1
,
1009 OMAP24XX_DMA_SPI1_TX2
,
1010 OMAP24XX_DMA_SPI1_TX3
,
1013 static u8 __initdata spi2_rxdma_id
[] = {
1014 OMAP24XX_DMA_SPI2_RX0
,
1015 OMAP24XX_DMA_SPI2_RX1
,
1018 static u8 __initdata spi2_txdma_id
[] = {
1019 OMAP24XX_DMA_SPI2_TX0
,
1020 OMAP24XX_DMA_SPI2_TX1
,
1023 #if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) \
1024 || defined(CONFIG_ARCH_OMAP4)
1025 static u8 __initdata spi3_rxdma_id
[] = {
1026 OMAP24XX_DMA_SPI3_RX0
,
1027 OMAP24XX_DMA_SPI3_RX1
,
1030 static u8 __initdata spi3_txdma_id
[] = {
1031 OMAP24XX_DMA_SPI3_TX0
,
1032 OMAP24XX_DMA_SPI3_TX1
,
1036 #if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)
1037 static u8 __initdata spi4_rxdma_id
[] = {
1038 OMAP34XX_DMA_SPI4_RX0
,
1041 static u8 __initdata spi4_txdma_id
[] = {
1042 OMAP34XX_DMA_SPI4_TX0
,
1046 static int __init
omap2_mcspi_probe(struct platform_device
*pdev
)
1048 struct spi_master
*master
;
1049 struct omap2_mcspi
*mcspi
;
1052 const u8
*rxdma_id
, *txdma_id
;
1053 unsigned num_chipselect
;
1057 rxdma_id
= spi1_rxdma_id
;
1058 txdma_id
= spi1_txdma_id
;
1062 rxdma_id
= spi2_rxdma_id
;
1063 txdma_id
= spi2_txdma_id
;
1066 #if defined(CONFIG_ARCH_OMAP2430) || defined(CONFIG_ARCH_OMAP3) \
1067 || defined(CONFIG_ARCH_OMAP4)
1069 rxdma_id
= spi3_rxdma_id
;
1070 txdma_id
= spi3_txdma_id
;
1074 #if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)
1076 rxdma_id
= spi4_rxdma_id
;
1077 txdma_id
= spi4_txdma_id
;
1085 master
= spi_alloc_master(&pdev
->dev
, sizeof *mcspi
);
1086 if (master
== NULL
) {
1087 dev_dbg(&pdev
->dev
, "master allocation failed\n");
1091 /* the spi->mode bits understood by this driver: */
1092 master
->mode_bits
= SPI_CPOL
| SPI_CPHA
| SPI_CS_HIGH
;
1095 master
->bus_num
= pdev
->id
;
1097 master
->setup
= omap2_mcspi_setup
;
1098 master
->transfer
= omap2_mcspi_transfer
;
1099 master
->cleanup
= omap2_mcspi_cleanup
;
1100 master
->num_chipselect
= num_chipselect
;
1102 dev_set_drvdata(&pdev
->dev
, master
);
1104 mcspi
= spi_master_get_devdata(master
);
1105 mcspi
->master
= master
;
1107 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1112 if (!request_mem_region(r
->start
, (r
->end
- r
->start
) + 1,
1113 dev_name(&pdev
->dev
))) {
1118 mcspi
->phys
= r
->start
;
1119 mcspi
->base
= ioremap(r
->start
, r
->end
- r
->start
+ 1);
1121 dev_dbg(&pdev
->dev
, "can't ioremap MCSPI\n");
1126 INIT_WORK(&mcspi
->work
, omap2_mcspi_work
);
1128 spin_lock_init(&mcspi
->lock
);
1129 INIT_LIST_HEAD(&mcspi
->msg_queue
);
1130 INIT_LIST_HEAD(&omap2_mcspi_ctx
[master
->bus_num
- 1].cs
);
1132 mcspi
->ick
= clk_get(&pdev
->dev
, "ick");
1133 if (IS_ERR(mcspi
->ick
)) {
1134 dev_dbg(&pdev
->dev
, "can't get mcspi_ick\n");
1135 status
= PTR_ERR(mcspi
->ick
);
1138 mcspi
->fck
= clk_get(&pdev
->dev
, "fck");
1139 if (IS_ERR(mcspi
->fck
)) {
1140 dev_dbg(&pdev
->dev
, "can't get mcspi_fck\n");
1141 status
= PTR_ERR(mcspi
->fck
);
1145 mcspi
->dma_channels
= kcalloc(master
->num_chipselect
,
1146 sizeof(struct omap2_mcspi_dma
),
1149 if (mcspi
->dma_channels
== NULL
)
1152 for (i
= 0; i
< num_chipselect
; i
++) {
1153 mcspi
->dma_channels
[i
].dma_rx_channel
= -1;
1154 mcspi
->dma_channels
[i
].dma_rx_sync_dev
= rxdma_id
[i
];
1155 mcspi
->dma_channels
[i
].dma_tx_channel
= -1;
1156 mcspi
->dma_channels
[i
].dma_tx_sync_dev
= txdma_id
[i
];
1159 if (omap2_mcspi_reset(mcspi
) < 0)
1162 status
= spi_register_master(master
);
1169 kfree(mcspi
->dma_channels
);
1171 clk_put(mcspi
->fck
);
1173 clk_put(mcspi
->ick
);
1175 iounmap(mcspi
->base
);
1177 release_mem_region(r
->start
, (r
->end
- r
->start
) + 1);
1179 spi_master_put(master
);
1183 static int __exit
omap2_mcspi_remove(struct platform_device
*pdev
)
1185 struct spi_master
*master
;
1186 struct omap2_mcspi
*mcspi
;
1187 struct omap2_mcspi_dma
*dma_channels
;
1191 master
= dev_get_drvdata(&pdev
->dev
);
1192 mcspi
= spi_master_get_devdata(master
);
1193 dma_channels
= mcspi
->dma_channels
;
1195 clk_put(mcspi
->fck
);
1196 clk_put(mcspi
->ick
);
1198 r
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1199 release_mem_region(r
->start
, (r
->end
- r
->start
) + 1);
1202 spi_unregister_master(master
);
1204 kfree(dma_channels
);
1209 /* work with hotplug and coldplug */
1210 MODULE_ALIAS("platform:omap2_mcspi");
1212 static struct platform_driver omap2_mcspi_driver
= {
1214 .name
= "omap2_mcspi",
1215 .owner
= THIS_MODULE
,
1217 .remove
= __exit_p(omap2_mcspi_remove
),
1221 static int __init
omap2_mcspi_init(void)
1223 omap2_mcspi_wq
= create_singlethread_workqueue(
1224 omap2_mcspi_driver
.driver
.name
);
1225 if (omap2_mcspi_wq
== NULL
)
1227 return platform_driver_probe(&omap2_mcspi_driver
, omap2_mcspi_probe
);
1229 subsys_initcall(omap2_mcspi_init
);
1231 static void __exit
omap2_mcspi_exit(void)
1233 platform_driver_unregister(&omap2_mcspi_driver
);
1235 destroy_workqueue(omap2_mcspi_wq
);
1237 module_exit(omap2_mcspi_exit
);
1239 MODULE_LICENSE("GPL");