1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * linux/drivers/mmc/core/sd_ops.h 4 * 5 * Copyright 2006-2007 Pierre Ossman 6 */ 7 8 #include <linux/slab.h> 9 #include <linux/types.h> 10 #include <linux/export.h> 11 #include <linux/scatterlist.h> 12 13 #include <linux/mmc/host.h> 14 #include <linux/mmc/card.h> 15 #include <linux/mmc/mmc.h> 16 #include <linux/mmc/sd.h> 17 18 #include "core.h" 19 #include "sd_ops.h" 20 #include "mmc_ops.h" 21 22 /* 23 * Extensive testing has shown that some specific SD cards 24 * require an increased command timeout to be successfully 25 * initialized. 26 */ 27 #define SD_APP_OP_COND_PERIOD_US (10 * 1000) /* 10ms */ 28 #define SD_APP_OP_COND_TIMEOUT_MS 2000 /* 2s */ 29 30 struct sd_app_op_cond_busy_data { 31 struct mmc_host *host; 32 u32 ocr; 33 struct mmc_command *cmd; 34 }; 35 36 int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card) 37 { 38 int err; 39 struct mmc_command cmd = {}; 40 41 if (WARN_ON(card && card->host != host)) 42 return -EINVAL; 43 44 cmd.opcode = MMC_APP_CMD; 45 46 if (card) { 47 cmd.arg = card->rca << 16; 48 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 49 } else { 50 cmd.arg = 0; 51 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR; 52 } 53 54 err = mmc_wait_for_cmd(host, &cmd, 0); 55 if (err) 56 return err; 57 58 /* Check that card supported application commands */ 59 if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD)) 60 return -EOPNOTSUPP; 61 62 return 0; 63 } 64 EXPORT_SYMBOL_GPL(mmc_app_cmd); 65 66 static int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card, 67 struct mmc_command *cmd) 68 { 69 struct mmc_request mrq = {}; 70 int i, err = -EIO; 71 72 /* 73 * We have to resend MMC_APP_CMD for each attempt so 74 * we cannot use the retries field in mmc_command. 75 */ 76 for (i = 0; i <= MMC_CMD_RETRIES; i++) { 77 err = mmc_app_cmd(host, card); 78 if (err) { 79 /* no point in retrying; no APP commands allowed */ 80 if (mmc_host_is_spi(host)) { 81 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 82 break; 83 } 84 continue; 85 } 86 87 memset(&mrq, 0, sizeof(struct mmc_request)); 88 89 memset(cmd->resp, 0, sizeof(cmd->resp)); 90 cmd->retries = 0; 91 92 mrq.cmd = cmd; 93 cmd->data = NULL; 94 95 mmc_wait_for_req(host, &mrq); 96 97 err = cmd->error; 98 if (!cmd->error) 99 break; 100 101 /* no point in retrying illegal APP commands */ 102 if (mmc_host_is_spi(host)) { 103 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 104 break; 105 } 106 } 107 108 return err; 109 } 110 111 int mmc_app_set_bus_width(struct mmc_card *card, int width) 112 { 113 struct mmc_command cmd = {}; 114 115 cmd.opcode = SD_APP_SET_BUS_WIDTH; 116 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 117 118 switch (width) { 119 case MMC_BUS_WIDTH_1: 120 cmd.arg = SD_BUS_WIDTH_1; 121 break; 122 case MMC_BUS_WIDTH_4: 123 cmd.arg = SD_BUS_WIDTH_4; 124 break; 125 default: 126 return -EINVAL; 127 } 128 129 return mmc_wait_for_app_cmd(card->host, card, &cmd); 130 } 131 132 static int sd_app_op_cond_cb(void *cb_data, bool *busy) 133 { 134 struct sd_app_op_cond_busy_data *data = cb_data; 135 struct mmc_host *host = data->host; 136 struct mmc_command *cmd = data->cmd; 137 u32 ocr = data->ocr; 138 int err; 139 140 *busy = false; 141 142 err = mmc_wait_for_app_cmd(host, NULL, cmd); 143 if (err) 144 return err; 145 146 /* If we're just probing, do a single pass. */ 147 if (ocr == 0) 148 return 0; 149 150 /* Wait until reset completes. */ 151 if (mmc_host_is_spi(host)) { 152 if (!(cmd->resp[0] & R1_SPI_IDLE)) 153 return 0; 154 } else if (cmd->resp[0] & MMC_CARD_BUSY) { 155 return 0; 156 } 157 158 *busy = true; 159 return 0; 160 } 161 162 int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) 163 { 164 struct mmc_command cmd = {}; 165 struct sd_app_op_cond_busy_data cb_data = { 166 .host = host, 167 .ocr = ocr, 168 .cmd = &cmd 169 }; 170 int err; 171 172 cmd.opcode = SD_APP_OP_COND; 173 if (mmc_host_is_spi(host)) 174 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */ 175 else 176 cmd.arg = ocr; 177 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR; 178 179 err = __mmc_poll_for_busy(host, SD_APP_OP_COND_PERIOD_US, 180 SD_APP_OP_COND_TIMEOUT_MS, &sd_app_op_cond_cb, 181 &cb_data); 182 if (err) 183 return err; 184 185 if (rocr && !mmc_host_is_spi(host)) 186 *rocr = cmd.resp[0]; 187 188 return 0; 189 } 190 191 static int __mmc_send_if_cond(struct mmc_host *host, u32 ocr, u8 pcie_bits, 192 u32 *resp) 193 { 194 struct mmc_command cmd = {}; 195 int err; 196 static const u8 test_pattern = 0xAA; 197 u8 result_pattern; 198 199 /* 200 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND 201 * before SD_APP_OP_COND. This command will harmlessly fail for 202 * SD 1.0 cards. 203 */ 204 cmd.opcode = SD_SEND_IF_COND; 205 cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | pcie_bits << 8 | test_pattern; 206 cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR; 207 208 err = mmc_wait_for_cmd(host, &cmd, 0); 209 if (err) 210 return err; 211 212 if (mmc_host_is_spi(host)) 213 result_pattern = cmd.resp[1] & 0xFF; 214 else 215 result_pattern = cmd.resp[0] & 0xFF; 216 217 if (result_pattern != test_pattern) 218 return -EIO; 219 220 if (resp) 221 *resp = cmd.resp[0]; 222 223 return 0; 224 } 225 226 int mmc_send_if_cond(struct mmc_host *host, u32 ocr) 227 { 228 return __mmc_send_if_cond(host, ocr, 0, NULL); 229 } 230 231 int mmc_send_if_cond_pcie(struct mmc_host *host, u32 ocr) 232 { 233 u32 resp = 0; 234 u8 pcie_bits = 0; 235 int ret; 236 237 if (host->caps2 & MMC_CAP2_SD_EXP) { 238 /* Probe card for SD express support via PCIe. */ 239 pcie_bits = 0x10; 240 if (host->caps2 & MMC_CAP2_SD_EXP_1_2V) 241 /* Probe also for 1.2V support. */ 242 pcie_bits = 0x30; 243 } 244 245 ret = __mmc_send_if_cond(host, ocr, pcie_bits, &resp); 246 if (ret) 247 return 0; 248 249 /* Continue with the SD express init, if the card supports it. */ 250 resp &= 0x3000; 251 if (pcie_bits && resp) { 252 if (resp == 0x3000) 253 host->ios.timing = MMC_TIMING_SD_EXP_1_2V; 254 else 255 host->ios.timing = MMC_TIMING_SD_EXP; 256 257 /* 258 * According to the spec the clock shall also be gated, but 259 * let's leave this to the host driver for more flexibility. 260 */ 261 return host->ops->init_sd_express(host, &host->ios); 262 } 263 264 return 0; 265 } 266 267 int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca) 268 { 269 int err; 270 struct mmc_command cmd = {}; 271 272 cmd.opcode = SD_SEND_RELATIVE_ADDR; 273 cmd.arg = 0; 274 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR; 275 276 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 277 if (err) 278 return err; 279 280 *rca = cmd.resp[0] >> 16; 281 282 return 0; 283 } 284 285 int mmc_app_send_scr(struct mmc_card *card) 286 { 287 int err; 288 struct mmc_request mrq = {}; 289 struct mmc_command cmd = {}; 290 struct mmc_data data = {}; 291 struct scatterlist sg; 292 __be32 *scr; 293 294 /* NOTE: caller guarantees scr is heap-allocated */ 295 296 err = mmc_app_cmd(card->host, card); 297 if (err) 298 return err; 299 300 /* dma onto stack is unsafe/nonportable, but callers to this 301 * routine normally provide temporary on-stack buffers ... 302 */ 303 scr = kmalloc(sizeof(card->raw_scr), GFP_KERNEL); 304 if (!scr) 305 return -ENOMEM; 306 307 mrq.cmd = &cmd; 308 mrq.data = &data; 309 310 cmd.opcode = SD_APP_SEND_SCR; 311 cmd.arg = 0; 312 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 313 314 data.blksz = 8; 315 data.blocks = 1; 316 data.flags = MMC_DATA_READ; 317 data.sg = &sg; 318 data.sg_len = 1; 319 320 sg_init_one(&sg, scr, 8); 321 322 mmc_set_data_timeout(&data, card); 323 324 mmc_wait_for_req(card->host, &mrq); 325 326 card->raw_scr[0] = be32_to_cpu(scr[0]); 327 card->raw_scr[1] = be32_to_cpu(scr[1]); 328 329 kfree(scr); 330 331 if (cmd.error) 332 return cmd.error; 333 if (data.error) 334 return data.error; 335 336 return 0; 337 } 338 339 int mmc_sd_switch(struct mmc_card *card, bool mode, int group, 340 u8 value, u8 *resp) 341 { 342 u32 cmd_args; 343 344 /* NOTE: caller guarantees resp is heap-allocated */ 345 346 value &= 0xF; 347 cmd_args = mode << 31 | 0x00FFFFFF; 348 cmd_args &= ~(0xF << (group * 4)); 349 cmd_args |= value << (group * 4); 350 351 return mmc_send_adtc_data(card, card->host, SD_SWITCH, cmd_args, resp, 352 64); 353 } 354 EXPORT_SYMBOL_GPL(mmc_sd_switch); 355 356 int mmc_app_sd_status(struct mmc_card *card, void *ssr) 357 { 358 int err; 359 struct mmc_request mrq = {}; 360 struct mmc_command cmd = {}; 361 struct mmc_data data = {}; 362 struct scatterlist sg; 363 364 /* NOTE: caller guarantees ssr is heap-allocated */ 365 366 err = mmc_app_cmd(card->host, card); 367 if (err) 368 return err; 369 370 mrq.cmd = &cmd; 371 mrq.data = &data; 372 373 cmd.opcode = SD_APP_SD_STATUS; 374 cmd.arg = 0; 375 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC; 376 377 data.blksz = 64; 378 data.blocks = 1; 379 data.flags = MMC_DATA_READ; 380 data.sg = &sg; 381 data.sg_len = 1; 382 383 sg_init_one(&sg, ssr, 64); 384 385 mmc_set_data_timeout(&data, card); 386 387 mmc_wait_for_req(card->host, &mrq); 388 389 if (cmd.error) 390 return cmd.error; 391 if (data.error) 392 return data.error; 393 394 return 0; 395 } 396