2 * linux/drivers/mmc/core/mmc_ops.h
4 * Copyright 2006-2007 Pierre Ossman
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or (at
9 * your option) any later version.
12 #include <linux/slab.h>
13 #include <linux/export.h>
14 #include <linux/types.h>
15 #include <linux/scatterlist.h>
17 #include <linux/mmc/host.h>
18 #include <linux/mmc/card.h>
19 #include <linux/mmc/mmc.h>
24 static int _mmc_select_card(struct mmc_host
*host
, struct mmc_card
*card
)
27 struct mmc_command cmd
= {0};
31 cmd
.opcode
= MMC_SELECT_CARD
;
34 cmd
.arg
= card
->rca
<< 16;
35 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
38 cmd
.flags
= MMC_RSP_NONE
| MMC_CMD_AC
;
41 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
48 int mmc_select_card(struct mmc_card
*card
)
52 return _mmc_select_card(card
->host
, card
);
55 int mmc_deselect_cards(struct mmc_host
*host
)
57 return _mmc_select_card(host
, NULL
);
60 int mmc_card_sleepawake(struct mmc_host
*host
, int sleep
)
62 struct mmc_command cmd
= {0};
63 struct mmc_card
*card
= host
->card
;
67 mmc_deselect_cards(host
);
69 cmd
.opcode
= MMC_SLEEP_AWAKE
;
70 cmd
.arg
= card
->rca
<< 16;
74 cmd
.flags
= MMC_RSP_R1B
| MMC_CMD_AC
;
75 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
80 * If the host does not wait while the card signals busy, then we will
81 * will have to wait the sleep/awake timeout. Note, we cannot use the
82 * SEND_STATUS command to poll the status because that command (and most
83 * others) is invalid while the card sleeps.
85 if (!(host
->caps
& MMC_CAP_WAIT_WHILE_BUSY
))
86 mmc_delay(DIV_ROUND_UP(card
->ext_csd
.sa_timeout
, 10000));
89 err
= mmc_select_card(card
);
94 int mmc_go_idle(struct mmc_host
*host
)
97 struct mmc_command cmd
= {0};
100 * Non-SPI hosts need to prevent chipselect going active during
101 * GO_IDLE; that would put chips into SPI mode. Remind them of
102 * that in case of hardware that won't pull up DAT3/nCS otherwise.
104 * SPI hosts ignore ios.chip_select; it's managed according to
105 * rules that must accommodate non-MMC slaves which this layer
106 * won't even know about.
108 if (!mmc_host_is_spi(host
)) {
109 mmc_set_chip_select(host
, MMC_CS_HIGH
);
113 cmd
.opcode
= MMC_GO_IDLE_STATE
;
115 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_NONE
| MMC_CMD_BC
;
117 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
121 if (!mmc_host_is_spi(host
)) {
122 mmc_set_chip_select(host
, MMC_CS_DONTCARE
);
126 host
->use_spi_crc
= 0;
131 int mmc_send_op_cond(struct mmc_host
*host
, u32 ocr
, u32
*rocr
)
133 struct mmc_command cmd
= {0};
138 cmd
.opcode
= MMC_SEND_OP_COND
;
139 cmd
.arg
= mmc_host_is_spi(host
) ? 0 : ocr
;
140 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R3
| MMC_CMD_BCR
;
142 for (i
= 100; i
; i
--) {
143 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
147 /* if we're just probing, do a single pass */
151 /* otherwise wait until reset completes */
152 if (mmc_host_is_spi(host
)) {
153 if (!(cmd
.resp
[0] & R1_SPI_IDLE
))
156 if (cmd
.resp
[0] & MMC_CARD_BUSY
)
165 if (rocr
&& !mmc_host_is_spi(host
))
171 int mmc_all_send_cid(struct mmc_host
*host
, u32
*cid
)
174 struct mmc_command cmd
= {0};
179 cmd
.opcode
= MMC_ALL_SEND_CID
;
181 cmd
.flags
= MMC_RSP_R2
| MMC_CMD_BCR
;
183 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
187 memcpy(cid
, cmd
.resp
, sizeof(u32
) * 4);
192 int mmc_set_relative_addr(struct mmc_card
*card
)
195 struct mmc_command cmd
= {0};
200 cmd
.opcode
= MMC_SET_RELATIVE_ADDR
;
201 cmd
.arg
= card
->rca
<< 16;
202 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
204 err
= mmc_wait_for_cmd(card
->host
, &cmd
, MMC_CMD_RETRIES
);
212 mmc_send_cxd_native(struct mmc_host
*host
, u32 arg
, u32
*cxd
, int opcode
)
215 struct mmc_command cmd
= {0};
222 cmd
.flags
= MMC_RSP_R2
| MMC_CMD_AC
;
224 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
228 memcpy(cxd
, cmd
.resp
, sizeof(u32
) * 4);
234 mmc_send_cxd_data(struct mmc_card
*card
, struct mmc_host
*host
,
235 u32 opcode
, void *buf
, unsigned len
)
237 struct mmc_request mrq
= {NULL
};
238 struct mmc_command cmd
= {0};
239 struct mmc_data data
= {0};
240 struct scatterlist sg
;
243 /* dma onto stack is unsafe/nonportable, but callers to this
244 * routine normally provide temporary on-stack buffers ...
246 data_buf
= kmalloc(len
, GFP_KERNEL
);
247 if (data_buf
== NULL
)
256 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
257 * rely on callers to never use this with "native" calls for reading
258 * CSD or CID. Native versions of those commands use the R2 type,
259 * not R1 plus a data block.
261 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
265 data
.flags
= MMC_DATA_READ
;
269 sg_init_one(&sg
, data_buf
, len
);
271 if (opcode
== MMC_SEND_CSD
|| opcode
== MMC_SEND_CID
) {
273 * The spec states that CSR and CID accesses have a timeout
274 * of 64 clock cycles.
277 data
.timeout_clks
= 64;
279 mmc_set_data_timeout(&data
, card
);
281 mmc_wait_for_req(host
, &mrq
);
283 memcpy(buf
, data_buf
, len
);
294 int mmc_send_csd(struct mmc_card
*card
, u32
*csd
)
298 if (!mmc_host_is_spi(card
->host
))
299 return mmc_send_cxd_native(card
->host
, card
->rca
<< 16,
302 ret
= mmc_send_cxd_data(card
, card
->host
, MMC_SEND_CSD
, csd
, 16);
306 for (i
= 0;i
< 4;i
++)
307 csd
[i
] = be32_to_cpu(csd
[i
]);
312 int mmc_send_cid(struct mmc_host
*host
, u32
*cid
)
316 if (!mmc_host_is_spi(host
)) {
319 return mmc_send_cxd_native(host
, host
->card
->rca
<< 16,
323 ret
= mmc_send_cxd_data(NULL
, host
, MMC_SEND_CID
, cid
, 16);
327 for (i
= 0;i
< 4;i
++)
328 cid
[i
] = be32_to_cpu(cid
[i
]);
333 int mmc_send_ext_csd(struct mmc_card
*card
, u8
*ext_csd
)
335 return mmc_send_cxd_data(card
, card
->host
, MMC_SEND_EXT_CSD
,
339 int mmc_spi_read_ocr(struct mmc_host
*host
, int highcap
, u32
*ocrp
)
341 struct mmc_command cmd
= {0};
344 cmd
.opcode
= MMC_SPI_READ_OCR
;
345 cmd
.arg
= highcap
? (1 << 30) : 0;
346 cmd
.flags
= MMC_RSP_SPI_R3
;
348 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
354 int mmc_spi_set_crc(struct mmc_host
*host
, int use_crc
)
356 struct mmc_command cmd
= {0};
359 cmd
.opcode
= MMC_SPI_CRC_ON_OFF
;
360 cmd
.flags
= MMC_RSP_SPI_R1
;
363 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
365 host
->use_spi_crc
= use_crc
;
370 * mmc_switch - modify EXT_CSD register
371 * @card: the MMC card associated with the data transfer
372 * @set: cmd set values
373 * @index: EXT_CSD register index
374 * @value: value to program into EXT_CSD register
375 * @timeout_ms: timeout (ms) for operation performed by register write,
376 * timeout of zero implies maximum possible timeout
378 * Modifies the EXT_CSD register for selected card.
380 int mmc_switch(struct mmc_card
*card
, u8 set
, u8 index
, u8 value
,
381 unsigned int timeout_ms
)
384 struct mmc_command cmd
= {0};
390 cmd
.opcode
= MMC_SWITCH
;
391 cmd
.arg
= (MMC_SWITCH_MODE_WRITE_BYTE
<< 24) |
395 cmd
.flags
= MMC_RSP_SPI_R1B
| MMC_RSP_R1B
| MMC_CMD_AC
;
396 cmd
.cmd_timeout_ms
= timeout_ms
;
398 err
= mmc_wait_for_cmd(card
->host
, &cmd
, MMC_CMD_RETRIES
);
402 /* Must check status to be sure of no errors */
404 err
= mmc_send_status(card
, &status
);
407 if (card
->host
->caps
& MMC_CAP_WAIT_WHILE_BUSY
)
409 if (mmc_host_is_spi(card
->host
))
411 } while (R1_CURRENT_STATE(status
) == R1_STATE_PRG
);
413 if (mmc_host_is_spi(card
->host
)) {
414 if (status
& R1_SPI_ILLEGAL_COMMAND
)
417 if (status
& 0xFDFFA000)
418 printk(KERN_WARNING
"%s: unexpected status %#x after "
419 "switch", mmc_hostname(card
->host
), status
);
420 if (status
& R1_SWITCH_ERROR
)
426 EXPORT_SYMBOL_GPL(mmc_switch
);
428 int mmc_send_status(struct mmc_card
*card
, u32
*status
)
431 struct mmc_command cmd
= {0};
436 cmd
.opcode
= MMC_SEND_STATUS
;
437 if (!mmc_host_is_spi(card
->host
))
438 cmd
.arg
= card
->rca
<< 16;
439 cmd
.flags
= MMC_RSP_SPI_R2
| MMC_RSP_R1
| MMC_CMD_AC
;
441 err
= mmc_wait_for_cmd(card
->host
, &cmd
, MMC_CMD_RETRIES
);
445 /* NOTE: callers are required to understand the difference
446 * between "native" and SPI format status words!
449 *status
= cmd
.resp
[0];
455 mmc_send_bus_test(struct mmc_card
*card
, struct mmc_host
*host
, u8 opcode
,
458 struct mmc_request mrq
= {NULL
};
459 struct mmc_command cmd
= {0};
460 struct mmc_data data
= {0};
461 struct scatterlist sg
;
465 static u8 testdata_8bit
[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 };
466 static u8 testdata_4bit
[4] = { 0x5a, 0, 0, 0 };
468 /* dma onto stack is unsafe/nonportable, but callers to this
469 * routine normally provide temporary on-stack buffers ...
471 data_buf
= kmalloc(len
, GFP_KERNEL
);
476 test_buf
= testdata_8bit
;
478 test_buf
= testdata_4bit
;
480 printk(KERN_ERR
"%s: Invalid bus_width %d\n",
481 mmc_hostname(host
), len
);
486 if (opcode
== MMC_BUS_TEST_W
)
487 memcpy(data_buf
, test_buf
, len
);
494 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we
495 * rely on callers to never use this with "native" calls for reading
496 * CSD or CID. Native versions of those commands use the R2 type,
497 * not R1 plus a data block.
499 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
503 if (opcode
== MMC_BUS_TEST_R
)
504 data
.flags
= MMC_DATA_READ
;
506 data
.flags
= MMC_DATA_WRITE
;
510 sg_init_one(&sg
, data_buf
, len
);
511 mmc_wait_for_req(host
, &mrq
);
513 if (opcode
== MMC_BUS_TEST_R
) {
514 for (i
= 0; i
< len
/ 4; i
++)
515 if ((test_buf
[i
] ^ data_buf
[i
]) != 0xff) {
530 int mmc_bus_test(struct mmc_card
*card
, u8 bus_width
)
534 if (bus_width
== MMC_BUS_WIDTH_8
)
536 else if (bus_width
== MMC_BUS_WIDTH_4
)
538 else if (bus_width
== MMC_BUS_WIDTH_1
)
539 return 0; /* no need for test */
544 * Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there
545 * is a problem. This improves chances that the test will work.
547 mmc_send_bus_test(card
, card
->host
, MMC_BUS_TEST_W
, width
);
548 err
= mmc_send_bus_test(card
, card
->host
, MMC_BUS_TEST_R
, width
);