1/* 2 * linux/drivers/mmc/core/sd_ops.h 3 * 4 * Copyright 2006-2007 Pierre Ossman 5 * 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. 10 */ 11 12#include <linux/types.h> 13#include <linux/scatterlist.h> 14 15#include <linux/mmc/host.h> 16#include <linux/mmc/card.h> 17#include <linux/mmc/mmc.h> 18#include <linux/mmc/sd.h> 19 20#include "core.h" 21#include "sd_ops.h" 22 23static int mmc_app_cmd(struct mmc_host *host, struct mmc_card *card) 24{ 25 int err; 26 struct mmc_command cmd; 27 28 BUG_ON(!host); 29 BUG_ON(card && (card->host != host)); 30 31 cmd.opcode = MMC_APP_CMD; 32 33 if (card) { 34 cmd.arg = card->rca << 16; 35 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 36 } else { 37 cmd.arg = 0; 38 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_BCR; 39 } 40 41 err = mmc_wait_for_cmd(host, &cmd, 0); 42 if (err) 43 return err; 44 45 /* Check that card supported application commands */ 46 if (!mmc_host_is_spi(host) && !(cmd.resp[0] & R1_APP_CMD)) 47 return -EOPNOTSUPP; 48 49 return 0; 50} 51 52/** 53 * mmc_wait_for_app_cmd - start an application command and wait for 54 completion 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 59 * 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 63 * parse the response. 64 */ 65int mmc_wait_for_app_cmd(struct mmc_host *host, struct mmc_card *card, 66 struct mmc_command *cmd, int retries) 67{ 68 struct mmc_request mrq; 69 70 int i, err; 71 72 BUG_ON(!cmd); 73 BUG_ON(retries < 0); 74 75 err = -EIO; 76 77 /* 78 * We have to resend MMC_APP_CMD for each attempt so 79 * we cannot use the retries field in mmc_command. 80 */ 81 for (i = 0;i <= retries;i++) { 82 err = mmc_app_cmd(host, card); 83 if (err) { 84 /* no point in retrying; no APP commands allowed */ 85 if (mmc_host_is_spi(host)) { 86 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 87 break; 88 } 89 continue; 90 } 91 92 memset(&mrq, 0, sizeof(struct mmc_request)); 93 94 memset(cmd->resp, 0, sizeof(cmd->resp)); 95 cmd->retries = 0; 96 97 mrq.cmd = cmd; 98 cmd->data = NULL; 99 100 mmc_wait_for_req(host, &mrq); 101 102 err = cmd->error; 103 if (!cmd->error) 104 break; 105 106 /* no point in retrying illegal APP commands */ 107 if (mmc_host_is_spi(host)) { 108 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 109 break; 110 } 111 } 112 113 return err; 114} 115 116EXPORT_SYMBOL(mmc_wait_for_app_cmd); 117 118int mmc_app_set_bus_width(struct mmc_card *card, int width) 119{ 120 int err; 121 struct mmc_command cmd; 122 123 BUG_ON(!card); 124 BUG_ON(!card->host); 125 126 memset(&cmd, 0, sizeof(struct mmc_command)); 127 128 cmd.opcode = SD_APP_SET_BUS_WIDTH; 129 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 130 131 switch (width) { 132 case MMC_BUS_WIDTH_1: 133 cmd.arg = SD_BUS_WIDTH_1; 134 break; 135 case MMC_BUS_WIDTH_4: 136 cmd.arg = SD_BUS_WIDTH_4; 137 break; 138 default: 139 return -EINVAL; 140 } 141 142 err = mmc_wait_for_app_cmd(card->host, card, &cmd, MMC_CMD_RETRIES); 143 if (err) 144 return err; 145 146 return 0; 147} 148 149int mmc_send_app_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) 150{ 151 struct mmc_command cmd; 152 int i, err = 0; 153 154 BUG_ON(!host); 155 156 memset(&cmd, 0, sizeof(struct mmc_command)); 157 158 cmd.opcode = SD_APP_OP_COND; 159 if (mmc_host_is_spi(host)) 160 cmd.arg = ocr & (1 << 30); /* SPI only defines one bit */ 161 else 162 cmd.arg = ocr; 163 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR; 164 165 for (i = 100; i; i--) { 166 err = mmc_wait_for_app_cmd(host, NULL, &cmd, MMC_CMD_RETRIES); 167 if (err) 168 break; 169 170 /* if we're just probing, do a single pass */ 171 if (ocr == 0) 172 break; 173 174 /* otherwise wait until reset completes */ 175 if (mmc_host_is_spi(host)) { 176 if (!(cmd.resp[0] & R1_SPI_IDLE)) 177 break; 178 } else { 179 if (cmd.resp[0] & MMC_CARD_BUSY) 180 break; 181 } 182 183 err = -ETIMEDOUT; 184 185 mmc_delay(10); 186 } 187 188 if (rocr && !mmc_host_is_spi(host)) 189 *rocr = cmd.resp[0]; 190 191 return err; 192} 193 194int mmc_send_if_cond(struct mmc_host *host, u32 ocr) 195{ 196 struct mmc_command cmd = {0}; 197 int err; 198 static const u8 test_pattern = 0xAA; 199 u8 result_pattern; 200 201 /* 202 * To support SD 2.0 cards, we must always invoke SD_SEND_IF_COND 203 * before SD_APP_OP_COND. This command will harmlessly fail for 204 * SD 1.0 cards. 205 */ 206 cmd.opcode = SD_SEND_IF_COND; 207 cmd.arg = ((ocr & 0xFF8000) != 0) << 8 | test_pattern; 208 cmd.flags = MMC_RSP_SPI_R7 | MMC_RSP_R7 | MMC_CMD_BCR; 209 210 err = mmc_wait_for_cmd(host, &cmd, 0); 211 if (err) 212 return err; 213 214 if (mmc_host_is_spi(host)) 215 result_pattern = cmd.resp[1] & 0xFF; 216 else 217 result_pattern = cmd.resp[0] & 0xFF; 218 219 if (result_pattern != test_pattern) 220 return -EIO; 221 222 return 0; 223} 224 225int mmc_send_relative_addr(struct mmc_host *host, unsigned int *rca) 226{ 227 int err; 228 struct mmc_command cmd; 229 230 BUG_ON(!host); 231 BUG_ON(!rca); 232 233 memset(&cmd, 0, sizeof(struct mmc_command)); 234 235 cmd.opcode = SD_SEND_RELATIVE_ADDR; 236 cmd.arg = 0; 237 cmd.flags = MMC_RSP_R6 | MMC_CMD_BCR; 238 239 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 240 if (err) 241 return err; 242 243 *rca = cmd.resp[0] >> 16; 244 245 return 0; 246} 247 248int mmc_app_send_scr(struct mmc_card *card, u32 *scr) 249{ 250 int err; 251 struct mmc_request mrq; 252 struct mmc_command cmd; 253 struct mmc_data data; 254 struct scatterlist sg; 255#ifdef CONFIG_BCM47XX 256 int retries = MMC_DATA_RETRIES; 257#endif /* CONFIG_BCM47XX */ 258 259 BUG_ON(!card); 260 BUG_ON(!card->host); 261 BUG_ON(!scr); 262 263#ifdef CONFIG_BCM47XX 264retry: 265#endif /* CONFIG_BCM47XX */ 266 267 /* NOTE: caller guarantees scr is heap-allocated */ 268 269 err = mmc_app_cmd(card->host, card); 270 if (err) 271 return err; 272 273 memset(&mrq, 0, sizeof(struct mmc_request)); 274 memset(&cmd, 0, sizeof(struct mmc_command)); 275 memset(&data, 0, sizeof(struct mmc_data)); 276 277 mrq.cmd = &cmd; 278 mrq.data = &data; 279 280 cmd.opcode = SD_APP_SEND_SCR; 281 cmd.arg = 0; 282 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 283 284 data.blksz = 8; 285 data.blocks = 1; 286 data.flags = MMC_DATA_READ; 287 data.sg = &sg; 288 data.sg_len = 1; 289 290 sg_init_one(&sg, scr, 8); 291 292 mmc_set_data_timeout(&data, card); 293 294 mmc_wait_for_req(card->host, &mrq); 295 296#ifdef CONFIG_BCM47XX 297 if (data.error && retries--) { 298 mmc_delay(1); 299 goto retry; 300 } 301#endif /* CONFIG_BCM47XX */ 302 303 if (cmd.error) 304 return cmd.error; 305 if (data.error) 306 return data.error; 307 308 scr[0] = be32_to_cpu(scr[0]); 309 scr[1] = be32_to_cpu(scr[1]); 310 311 return 0; 312} 313 314int mmc_sd_switch(struct mmc_card *card, int mode, int group, 315 u8 value, u8 *resp) 316{ 317 struct mmc_request mrq; 318 struct mmc_command cmd; 319 struct mmc_data data; 320 struct scatterlist sg; 321#ifdef CONFIG_BCM47XX 322 int retries = MMC_DATA_RETRIES; 323#endif /* CONFIG_BCM47XX */ 324 325 BUG_ON(!card); 326 BUG_ON(!card->host); 327 328#ifdef CONFIG_BCM47XX 329retry: 330#endif /* CONFIG_BCM47XX */ 331 332 /* NOTE: caller guarantees resp is heap-allocated */ 333 334 mode = !!mode; 335 value &= 0xF; 336 337 memset(&mrq, 0, sizeof(struct mmc_request)); 338 memset(&cmd, 0, sizeof(struct mmc_command)); 339 memset(&data, 0, sizeof(struct mmc_data)); 340 341 mrq.cmd = &cmd; 342 mrq.data = &data; 343 344 cmd.opcode = SD_SWITCH; 345 cmd.arg = mode << 31 | 0x00FFFFFF; 346 cmd.arg &= ~(0xF << (group * 4)); 347 cmd.arg |= value << (group * 4); 348 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 349 350 data.blksz = 64; 351 data.blocks = 1; 352 data.flags = MMC_DATA_READ; 353 data.sg = &sg; 354 data.sg_len = 1; 355 356 sg_init_one(&sg, resp, 64); 357 358 mmc_set_data_timeout(&data, card); 359 360 mmc_wait_for_req(card->host, &mrq); 361 362#ifdef CONFIG_BCM47XX 363 if (data.error && retries--) { 364 mmc_delay(1); 365 goto retry; 366 } 367#endif /* CONFIG_BCM47XX */ 368 369 if (cmd.error) 370 return cmd.error; 371 if (data.error) 372 return data.error; 373 374 return 0; 375} 376 377int mmc_app_sd_status(struct mmc_card *card, void *ssr) 378{ 379 int err; 380 struct mmc_request mrq; 381 struct mmc_command cmd; 382 struct mmc_data data; 383 struct scatterlist sg; 384#ifdef CONFIG_BCM47XX 385 int retries = MMC_DATA_RETRIES; 386#endif /* CONFIG_BCM47XX */ 387 388 BUG_ON(!card); 389 BUG_ON(!card->host); 390 BUG_ON(!ssr); 391 392#ifdef CONFIG_BCM47XX 393retry: 394#endif /* CONFIG_BCM47XX */ 395 396 /* NOTE: caller guarantees ssr is heap-allocated */ 397 398 err = mmc_app_cmd(card->host, card); 399 if (err) 400 return err; 401 402 memset(&mrq, 0, sizeof(struct mmc_request)); 403 memset(&cmd, 0, sizeof(struct mmc_command)); 404 memset(&data, 0, sizeof(struct mmc_data)); 405 406 mrq.cmd = &cmd; 407 mrq.data = &data; 408 409 cmd.opcode = SD_APP_SD_STATUS; 410 cmd.arg = 0; 411 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_ADTC; 412 413 data.blksz = 64; 414 data.blocks = 1; 415 data.flags = MMC_DATA_READ; 416 data.sg = &sg; 417 data.sg_len = 1; 418 419 sg_init_one(&sg, ssr, 64); 420 421 mmc_set_data_timeout(&data, card); 422 423 mmc_wait_for_req(card->host, &mrq); 424 425#ifdef CONFIG_BCM47XX 426 if (data.error && retries--) { 427 mmc_delay(1); 428 goto retry; 429 } 430#endif /* CONFIG_BCM47XX */ 431 432 if (cmd.error) 433 return cmd.error; 434 if (data.error) 435 return data.error; 436 437 return 0; 438} 439