]>
git.proxmox.com Git - mirror_ubuntu-focal-kernel.git/blob - drivers/mmc/core/sd_ops.c
2 * linux/drivers/mmc/core/sd_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/types.h>
13 #include <linux/scatterlist.h>
15 #include <linux/mmc/host.h>
16 #include <linux/mmc/card.h>
17 #include <linux/mmc/mmc.h>
18 #include <linux/mmc/sd.h>
23 static int mmc_app_cmd(struct mmc_host
*host
, struct mmc_card
*card
)
26 struct mmc_command cmd
;
29 BUG_ON(card
&& (card
->host
!= host
));
31 cmd
.opcode
= MMC_APP_CMD
;
34 cmd
.arg
= card
->rca
<< 16;
35 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_AC
;
38 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_BCR
;
41 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
45 /* Check that card supported application commands */
46 if (!mmc_host_is_spi(host
) && !(cmd
.resp
[0] & R1_APP_CMD
))
53 * mmc_wait_for_app_cmd - start an application command and wait for
55 * @host: MMC host to start command
56 * @card: Card to send MMC_APP_CMD to
57 * @cmd: MMC command to start
58 * @retries: maximum number of retries
60 * Sends a MMC_APP_CMD, checks the card response, sends the command
61 * in the parameter and waits for it to complete. Return any error
62 * that occurred while the command was executing. Do not attempt to
65 int mmc_wait_for_app_cmd(struct mmc_host
*host
, struct mmc_card
*card
,
66 struct mmc_command
*cmd
, int retries
)
68 struct mmc_request mrq
;
78 * We have to resend MMC_APP_CMD for each attempt so
79 * we cannot use the retries field in mmc_command.
81 for (i
= 0;i
<= retries
;i
++) {
82 memset(&mrq
, 0, sizeof(struct mmc_request
));
84 err
= mmc_app_cmd(host
, card
);
86 /* no point in retrying; no APP commands allowed */
87 if (mmc_host_is_spi(host
)) {
88 if (cmd
->resp
[0] & R1_SPI_ILLEGAL_COMMAND
)
94 memset(&mrq
, 0, sizeof(struct mmc_request
));
96 memset(cmd
->resp
, 0, sizeof(cmd
->resp
));
102 mmc_wait_for_req(host
, &mrq
);
108 /* no point in retrying illegal APP commands */
109 if (mmc_host_is_spi(host
)) {
110 if (cmd
->resp
[0] & R1_SPI_ILLEGAL_COMMAND
)
118 EXPORT_SYMBOL(mmc_wait_for_app_cmd
);
120 int mmc_app_set_bus_width(struct mmc_card
*card
, int width
)
123 struct mmc_command cmd
;
128 memset(&cmd
, 0, sizeof(struct mmc_command
));
130 cmd
.opcode
= SD_APP_SET_BUS_WIDTH
;
131 cmd
.flags
= MMC_RSP_R1
| MMC_CMD_AC
;
134 case MMC_BUS_WIDTH_1
:
135 cmd
.arg
= SD_BUS_WIDTH_1
;
137 case MMC_BUS_WIDTH_4
:
138 cmd
.arg
= SD_BUS_WIDTH_4
;
144 err
= mmc_wait_for_app_cmd(card
->host
, card
, &cmd
, MMC_CMD_RETRIES
);
151 int mmc_send_app_op_cond(struct mmc_host
*host
, u32 ocr
, u32
*rocr
)
153 struct mmc_command cmd
;
158 memset(&cmd
, 0, sizeof(struct mmc_command
));
160 cmd
.opcode
= SD_APP_OP_COND
;
161 if (mmc_host_is_spi(host
))
162 cmd
.arg
= ocr
& (1 << 30); /* SPI only defines one bit */
165 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R3
| MMC_CMD_BCR
;
167 for (i
= 100; i
; i
--) {
168 err
= mmc_wait_for_app_cmd(host
, NULL
, &cmd
, MMC_CMD_RETRIES
);
172 /* if we're just probing, do a single pass */
176 /* otherwise wait until reset completes */
177 if (mmc_host_is_spi(host
)) {
178 if (!(cmd
.resp
[0] & R1_SPI_IDLE
))
181 if (cmd
.resp
[0] & MMC_CARD_BUSY
)
190 if (rocr
&& !mmc_host_is_spi(host
))
196 int mmc_send_if_cond(struct mmc_host
*host
, u32 ocr
)
198 struct mmc_command cmd
;
200 static const u8 test_pattern
= 0xAA;
204 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND
205 * before SD_APP_OP_COND. This command will harmlessly fail for
208 cmd
.opcode
= SD_SEND_IF_COND
;
209 cmd
.arg
= ((ocr
& 0xFF8000) != 0) << 8 | test_pattern
;
210 cmd
.flags
= MMC_RSP_SPI_R7
| MMC_RSP_R7
| MMC_CMD_BCR
;
212 err
= mmc_wait_for_cmd(host
, &cmd
, 0);
216 if (mmc_host_is_spi(host
))
217 result_pattern
= cmd
.resp
[1] & 0xFF;
219 result_pattern
= cmd
.resp
[0] & 0xFF;
221 if (result_pattern
!= test_pattern
)
227 int mmc_send_relative_addr(struct mmc_host
*host
, unsigned int *rca
)
230 struct mmc_command cmd
;
235 memset(&cmd
, 0, sizeof(struct mmc_command
));
237 cmd
.opcode
= SD_SEND_RELATIVE_ADDR
;
239 cmd
.flags
= MMC_RSP_R6
| MMC_CMD_BCR
;
241 err
= mmc_wait_for_cmd(host
, &cmd
, MMC_CMD_RETRIES
);
245 *rca
= cmd
.resp
[0] >> 16;
250 int mmc_app_send_scr(struct mmc_card
*card
, u32
*scr
)
253 struct mmc_request mrq
;
254 struct mmc_command cmd
;
255 struct mmc_data data
;
256 struct scatterlist sg
;
262 /* NOTE: caller guarantees scr is heap-allocated */
264 err
= mmc_app_cmd(card
->host
, card
);
268 memset(&mrq
, 0, sizeof(struct mmc_request
));
269 memset(&cmd
, 0, sizeof(struct mmc_command
));
270 memset(&data
, 0, sizeof(struct mmc_data
));
275 cmd
.opcode
= SD_APP_SEND_SCR
;
277 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
281 data
.flags
= MMC_DATA_READ
;
285 sg_init_one(&sg
, scr
, 8);
287 mmc_set_data_timeout(&data
, card
);
289 mmc_wait_for_req(card
->host
, &mrq
);
296 scr
[0] = be32_to_cpu(scr
[0]);
297 scr
[1] = be32_to_cpu(scr
[1]);
302 int mmc_sd_switch(struct mmc_card
*card
, int mode
, int group
,
305 struct mmc_request mrq
;
306 struct mmc_command cmd
;
307 struct mmc_data data
;
308 struct scatterlist sg
;
313 /* NOTE: caller guarantees resp is heap-allocated */
318 memset(&mrq
, 0, sizeof(struct mmc_request
));
319 memset(&cmd
, 0, sizeof(struct mmc_command
));
320 memset(&data
, 0, sizeof(struct mmc_data
));
325 cmd
.opcode
= SD_SWITCH
;
326 cmd
.arg
= mode
<< 31 | 0x00FFFFFF;
327 cmd
.arg
&= ~(0xF << (group
* 4));
328 cmd
.arg
|= value
<< (group
* 4);
329 cmd
.flags
= MMC_RSP_SPI_R1
| MMC_RSP_R1
| MMC_CMD_ADTC
;
333 data
.flags
= MMC_DATA_READ
;
337 sg_init_one(&sg
, resp
, 64);
339 mmc_set_data_timeout(&data
, card
);
341 mmc_wait_for_req(card
->host
, &mrq
);