2 * mmc_spi.c - Access SD/MMC cards through SPI master controllers
4 * (C) Copyright 2005, Intec Automation,
5 * Mike Lavender (mike@steroidmicros)
6 * (C) Copyright 2006-2007, David Brownell
7 * (C) Copyright 2007, Axis Communications,
8 * Hans-Peter Nilsson (hp@axis.com)
9 * (C) Copyright 2007, ATRON electronic GmbH,
10 * Jan Nikitenko <jan.nikitenko@gmail.com>
13 * This program is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * This program is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License
24 * along with this program; if not, write to the Free Software
25 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
27 #include <linux/hrtimer.h>
28 #include <linux/delay.h>
29 #include <linux/bio.h>
30 #include <linux/dma-mapping.h>
31 #include <linux/crc7.h>
32 #include <linux/crc-itu-t.h>
33 #include <linux/scatterlist.h>
35 #include <linux/mmc/host.h>
36 #include <linux/mmc/mmc.h> /* for R1_SPI_* bit values */
38 #include <linux/spi/spi.h>
39 #include <linux/spi/mmc_spi.h>
41 #include <asm/unaligned.h>
46 * - For now, we won't try to interoperate with a real mmc/sd/sdio
47 * controller, although some of them do have hardware support for
48 * SPI protocol. The main reason for such configs would be mmc-ish
49 * cards like DataFlash, which don't support that "native" protocol.
51 * We don't have a "DataFlash/MMC/SD/SDIO card slot" abstraction to
52 * switch between driver stacks, and in any case if "native" mode
53 * is available, it will be faster and hence preferable.
55 * - MMC depends on a different chipselect management policy than the
56 * SPI interface currently supports for shared bus segments: it needs
57 * to issue multiple spi_message requests with the chipselect active,
58 * using the results of one message to decide the next one to issue.
60 * Pending updates to the programming interface, this driver expects
61 * that it not share the bus with other drivers (precluding conflicts).
63 * - We tell the controller to keep the chipselect active from the
64 * beginning of an mmc_host_ops.request until the end. So beware
65 * of SPI controller drivers that mis-handle the cs_change flag!
67 * However, many cards seem OK with chipselect flapping up/down
68 * during that time ... at least on unshared bus segments.
73 * Local protocol constants, internal to data block protocols.
76 /* Response tokens used to ack each block written: */
77 #define SPI_MMC_RESPONSE_CODE(x) ((x) & 0x1f)
78 #define SPI_RESPONSE_ACCEPTED ((2 << 1)|1)
79 #define SPI_RESPONSE_CRC_ERR ((5 << 1)|1)
80 #define SPI_RESPONSE_WRITE_ERR ((6 << 1)|1)
82 /* Read and write blocks start with these tokens and end with crc;
83 * on error, read tokens act like a subset of R2_SPI_* values.
85 #define SPI_TOKEN_SINGLE 0xfe /* single block r/w, multiblock read */
86 #define SPI_TOKEN_MULTI_WRITE 0xfc /* multiblock write */
87 #define SPI_TOKEN_STOP_TRAN 0xfd /* terminate multiblock write */
89 #define MMC_SPI_BLOCKSIZE 512
92 /* These fixed timeouts come from the latest SD specs, which say to ignore
93 * the CSD values. The R1B value is for card erase (e.g. the "I forgot the
94 * card's password" scenario); it's mostly applied to STOP_TRANSMISSION after
95 * reads which takes nowhere near that long. Older cards may be able to use
96 * shorter timeouts ... but why bother?
98 #define r1b_timeout ktime_set(3, 0)
101 /****************************************************************************/
104 * Local Data Structures
107 /* "scratch" is per-{command,block} data exchanged with the card */
114 struct mmc_spi_host
{
115 struct mmc_host
*mmc
;
116 struct spi_device
*spi
;
118 unsigned char power_mode
;
121 struct mmc_spi_platform_data
*pdata
;
123 /* for bulk data transfers */
124 struct spi_transfer token
, t
, crc
, early_status
;
125 struct spi_message m
;
127 /* for status readback */
128 struct spi_transfer status
;
129 struct spi_message readback
;
131 /* underlying DMA-aware controller, or null */
132 struct device
*dma_dev
;
134 /* buffer used for commands and for message "overhead" */
135 struct scratch
*data
;
138 /* Specs say to write ones most of the time, even when the card
139 * has no need to read its input data; and many cards won't care.
140 * This is our source of those ones.
147 /****************************************************************************/
150 * MMC-over-SPI protocol glue, used by the MMC stack interface
153 static inline int mmc_cs_off(struct mmc_spi_host
*host
)
155 /* chipselect will always be inactive after setup() */
156 return spi_setup(host
->spi
);
160 mmc_spi_readbytes(struct mmc_spi_host
*host
, unsigned len
)
164 if (len
> sizeof(*host
->data
)) {
169 host
->status
.len
= len
;
172 dma_sync_single_for_device(host
->dma_dev
,
173 host
->data_dma
, sizeof(*host
->data
),
176 status
= spi_sync(host
->spi
, &host
->readback
);
179 dma_sync_single_for_cpu(host
->dma_dev
,
180 host
->data_dma
, sizeof(*host
->data
),
187 mmc_spi_skip(struct mmc_spi_host
*host
, ktime_t timeout
, unsigned n
, u8 byte
)
189 u8
*cp
= host
->data
->status
;
191 timeout
= ktime_add(timeout
, ktime_get());
197 status
= mmc_spi_readbytes(host
, n
);
201 for (i
= 0; i
< n
; i
++) {
206 /* REVISIT investigate msleep() to avoid busy-wait I/O
207 * in at least some cases.
209 if (ktime_to_ns(ktime_sub(ktime_get(), timeout
)) > 0)
216 mmc_spi_wait_unbusy(struct mmc_spi_host
*host
, ktime_t timeout
)
218 return mmc_spi_skip(host
, timeout
, sizeof(host
->data
->status
), 0);
221 static int mmc_spi_readtoken(struct mmc_spi_host
*host
, ktime_t timeout
)
223 return mmc_spi_skip(host
, timeout
, 1, 0xff);
228 * Note that for SPI, cmd->resp[0] is not the same data as "native" protocol
229 * hosts return! The low byte holds R1_SPI bits. The next byte may hold
230 * R2_SPI bits ... for SEND_STATUS, or after data read errors.
232 * cmd->resp[1] holds any four-byte response, for R3 (READ_OCR) and on
233 * newer cards R7 (IF_COND).
236 static char *maptype(struct mmc_command
*cmd
)
238 switch (mmc_spi_resp_type(cmd
)) {
239 case MMC_RSP_SPI_R1
: return "R1";
240 case MMC_RSP_SPI_R1B
: return "R1B";
241 case MMC_RSP_SPI_R2
: return "R2/R5";
242 case MMC_RSP_SPI_R3
: return "R3/R4/R7";
247 /* return zero, else negative errno after setting cmd->error */
248 static int mmc_spi_response_get(struct mmc_spi_host
*host
,
249 struct mmc_command
*cmd
, int cs_on
)
251 u8
*cp
= host
->data
->status
;
252 u8
*end
= cp
+ host
->t
.len
;
256 snprintf(tag
, sizeof(tag
), " ... CMD%d response SPI_%s",
257 cmd
->opcode
, maptype(cmd
));
259 /* Except for data block reads, the whole response will already
260 * be stored in the scratch buffer. It's somewhere after the
261 * command and the first byte we read after it. We ignore that
262 * first byte. After STOP_TRANSMISSION command it may include
263 * two data bits, but otherwise it's all ones.
266 while (cp
< end
&& *cp
== 0xff)
269 /* Data block reads (R1 response types) may need more data... */
273 cp
= host
->data
->status
;
275 /* Card sends N(CR) (== 1..8) bytes of all-ones then one
276 * status byte ... and we already scanned 2 bytes.
278 * REVISIT block read paths use nasty byte-at-a-time I/O
279 * so it can always DMA directly into the target buffer.
280 * It'd probably be better to memcpy() the first chunk and
281 * avoid extra i/o calls...
283 * Note we check for more than 8 bytes, because in practice,
284 * some SD cards are slow...
286 for (i
= 2; i
< 16; i
++) {
287 value
= mmc_spi_readbytes(host
, 1);
299 dev_dbg(&host
->spi
->dev
, "%s: INVALID RESPONSE, %02x\n",
305 cmd
->resp
[0] = *cp
++;
308 /* Status byte: the entire seven-bit R1 response. */
309 if (cmd
->resp
[0] != 0) {
310 if ((R1_SPI_PARAMETER
| R1_SPI_ADDRESS
311 | R1_SPI_ILLEGAL_COMMAND
)
314 else if (R1_SPI_COM_CRC
& cmd
->resp
[0])
316 else if ((R1_SPI_ERASE_SEQ
| R1_SPI_ERASE_RESET
)
319 /* else R1_SPI_IDLE, "it's resetting" */
322 switch (mmc_spi_resp_type(cmd
)) {
324 /* SPI R1B == R1 + busy; STOP_TRANSMISSION (for multiblock reads)
325 * and less-common stuff like various erase operations.
327 case MMC_RSP_SPI_R1B
:
328 /* maybe we read all the busy tokens already */
329 while (cp
< end
&& *cp
== 0)
332 mmc_spi_wait_unbusy(host
, r1b_timeout
);
335 /* SPI R2 == R1 + second status byte; SEND_STATUS
336 * SPI R5 == R1 + data byte; IO_RW_DIRECT
339 cmd
->resp
[0] |= *cp
<< 8;
342 /* SPI R3, R4, or R7 == R1 + 4 bytes */
344 cmd
->resp
[1] = get_unaligned_be32(cp
);
347 /* SPI R1 == just one status byte */
352 dev_dbg(&host
->spi
->dev
, "bad response type %04x\n",
353 mmc_spi_resp_type(cmd
));
360 dev_dbg(&host
->spi
->dev
, "%s: resp %04x %08x\n",
361 tag
, cmd
->resp
[0], cmd
->resp
[1]);
363 /* disable chipselect on errors and some success cases */
364 if (value
>= 0 && cs_on
)
373 /* Issue command and read its response.
374 * Returns zero on success, negative for error.
376 * On error, caller must cope with mmc core retry mechanism. That
377 * means immediate low-level resubmit, which affects the bus lock...
380 mmc_spi_command_send(struct mmc_spi_host
*host
,
381 struct mmc_request
*mrq
,
382 struct mmc_command
*cmd
, int cs_on
)
384 struct scratch
*data
= host
->data
;
385 u8
*cp
= data
->status
;
388 struct spi_transfer
*t
;
390 /* We can handle most commands (except block reads) in one full
391 * duplex I/O operation before either starting the next transfer
392 * (data block or command) or else deselecting the card.
394 * First, write 7 bytes:
395 * - an all-ones byte to ensure the card is ready
396 * - opcode byte (plus start and transmission bits)
397 * - four bytes of big-endian argument
398 * - crc7 (plus end bit) ... always computed, it's cheap
400 * We init the whole buffer to all-ones, which is what we need
401 * to write while we're reading (later) response data.
403 memset(cp
++, 0xff, sizeof(data
->status
));
405 *cp
++ = 0x40 | cmd
->opcode
;
406 *cp
++ = (u8
)(arg
>> 24);
407 *cp
++ = (u8
)(arg
>> 16);
408 *cp
++ = (u8
)(arg
>> 8);
410 *cp
++ = (crc7(0, &data
->status
[1], 5) << 1) | 0x01;
412 /* Then, read up to 13 bytes (while writing all-ones):
413 * - N(CR) (== 1..8) bytes of all-ones
414 * - status byte (for all response types)
415 * - the rest of the response, either:
416 * + nothing, for R1 or R1B responses
417 * + second status byte, for R2 responses
418 * + four data bytes, for R3 and R7 responses
420 * Finally, read some more bytes ... in the nice cases we know in
421 * advance how many, and reading 1 more is always OK:
422 * - N(EC) (== 0..N) bytes of all-ones, before deselect/finish
423 * - N(RC) (== 1..N) bytes of all-ones, before next command
424 * - N(WR) (== 1..N) bytes of all-ones, before data write
426 * So in those cases one full duplex I/O of at most 21 bytes will
427 * handle the whole command, leaving the card ready to receive a
428 * data block or new command. We do that whenever we can, shaving
429 * CPU and IRQ costs (especially when using DMA or FIFOs).
431 * There are two other cases, where it's not generally practical
432 * to rely on a single I/O:
434 * - R1B responses need at least N(EC) bytes of all-zeroes.
436 * In this case we can *try* to fit it into one I/O, then
437 * maybe read more data later.
439 * - Data block reads are more troublesome, since a variable
440 * number of padding bytes precede the token and data.
441 * + N(CX) (== 0..8) bytes of all-ones, before CSD or CID
442 * + N(AC) (== 1..many) bytes of all-ones
444 * In this case we currently only have minimal speedups here:
445 * when N(CR) == 1 we can avoid I/O in response_get().
447 if (cs_on
&& (mrq
->data
->flags
& MMC_DATA_READ
)) {
448 cp
+= 2; /* min(N(CR)) + status */
451 cp
+= 10; /* max(N(CR)) + status + min(N(RC),N(WR)) */
452 if (cmd
->flags
& MMC_RSP_SPI_S2
) /* R2/R5 */
454 else if (cmd
->flags
& MMC_RSP_SPI_B4
) /* R3/R4/R7 */
456 else if (cmd
->flags
& MMC_RSP_BUSY
) /* R1B */
457 cp
= data
->status
+ sizeof(data
->status
);
458 /* else: R1 (most commands) */
461 dev_dbg(&host
->spi
->dev
, " mmc_spi: CMD%d, resp %s\n",
462 cmd
->opcode
, maptype(cmd
));
464 /* send command, leaving chipselect active */
465 spi_message_init(&host
->m
);
468 memset(t
, 0, sizeof(*t
));
469 t
->tx_buf
= t
->rx_buf
= data
->status
;
470 t
->tx_dma
= t
->rx_dma
= host
->data_dma
;
471 t
->len
= cp
- data
->status
;
473 spi_message_add_tail(t
, &host
->m
);
476 host
->m
.is_dma_mapped
= 1;
477 dma_sync_single_for_device(host
->dma_dev
,
478 host
->data_dma
, sizeof(*host
->data
),
481 status
= spi_sync(host
->spi
, &host
->m
);
484 dma_sync_single_for_cpu(host
->dma_dev
,
485 host
->data_dma
, sizeof(*host
->data
),
488 dev_dbg(&host
->spi
->dev
, " ... write returned %d\n", status
);
493 /* after no-data commands and STOP_TRANSMISSION, chipselect off */
494 return mmc_spi_response_get(host
, cmd
, cs_on
);
497 /* Build data message with up to four separate transfers. For TX, we
498 * start by writing the data token. And in most cases, we finish with
501 * We always provide TX data for data and CRC. The MMC/SD protocol
502 * requires us to write ones; but Linux defaults to writing zeroes;
503 * so we explicitly initialize it to all ones on RX paths.
505 * We also handle DMA mapping, so the underlying SPI controller does
506 * not need to (re)do it for each message.
509 mmc_spi_setup_data_message(
510 struct mmc_spi_host
*host
,
512 enum dma_data_direction direction
)
514 struct spi_transfer
*t
;
515 struct scratch
*scratch
= host
->data
;
516 dma_addr_t dma
= host
->data_dma
;
518 spi_message_init(&host
->m
);
520 host
->m
.is_dma_mapped
= 1;
522 /* for reads, readblock() skips 0xff bytes before finding
523 * the token; for writes, this transfer issues that token.
525 if (direction
== DMA_TO_DEVICE
) {
527 memset(t
, 0, sizeof(*t
));
530 scratch
->data_token
= SPI_TOKEN_MULTI_WRITE
;
532 scratch
->data_token
= SPI_TOKEN_SINGLE
;
533 t
->tx_buf
= &scratch
->data_token
;
535 t
->tx_dma
= dma
+ offsetof(struct scratch
, data_token
);
536 spi_message_add_tail(t
, &host
->m
);
539 /* Body of transfer is buffer, then CRC ...
540 * either TX-only, or RX with TX-ones.
543 memset(t
, 0, sizeof(*t
));
544 t
->tx_buf
= host
->ones
;
545 t
->tx_dma
= host
->ones_dma
;
546 /* length and actual buffer info are written later */
547 spi_message_add_tail(t
, &host
->m
);
550 memset(t
, 0, sizeof(*t
));
552 if (direction
== DMA_TO_DEVICE
) {
553 /* the actual CRC may get written later */
554 t
->tx_buf
= &scratch
->crc_val
;
556 t
->tx_dma
= dma
+ offsetof(struct scratch
, crc_val
);
558 t
->tx_buf
= host
->ones
;
559 t
->tx_dma
= host
->ones_dma
;
560 t
->rx_buf
= &scratch
->crc_val
;
562 t
->rx_dma
= dma
+ offsetof(struct scratch
, crc_val
);
564 spi_message_add_tail(t
, &host
->m
);
567 * A single block read is followed by N(EC) [0+] all-ones bytes
568 * before deselect ... don't bother.
570 * Multiblock reads are followed by N(AC) [1+] all-ones bytes before
571 * the next block is read, or a STOP_TRANSMISSION is issued. We'll
572 * collect that single byte, so readblock() doesn't need to.
574 * For a write, the one-byte data response follows immediately, then
575 * come zero or more busy bytes, then N(WR) [1+] all-ones bytes.
576 * Then single block reads may deselect, and multiblock ones issue
577 * the next token (next data block, or STOP_TRAN). We can try to
578 * minimize I/O ops by using a single read to collect end-of-busy.
580 if (multiple
|| direction
== DMA_TO_DEVICE
) {
581 t
= &host
->early_status
;
582 memset(t
, 0, sizeof(*t
));
583 t
->len
= (direction
== DMA_TO_DEVICE
)
584 ? sizeof(scratch
->status
)
586 t
->tx_buf
= host
->ones
;
587 t
->tx_dma
= host
->ones_dma
;
588 t
->rx_buf
= scratch
->status
;
590 t
->rx_dma
= dma
+ offsetof(struct scratch
, status
);
592 spi_message_add_tail(t
, &host
->m
);
598 * - caller handled preceding N(WR) [1+] all-ones bytes
603 * - an all-ones byte ... card writes a data-response byte
604 * - followed by N(EC) [0+] all-ones bytes, card writes zero/'busy'
606 * Return negative errno, else success.
609 mmc_spi_writeblock(struct mmc_spi_host
*host
, struct spi_transfer
*t
,
612 struct spi_device
*spi
= host
->spi
;
614 struct scratch
*scratch
= host
->data
;
617 if (host
->mmc
->use_spi_crc
)
618 scratch
->crc_val
= cpu_to_be16(
619 crc_itu_t(0, t
->tx_buf
, t
->len
));
621 dma_sync_single_for_device(host
->dma_dev
,
622 host
->data_dma
, sizeof(*scratch
),
625 status
= spi_sync(spi
, &host
->m
);
628 dev_dbg(&spi
->dev
, "write error (%d)\n", status
);
633 dma_sync_single_for_cpu(host
->dma_dev
,
634 host
->data_dma
, sizeof(*scratch
),
638 * Get the transmission data-response reply. It must follow
639 * immediately after the data block we transferred. This reply
640 * doesn't necessarily tell whether the write operation succeeded;
641 * it just says if the transmission was ok and whether *earlier*
642 * writes succeeded; see the standard.
644 * In practice, there are (even modern SDHC-)cards which are late
645 * in sending the response, and miss the time frame by a few bits,
646 * so we have to cope with this situation and check the response
647 * bit-by-bit. Arggh!!!
649 pattern
= scratch
->status
[0] << 24;
650 pattern
|= scratch
->status
[1] << 16;
651 pattern
|= scratch
->status
[2] << 8;
652 pattern
|= scratch
->status
[3];
654 /* First 3 bit of pattern are undefined */
655 pattern
|= 0xE0000000;
657 /* left-adjust to leading 0 bit */
658 while (pattern
& 0x80000000)
660 /* right-adjust for pattern matching. Code is in bit 4..0 now. */
664 case SPI_RESPONSE_ACCEPTED
:
667 case SPI_RESPONSE_CRC_ERR
:
668 /* host shall then issue MMC_STOP_TRANSMISSION */
671 case SPI_RESPONSE_WRITE_ERR
:
672 /* host shall then issue MMC_STOP_TRANSMISSION,
673 * and should MMC_SEND_STATUS to sort it out
682 dev_dbg(&spi
->dev
, "write error %02x (%d)\n",
683 scratch
->status
[0], status
);
691 /* Return when not busy. If we didn't collect that status yet,
692 * we'll need some more I/O.
694 for (i
= 4; i
< sizeof(scratch
->status
); i
++) {
695 /* card is non-busy if the most recent bit is 1 */
696 if (scratch
->status
[i
] & 0x01)
699 return mmc_spi_wait_unbusy(host
, timeout
);
704 * - skip leading all-ones bytes ... either
705 * + N(AC) [1..f(clock,CSD)] usually, else
706 * + N(CX) [0..8] when reading CSD or CID
708 * + token ... if error token, no data or crc
712 * After single block reads, we're done; N(EC) [0+] all-ones bytes follow
713 * before dropping chipselect.
715 * For multiblock reads, caller either reads the next block or issues a
716 * STOP_TRANSMISSION command.
719 mmc_spi_readblock(struct mmc_spi_host
*host
, struct spi_transfer
*t
,
722 struct spi_device
*spi
= host
->spi
;
724 struct scratch
*scratch
= host
->data
;
726 /* At least one SD card sends an all-zeroes byte when N(CX)
727 * applies, before the all-ones bytes ... just cope with that.
729 status
= mmc_spi_readbytes(host
, 1);
732 status
= scratch
->status
[0];
733 if (status
== 0xff || status
== 0)
734 status
= mmc_spi_readtoken(host
, timeout
);
736 if (status
== SPI_TOKEN_SINGLE
) {
738 dma_sync_single_for_device(host
->dma_dev
,
739 host
->data_dma
, sizeof(*scratch
),
741 dma_sync_single_for_device(host
->dma_dev
,
746 status
= spi_sync(spi
, &host
->m
);
749 dma_sync_single_for_cpu(host
->dma_dev
,
750 host
->data_dma
, sizeof(*scratch
),
752 dma_sync_single_for_cpu(host
->dma_dev
,
758 dev_dbg(&spi
->dev
, "read error %02x (%d)\n", status
, status
);
760 /* we've read extra garbage, timed out, etc */
764 /* low four bits are an R2 subset, fifth seems to be
765 * vendor specific ... map them all to generic error..
770 if (host
->mmc
->use_spi_crc
) {
771 u16 crc
= crc_itu_t(0, t
->rx_buf
, t
->len
);
773 be16_to_cpus(&scratch
->crc_val
);
774 if (scratch
->crc_val
!= crc
) {
775 dev_dbg(&spi
->dev
, "read - crc error: crc_val=0x%04x, "
776 "computed=0x%04x len=%d\n",
777 scratch
->crc_val
, crc
, t
->len
);
790 * An MMC/SD data stage includes one or more blocks, optional CRCs,
791 * and inline handshaking. That handhaking makes it unlike most
792 * other SPI protocol stacks.
795 mmc_spi_data_do(struct mmc_spi_host
*host
, struct mmc_command
*cmd
,
796 struct mmc_data
*data
, u32 blk_size
)
798 struct spi_device
*spi
= host
->spi
;
799 struct device
*dma_dev
= host
->dma_dev
;
800 struct spi_transfer
*t
;
801 enum dma_data_direction direction
;
802 struct scatterlist
*sg
;
804 int multiple
= (data
->blocks
> 1);
808 if (data
->flags
& MMC_DATA_READ
)
809 direction
= DMA_FROM_DEVICE
;
811 direction
= DMA_TO_DEVICE
;
812 mmc_spi_setup_data_message(host
, multiple
, direction
);
816 clock_rate
= t
->speed_hz
;
818 clock_rate
= spi
->max_speed_hz
;
820 timeout
= ktime_add_ns(ktime_set(0, 0), data
->timeout_ns
+
821 data
->timeout_clks
* 1000000 / clock_rate
);
823 /* Handle scatterlist segments one at a time, with synch for
824 * each 512-byte block
826 for (sg
= data
->sg
, n_sg
= data
->sg_len
; n_sg
; n_sg
--, sg
++) {
828 dma_addr_t dma_addr
= 0;
830 unsigned length
= sg
->length
;
831 enum dma_data_direction dir
= direction
;
833 /* set up dma mapping for controller drivers that might
834 * use DMA ... though they may fall back to PIO
837 /* never invalidate whole *shared* pages ... */
838 if ((sg
->offset
!= 0 || length
!= PAGE_SIZE
)
839 && dir
== DMA_FROM_DEVICE
)
840 dir
= DMA_BIDIRECTIONAL
;
842 dma_addr
= dma_map_page(dma_dev
, sg_page(sg
), 0,
844 if (direction
== DMA_TO_DEVICE
)
845 t
->tx_dma
= dma_addr
+ sg
->offset
;
847 t
->rx_dma
= dma_addr
+ sg
->offset
;
850 /* allow pio too; we don't allow highmem */
851 kmap_addr
= kmap(sg_page(sg
));
852 if (direction
== DMA_TO_DEVICE
)
853 t
->tx_buf
= kmap_addr
+ sg
->offset
;
855 t
->rx_buf
= kmap_addr
+ sg
->offset
;
857 /* transfer each block, and update request status */
859 t
->len
= min(length
, blk_size
);
861 dev_dbg(&host
->spi
->dev
,
862 " mmc_spi: %s block, %d bytes\n",
863 (direction
== DMA_TO_DEVICE
)
868 if (direction
== DMA_TO_DEVICE
)
869 status
= mmc_spi_writeblock(host
, t
, timeout
);
871 status
= mmc_spi_readblock(host
, t
, timeout
);
875 data
->bytes_xfered
+= t
->len
;
882 /* discard mappings */
883 if (direction
== DMA_FROM_DEVICE
)
884 flush_kernel_dcache_page(sg_page(sg
));
887 dma_unmap_page(dma_dev
, dma_addr
, PAGE_SIZE
, dir
);
890 data
->error
= status
;
891 dev_dbg(&spi
->dev
, "%s status %d\n",
892 (direction
== DMA_TO_DEVICE
)
899 /* NOTE some docs describe an MMC-only SET_BLOCK_COUNT (CMD23) that
900 * can be issued before multiblock writes. Unlike its more widely
901 * documented analogue for SD cards (SET_WR_BLK_ERASE_COUNT, ACMD23),
902 * that can affect the STOP_TRAN logic. Complete (and current)
903 * MMC specs should sort that out before Linux starts using CMD23.
905 if (direction
== DMA_TO_DEVICE
&& multiple
) {
906 struct scratch
*scratch
= host
->data
;
908 const unsigned statlen
= sizeof(scratch
->status
);
910 dev_dbg(&spi
->dev
, " mmc_spi: STOP_TRAN\n");
912 /* Tweak the per-block message we set up earlier by morphing
913 * it to hold single buffer with the token followed by some
914 * all-ones bytes ... skip N(BR) (0..1), scan the rest for
915 * "not busy any longer" status, and leave chip selected.
917 INIT_LIST_HEAD(&host
->m
.transfers
);
918 list_add(&host
->early_status
.transfer_list
,
921 memset(scratch
->status
, 0xff, statlen
);
922 scratch
->status
[0] = SPI_TOKEN_STOP_TRAN
;
924 host
->early_status
.tx_buf
= host
->early_status
.rx_buf
;
925 host
->early_status
.tx_dma
= host
->early_status
.rx_dma
;
926 host
->early_status
.len
= statlen
;
929 dma_sync_single_for_device(host
->dma_dev
,
930 host
->data_dma
, sizeof(*scratch
),
933 tmp
= spi_sync(spi
, &host
->m
);
936 dma_sync_single_for_cpu(host
->dma_dev
,
937 host
->data_dma
, sizeof(*scratch
),
946 /* Ideally we collected "not busy" status with one I/O,
947 * avoiding wasteful byte-at-a-time scanning... but more
948 * I/O is often needed.
950 for (tmp
= 2; tmp
< statlen
; tmp
++) {
951 if (scratch
->status
[tmp
] != 0)
954 tmp
= mmc_spi_wait_unbusy(host
, timeout
);
955 if (tmp
< 0 && !data
->error
)
960 /****************************************************************************/
963 * MMC driver implementation -- the interface to the MMC stack
966 static void mmc_spi_request(struct mmc_host
*mmc
, struct mmc_request
*mrq
)
968 struct mmc_spi_host
*host
= mmc_priv(mmc
);
969 int status
= -EINVAL
;
972 /* MMC core and layered drivers *MUST* issue SPI-aware commands */
974 struct mmc_command
*cmd
;
978 if (!mmc_spi_resp_type(cmd
)) {
979 dev_dbg(&host
->spi
->dev
, "bogus command\n");
980 cmd
->error
= -EINVAL
;
985 if (cmd
&& !mmc_spi_resp_type(cmd
)) {
986 dev_dbg(&host
->spi
->dev
, "bogus STOP command\n");
987 cmd
->error
= -EINVAL
;
993 mmc_request_done(host
->mmc
, mrq
);
999 /* issue command; then optionally data and stop */
1000 status
= mmc_spi_command_send(host
, mrq
, mrq
->cmd
, mrq
->data
!= NULL
);
1001 if (status
== 0 && mrq
->data
) {
1002 mmc_spi_data_do(host
, mrq
->cmd
, mrq
->data
, mrq
->data
->blksz
);
1004 status
= mmc_spi_command_send(host
, mrq
, mrq
->stop
, 0);
1009 mmc_request_done(host
->mmc
, mrq
);
1012 /* See Section 6.4.1, in SD "Simplified Physical Layer Specification 2.0"
1014 * NOTE that here we can't know that the card has just been powered up;
1015 * not all MMC/SD sockets support power switching.
1017 * FIXME when the card is still in SPI mode, e.g. from a previous kernel,
1018 * this doesn't seem to do the right thing at all...
1020 static void mmc_spi_initsequence(struct mmc_spi_host
*host
)
1022 /* Try to be very sure any previous command has completed;
1023 * wait till not-busy, skip debris from any old commands.
1025 mmc_spi_wait_unbusy(host
, r1b_timeout
);
1026 mmc_spi_readbytes(host
, 10);
1029 * Do a burst with chipselect active-high. We need to do this to
1030 * meet the requirement of 74 clock cycles with both chipselect
1031 * and CMD (MOSI) high before CMD0 ... after the card has been
1032 * powered up to Vdd(min), and so is ready to take commands.
1034 * Some cards are particularly needy of this (e.g. Viking "SD256")
1035 * while most others don't seem to care.
1037 * Note that this is one of the places MMC/SD plays games with the
1038 * SPI protocol. Another is that when chipselect is released while
1039 * the card returns BUSY status, the clock must issue several cycles
1040 * with chipselect high before the card will stop driving its output.
1042 host
->spi
->mode
|= SPI_CS_HIGH
;
1043 if (spi_setup(host
->spi
) != 0) {
1044 /* Just warn; most cards work without it. */
1045 dev_warn(&host
->spi
->dev
,
1046 "can't change chip-select polarity\n");
1047 host
->spi
->mode
&= ~SPI_CS_HIGH
;
1049 mmc_spi_readbytes(host
, 18);
1051 host
->spi
->mode
&= ~SPI_CS_HIGH
;
1052 if (spi_setup(host
->spi
) != 0) {
1053 /* Wot, we can't get the same setup we had before? */
1054 dev_err(&host
->spi
->dev
,
1055 "can't restore chip-select polarity\n");
1060 static char *mmc_powerstring(u8 power_mode
)
1062 switch (power_mode
) {
1063 case MMC_POWER_OFF
: return "off";
1064 case MMC_POWER_UP
: return "up";
1065 case MMC_POWER_ON
: return "on";
1070 static void mmc_spi_set_ios(struct mmc_host
*mmc
, struct mmc_ios
*ios
)
1072 struct mmc_spi_host
*host
= mmc_priv(mmc
);
1074 if (host
->power_mode
!= ios
->power_mode
) {
1077 canpower
= host
->pdata
&& host
->pdata
->setpower
;
1079 dev_dbg(&host
->spi
->dev
, "mmc_spi: power %s (%d)%s\n",
1080 mmc_powerstring(ios
->power_mode
),
1082 canpower
? ", can switch" : "");
1084 /* switch power on/off if possible, accounting for
1085 * max 250msec powerup time if needed.
1088 switch (ios
->power_mode
) {
1091 host
->pdata
->setpower(&host
->spi
->dev
,
1093 if (ios
->power_mode
== MMC_POWER_UP
)
1094 msleep(host
->powerup_msecs
);
1098 /* See 6.4.1 in the simplified SD card physical spec 2.0 */
1099 if (ios
->power_mode
== MMC_POWER_ON
)
1100 mmc_spi_initsequence(host
);
1102 /* If powering down, ground all card inputs to avoid power
1103 * delivery from data lines! On a shared SPI bus, this
1104 * will probably be temporary; 6.4.2 of the simplified SD
1105 * spec says this must last at least 1msec.
1107 * - Clock low means CPOL 0, e.g. mode 0
1108 * - MOSI low comes from writing zero
1109 * - Chipselect is usually active low...
1111 if (canpower
&& ios
->power_mode
== MMC_POWER_OFF
) {
1115 host
->spi
->mode
&= ~(SPI_CPOL
|SPI_CPHA
);
1116 mres
= spi_setup(host
->spi
);
1118 dev_dbg(&host
->spi
->dev
,
1119 "switch to SPI mode 0 failed\n");
1121 if (spi_write(host
->spi
, &nullbyte
, 1) < 0)
1122 dev_dbg(&host
->spi
->dev
,
1123 "put spi signals to low failed\n");
1126 * Now clock should be low due to spi mode 0;
1127 * MOSI should be low because of written 0x00;
1128 * chipselect should be low (it is active low)
1129 * power supply is off, so now MMC is off too!
1131 * FIXME no, chipselect can be high since the
1132 * device is inactive and SPI_CS_HIGH is clear...
1136 host
->spi
->mode
|= (SPI_CPOL
|SPI_CPHA
);
1137 mres
= spi_setup(host
->spi
);
1139 dev_dbg(&host
->spi
->dev
,
1140 "switch back to SPI mode 3"
1145 host
->power_mode
= ios
->power_mode
;
1148 if (host
->spi
->max_speed_hz
!= ios
->clock
&& ios
->clock
!= 0) {
1151 host
->spi
->max_speed_hz
= ios
->clock
;
1152 status
= spi_setup(host
->spi
);
1153 dev_dbg(&host
->spi
->dev
,
1154 "mmc_spi: clock to %d Hz, %d\n",
1155 host
->spi
->max_speed_hz
, status
);
1159 static int mmc_spi_get_ro(struct mmc_host
*mmc
)
1161 struct mmc_spi_host
*host
= mmc_priv(mmc
);
1163 if (host
->pdata
&& host
->pdata
->get_ro
)
1164 return !!host
->pdata
->get_ro(mmc
->parent
);
1166 * Board doesn't support read only detection; let the mmc core
1167 * decide what to do.
1172 static int mmc_spi_get_cd(struct mmc_host
*mmc
)
1174 struct mmc_spi_host
*host
= mmc_priv(mmc
);
1176 if (host
->pdata
&& host
->pdata
->get_cd
)
1177 return !!host
->pdata
->get_cd(mmc
->parent
);
1181 static const struct mmc_host_ops mmc_spi_ops
= {
1182 .request
= mmc_spi_request
,
1183 .set_ios
= mmc_spi_set_ios
,
1184 .get_ro
= mmc_spi_get_ro
,
1185 .get_cd
= mmc_spi_get_cd
,
1189 /****************************************************************************/
1192 * SPI driver implementation
1196 mmc_spi_detect_irq(int irq
, void *mmc
)
1198 struct mmc_spi_host
*host
= mmc_priv(mmc
);
1199 u16 delay_msec
= max(host
->pdata
->detect_delay
, (u16
)100);
1201 mmc_detect_change(mmc
, msecs_to_jiffies(delay_msec
));
1205 struct count_children
{
1207 struct bus_type
*bus
;
1210 static int maybe_count_child(struct device
*dev
, void *c
)
1212 struct count_children
*ccp
= c
;
1214 if (dev
->bus
== ccp
->bus
) {
1222 static int mmc_spi_probe(struct spi_device
*spi
)
1225 struct mmc_host
*mmc
;
1226 struct mmc_spi_host
*host
;
1229 /* MMC and SD specs only seem to care that sampling is on the
1230 * rising edge ... meaning SPI modes 0 or 3. So either SPI mode
1231 * should be legit. We'll use mode 0 since the steady state is 0,
1232 * which is appropriate for hotplugging, unless the platform data
1233 * specify mode 3 (if hardware is not compatible to mode 0).
1235 if (spi
->mode
!= SPI_MODE_3
)
1236 spi
->mode
= SPI_MODE_0
;
1237 spi
->bits_per_word
= 8;
1239 status
= spi_setup(spi
);
1241 dev_dbg(&spi
->dev
, "needs SPI mode %02x, %d KHz; %d\n",
1242 spi
->mode
, spi
->max_speed_hz
/ 1000,
1247 /* We can use the bus safely iff nobody else will interfere with us.
1248 * Most commands consist of one SPI message to issue a command, then
1249 * several more to collect its response, then possibly more for data
1250 * transfer. Clocking access to other devices during that period will
1251 * corrupt the command execution.
1253 * Until we have software primitives which guarantee non-interference,
1254 * we'll aim for a hardware-level guarantee.
1256 * REVISIT we can't guarantee another device won't be added later...
1258 if (spi
->master
->num_chipselect
> 1) {
1259 struct count_children cc
;
1262 cc
.bus
= spi
->dev
.bus
;
1263 status
= device_for_each_child(spi
->dev
.parent
, &cc
,
1266 dev_err(&spi
->dev
, "can't share SPI bus\n");
1270 dev_warn(&spi
->dev
, "ASSUMING SPI bus stays unshared!\n");
1273 /* We need a supply of ones to transmit. This is the only time
1274 * the CPU touches these, so cache coherency isn't a concern.
1276 * NOTE if many systems use more than one MMC-over-SPI connector
1277 * it'd save some memory to share this. That's evidently rare.
1280 ones
= kmalloc(MMC_SPI_BLOCKSIZE
, GFP_KERNEL
);
1283 memset(ones
, 0xff, MMC_SPI_BLOCKSIZE
);
1285 mmc
= mmc_alloc_host(sizeof(*host
), &spi
->dev
);
1289 mmc
->ops
= &mmc_spi_ops
;
1290 mmc
->max_blk_size
= MMC_SPI_BLOCKSIZE
;
1292 mmc
->caps
= MMC_CAP_SPI
;
1294 /* SPI doesn't need the lowspeed device identification thing for
1295 * MMC or SD cards, since it never comes up in open drain mode.
1296 * That's good; some SPI masters can't handle very low speeds!
1298 * However, low speed SDIO cards need not handle over 400 KHz;
1299 * that's the only reason not to use a few MHz for f_min (until
1300 * the upper layer reads the target frequency from the CSD).
1302 mmc
->f_min
= 400000;
1303 mmc
->f_max
= spi
->max_speed_hz
;
1305 host
= mmc_priv(mmc
);
1311 /* Platform data is used to hook up things like card sensing
1312 * and power switching gpios.
1314 host
->pdata
= mmc_spi_get_pdata(spi
);
1316 mmc
->ocr_avail
= host
->pdata
->ocr_mask
;
1317 if (!mmc
->ocr_avail
) {
1318 dev_warn(&spi
->dev
, "ASSUMING 3.2-3.4 V slot power\n");
1319 mmc
->ocr_avail
= MMC_VDD_32_33
|MMC_VDD_33_34
;
1321 if (host
->pdata
&& host
->pdata
->setpower
) {
1322 host
->powerup_msecs
= host
->pdata
->powerup_msecs
;
1323 if (!host
->powerup_msecs
|| host
->powerup_msecs
> 250)
1324 host
->powerup_msecs
= 250;
1327 dev_set_drvdata(&spi
->dev
, mmc
);
1329 /* preallocate dma buffers */
1330 host
->data
= kmalloc(sizeof(*host
->data
), GFP_KERNEL
);
1334 if (spi
->master
->dev
.parent
->dma_mask
) {
1335 struct device
*dev
= spi
->master
->dev
.parent
;
1337 host
->dma_dev
= dev
;
1338 host
->ones_dma
= dma_map_single(dev
, ones
,
1339 MMC_SPI_BLOCKSIZE
, DMA_TO_DEVICE
);
1340 host
->data_dma
= dma_map_single(dev
, host
->data
,
1341 sizeof(*host
->data
), DMA_BIDIRECTIONAL
);
1343 /* REVISIT in theory those map operations can fail... */
1345 dma_sync_single_for_cpu(host
->dma_dev
,
1346 host
->data_dma
, sizeof(*host
->data
),
1350 /* setup message for status/busy readback */
1351 spi_message_init(&host
->readback
);
1352 host
->readback
.is_dma_mapped
= (host
->dma_dev
!= NULL
);
1354 spi_message_add_tail(&host
->status
, &host
->readback
);
1355 host
->status
.tx_buf
= host
->ones
;
1356 host
->status
.tx_dma
= host
->ones_dma
;
1357 host
->status
.rx_buf
= &host
->data
->status
;
1358 host
->status
.rx_dma
= host
->data_dma
+ offsetof(struct scratch
, status
);
1359 host
->status
.cs_change
= 1;
1361 /* register card detect irq */
1362 if (host
->pdata
&& host
->pdata
->init
) {
1363 status
= host
->pdata
->init(&spi
->dev
, mmc_spi_detect_irq
, mmc
);
1365 goto fail_glue_init
;
1368 /* pass platform capabilities, if any */
1370 mmc
->caps
|= host
->pdata
->caps
;
1372 status
= mmc_add_host(mmc
);
1376 dev_info(&spi
->dev
, "SD/MMC host %s%s%s%s%s\n",
1377 dev_name(&mmc
->class_dev
),
1378 host
->dma_dev
? "" : ", no DMA",
1379 (host
->pdata
&& host
->pdata
->get_ro
)
1381 (host
->pdata
&& host
->pdata
->setpower
)
1382 ? "" : ", no poweroff",
1383 (mmc
->caps
& MMC_CAP_NEEDS_POLL
)
1384 ? ", cd polling" : "");
1388 mmc_remove_host (mmc
);
1391 dma_unmap_single(host
->dma_dev
, host
->data_dma
,
1392 sizeof(*host
->data
), DMA_BIDIRECTIONAL
);
1397 mmc_spi_put_pdata(spi
);
1398 dev_set_drvdata(&spi
->dev
, NULL
);
1406 static int __devexit
mmc_spi_remove(struct spi_device
*spi
)
1408 struct mmc_host
*mmc
= dev_get_drvdata(&spi
->dev
);
1409 struct mmc_spi_host
*host
;
1412 host
= mmc_priv(mmc
);
1414 /* prevent new mmc_detect_change() calls */
1415 if (host
->pdata
&& host
->pdata
->exit
)
1416 host
->pdata
->exit(&spi
->dev
, mmc
);
1418 mmc_remove_host(mmc
);
1420 if (host
->dma_dev
) {
1421 dma_unmap_single(host
->dma_dev
, host
->ones_dma
,
1422 MMC_SPI_BLOCKSIZE
, DMA_TO_DEVICE
);
1423 dma_unmap_single(host
->dma_dev
, host
->data_dma
,
1424 sizeof(*host
->data
), DMA_BIDIRECTIONAL
);
1430 spi
->max_speed_hz
= mmc
->f_max
;
1432 mmc_spi_put_pdata(spi
);
1433 dev_set_drvdata(&spi
->dev
, NULL
);
1439 static struct spi_driver mmc_spi_driver
= {
1442 .bus
= &spi_bus_type
,
1443 .owner
= THIS_MODULE
,
1445 .probe
= mmc_spi_probe
,
1446 .remove
= __devexit_p(mmc_spi_remove
),
1450 static int __init
mmc_spi_init(void)
1452 return spi_register_driver(&mmc_spi_driver
);
1454 module_init(mmc_spi_init
);
1457 static void __exit
mmc_spi_exit(void)
1459 spi_unregister_driver(&mmc_spi_driver
);
1461 module_exit(mmc_spi_exit
);
1464 MODULE_AUTHOR("Mike Lavender, David Brownell, "
1465 "Hans-Peter Nilsson, Jan Nikitenko");
1466 MODULE_DESCRIPTION("SPI SD/MMC host driver");
1467 MODULE_LICENSE("GPL");