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