1 /* 2 * linux/drivers/mmc/core/mmc_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/slab.h> 13 #include <linux/export.h> 14 #include <linux/types.h> 15 #include <linux/scatterlist.h> 16 17 #include <linux/mmc/host.h> 18 #include <linux/mmc/card.h> 19 #include <linux/mmc/mmc.h> 20 21 #include "core.h" 22 #include "mmc_ops.h" 23 24 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card) 25 { 26 int err; 27 struct mmc_command cmd = {0}; 28 29 BUG_ON(!host); 30 31 cmd.opcode = MMC_SELECT_CARD; 32 33 if (card) { 34 cmd.arg = card->rca << 16; 35 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 36 } else { 37 cmd.arg = 0; 38 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC; 39 } 40 41 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 42 if (err) 43 return err; 44 45 return 0; 46 } 47 48 int mmc_select_card(struct mmc_card *card) 49 { 50 BUG_ON(!card); 51 52 return _mmc_select_card(card->host, card); 53 } 54 55 int mmc_deselect_cards(struct mmc_host *host) 56 { 57 return _mmc_select_card(host, NULL); 58 } 59 60 int mmc_card_sleepawake(struct mmc_host *host, int sleep) 61 { 62 struct mmc_command cmd = {0}; 63 struct mmc_card *card = host->card; 64 int err; 65 66 if (sleep) 67 mmc_deselect_cards(host); 68 69 cmd.opcode = MMC_SLEEP_AWAKE; 70 cmd.arg = card->rca << 16; 71 if (sleep) 72 cmd.arg |= 1 << 15; 73 74 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 75 err = mmc_wait_for_cmd(host, &cmd, 0); 76 if (err) 77 return err; 78 79 /* 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. 84 */ 85 if (!(host->caps & MMC_CAP_WAIT_WHILE_BUSY)) 86 mmc_delay(DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000)); 87 88 if (!sleep) 89 err = mmc_select_card(card); 90 91 return err; 92 } 93 94 int mmc_go_idle(struct mmc_host *host) 95 { 96 int err; 97 struct mmc_command cmd = {0}; 98 99 /* 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. 103 * 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. 107 */ 108 if (!mmc_host_is_spi(host)) { 109 mmc_set_chip_select(host, MMC_CS_HIGH); 110 mmc_delay(1); 111 } 112 113 cmd.opcode = MMC_GO_IDLE_STATE; 114 cmd.arg = 0; 115 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC; 116 117 err = mmc_wait_for_cmd(host, &cmd, 0); 118 119 mmc_delay(1); 120 121 if (!mmc_host_is_spi(host)) { 122 mmc_set_chip_select(host, MMC_CS_DONTCARE); 123 mmc_delay(1); 124 } 125 126 host->use_spi_crc = 0; 127 128 return err; 129 } 130 131 int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) 132 { 133 struct mmc_command cmd = {0}; 134 int i, err = 0; 135 136 BUG_ON(!host); 137 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; 141 142 for (i = 100; i; i--) { 143 err = mmc_wait_for_cmd(host, &cmd, 0); 144 if (err) 145 break; 146 147 /* if we're just probing, do a single pass */ 148 if (ocr == 0) 149 break; 150 151 /* otherwise wait until reset completes */ 152 if (mmc_host_is_spi(host)) { 153 if (!(cmd.resp[0] & R1_SPI_IDLE)) 154 break; 155 } else { 156 if (cmd.resp[0] & MMC_CARD_BUSY) 157 break; 158 } 159 160 err = -ETIMEDOUT; 161 162 mmc_delay(10); 163 } 164 165 if (rocr && !mmc_host_is_spi(host)) 166 *rocr = cmd.resp[0]; 167 168 return err; 169 } 170 171 int mmc_all_send_cid(struct mmc_host *host, u32 *cid) 172 { 173 int err; 174 struct mmc_command cmd = {0}; 175 176 BUG_ON(!host); 177 BUG_ON(!cid); 178 179 cmd.opcode = MMC_ALL_SEND_CID; 180 cmd.arg = 0; 181 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 182 183 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 184 if (err) 185 return err; 186 187 memcpy(cid, cmd.resp, sizeof(u32) * 4); 188 189 return 0; 190 } 191 192 int mmc_set_relative_addr(struct mmc_card *card) 193 { 194 int err; 195 struct mmc_command cmd = {0}; 196 197 BUG_ON(!card); 198 BUG_ON(!card->host); 199 200 cmd.opcode = MMC_SET_RELATIVE_ADDR; 201 cmd.arg = card->rca << 16; 202 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 203 204 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 205 if (err) 206 return err; 207 208 return 0; 209 } 210 211 static int 212 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode) 213 { 214 int err; 215 struct mmc_command cmd = {0}; 216 217 BUG_ON(!host); 218 BUG_ON(!cxd); 219 220 cmd.opcode = opcode; 221 cmd.arg = arg; 222 cmd.flags = MMC_RSP_R2 | MMC_CMD_AC; 223 224 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 225 if (err) 226 return err; 227 228 memcpy(cxd, cmd.resp, sizeof(u32) * 4); 229 230 return 0; 231 } 232 233 static int 234 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host, 235 u32 opcode, void *buf, unsigned len) 236 { 237 struct mmc_request mrq = {NULL}; 238 struct mmc_command cmd = {0}; 239 struct mmc_data data = {0}; 240 struct scatterlist sg; 241 void *data_buf; 242 243 /* dma onto stack is unsafe/nonportable, but callers to this 244 * routine normally provide temporary on-stack buffers ... 245 */ 246 data_buf = kmalloc(len, GFP_KERNEL); 247 if (data_buf == NULL) 248 return -ENOMEM; 249 250 mrq.cmd = &cmd; 251 mrq.data = &data; 252 253 cmd.opcode = opcode; 254 cmd.arg = 0; 255 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. 260 */ 261 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 262 263 data.blksz = len; 264 data.blocks = 1; 265 data.flags = MMC_DATA_READ; 266 data.sg = &sg; 267 data.sg_len = 1; 268 269 sg_init_one(&sg, data_buf, len); 270 271 if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) { 272 /* 273 * The spec states that CSR and CID accesses have a timeout 274 * of 64 clock cycles. 275 */ 276 data.timeout_ns = 0; 277 data.timeout_clks = 64; 278 } else 279 mmc_set_data_timeout(&data, card); 280 281 mmc_wait_for_req(host, &mrq); 282 283 memcpy(buf, data_buf, len); 284 kfree(data_buf); 285 286 if (cmd.error) 287 return cmd.error; 288 if (data.error) 289 return data.error; 290 291 return 0; 292 } 293 294 int mmc_send_csd(struct mmc_card *card, u32 *csd) 295 { 296 int ret, i; 297 298 if (!mmc_host_is_spi(card->host)) 299 return mmc_send_cxd_native(card->host, card->rca << 16, 300 csd, MMC_SEND_CSD); 301 302 ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd, 16); 303 if (ret) 304 return ret; 305 306 for (i = 0;i < 4;i++) 307 csd[i] = be32_to_cpu(csd[i]); 308 309 return 0; 310 } 311 312 int mmc_send_cid(struct mmc_host *host, u32 *cid) 313 { 314 int ret, i; 315 316 if (!mmc_host_is_spi(host)) { 317 if (!host->card) 318 return -EINVAL; 319 return mmc_send_cxd_native(host, host->card->rca << 16, 320 cid, MMC_SEND_CID); 321 } 322 323 ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid, 16); 324 if (ret) 325 return ret; 326 327 for (i = 0;i < 4;i++) 328 cid[i] = be32_to_cpu(cid[i]); 329 330 return 0; 331 } 332 333 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd) 334 { 335 return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, 336 ext_csd, 512); 337 } 338 339 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp) 340 { 341 struct mmc_command cmd = {0}; 342 int err; 343 344 cmd.opcode = MMC_SPI_READ_OCR; 345 cmd.arg = highcap ? (1 << 30) : 0; 346 cmd.flags = MMC_RSP_SPI_R3; 347 348 err = mmc_wait_for_cmd(host, &cmd, 0); 349 350 *ocrp = cmd.resp[1]; 351 return err; 352 } 353 354 int mmc_spi_set_crc(struct mmc_host *host, int use_crc) 355 { 356 struct mmc_command cmd = {0}; 357 int err; 358 359 cmd.opcode = MMC_SPI_CRC_ON_OFF; 360 cmd.flags = MMC_RSP_SPI_R1; 361 cmd.arg = use_crc; 362 363 err = mmc_wait_for_cmd(host, &cmd, 0); 364 if (!err) 365 host->use_spi_crc = use_crc; 366 return err; 367 } 368 369 /** 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 377 * 378 * Modifies the EXT_CSD register for selected card. 379 */ 380 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, 381 unsigned int timeout_ms) 382 { 383 int err; 384 struct mmc_command cmd = {0}; 385 u32 status; 386 387 BUG_ON(!card); 388 BUG_ON(!card->host); 389 390 cmd.opcode = MMC_SWITCH; 391 cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 392 (index << 16) | 393 (value << 8) | 394 set; 395 cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 396 cmd.cmd_timeout_ms = timeout_ms; 397 398 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 399 if (err) 400 return err; 401 402 /* Must check status to be sure of no errors */ 403 do { 404 err = mmc_send_status(card, &status); 405 if (err) 406 return err; 407 if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) 408 break; 409 if (mmc_host_is_spi(card->host)) 410 break; 411 } while (R1_CURRENT_STATE(status) == R1_STATE_PRG); 412 413 if (mmc_host_is_spi(card->host)) { 414 if (status & R1_SPI_ILLEGAL_COMMAND) 415 return -EBADMSG; 416 } else { 417 if (status & 0xFDFFA000) 418 pr_warning("%s: unexpected status %#x after " 419 "switch", mmc_hostname(card->host), status); 420 if (status & R1_SWITCH_ERROR) 421 return -EBADMSG; 422 } 423 424 return 0; 425 } 426 EXPORT_SYMBOL_GPL(mmc_switch); 427 428 int mmc_send_status(struct mmc_card *card, u32 *status) 429 { 430 int err; 431 struct mmc_command cmd = {0}; 432 433 BUG_ON(!card); 434 BUG_ON(!card->host); 435 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; 440 441 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 442 if (err) 443 return err; 444 445 /* NOTE: callers are required to understand the difference 446 * between "native" and SPI format status words! 447 */ 448 if (status) 449 *status = cmd.resp[0]; 450 451 return 0; 452 } 453 454 static int 455 mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode, 456 u8 len) 457 { 458 struct mmc_request mrq = {NULL}; 459 struct mmc_command cmd = {0}; 460 struct mmc_data data = {0}; 461 struct scatterlist sg; 462 u8 *data_buf; 463 u8 *test_buf; 464 int i, err; 465 static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 }; 466 static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 }; 467 468 /* dma onto stack is unsafe/nonportable, but callers to this 469 * routine normally provide temporary on-stack buffers ... 470 */ 471 data_buf = kmalloc(len, GFP_KERNEL); 472 if (!data_buf) 473 return -ENOMEM; 474 475 if (len == 8) 476 test_buf = testdata_8bit; 477 else if (len == 4) 478 test_buf = testdata_4bit; 479 else { 480 pr_err("%s: Invalid bus_width %d\n", 481 mmc_hostname(host), len); 482 kfree(data_buf); 483 return -EINVAL; 484 } 485 486 if (opcode == MMC_BUS_TEST_W) 487 memcpy(data_buf, test_buf, len); 488 489 mrq.cmd = &cmd; 490 mrq.data = &data; 491 cmd.opcode = opcode; 492 cmd.arg = 0; 493 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. 498 */ 499 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 500 501 data.blksz = len; 502 data.blocks = 1; 503 if (opcode == MMC_BUS_TEST_R) 504 data.flags = MMC_DATA_READ; 505 else 506 data.flags = MMC_DATA_WRITE; 507 508 data.sg = &sg; 509 data.sg_len = 1; 510 sg_init_one(&sg, data_buf, len); 511 mmc_wait_for_req(host, &mrq); 512 err = 0; 513 if (opcode == MMC_BUS_TEST_R) { 514 for (i = 0; i < len / 4; i++) 515 if ((test_buf[i] ^ data_buf[i]) != 0xff) { 516 err = -EIO; 517 break; 518 } 519 } 520 kfree(data_buf); 521 522 if (cmd.error) 523 return cmd.error; 524 if (data.error) 525 return data.error; 526 527 return err; 528 } 529 530 int mmc_bus_test(struct mmc_card *card, u8 bus_width) 531 { 532 int err, width; 533 534 if (bus_width == MMC_BUS_WIDTH_8) 535 width = 8; 536 else if (bus_width == MMC_BUS_WIDTH_4) 537 width = 4; 538 else if (bus_width == MMC_BUS_WIDTH_1) 539 return 0; /* no need for test */ 540 else 541 return -EINVAL; 542 543 /* 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. 546 */ 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); 549 return err; 550 } 551 552 int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status) 553 { 554 struct mmc_command cmd = {0}; 555 unsigned int opcode; 556 unsigned int flags; 557 int err; 558 559 opcode = card->ext_csd.hpi_cmd; 560 if (opcode == MMC_STOP_TRANSMISSION) 561 flags = MMC_RSP_R1 | MMC_CMD_AC; 562 else if (opcode == MMC_SEND_STATUS) 563 flags = MMC_RSP_R1 | MMC_CMD_AC; 564 565 cmd.opcode = opcode; 566 cmd.arg = card->rca << 16 | 1; 567 cmd.flags = flags; 568 cmd.cmd_timeout_ms = card->ext_csd.out_of_int_time; 569 570 err = mmc_wait_for_cmd(card->host, &cmd, 0); 571 if (err) { 572 pr_warn("%s: error %d interrupting operation. " 573 "HPI command response %#x\n", mmc_hostname(card->host), 574 err, cmd.resp[0]); 575 return err; 576 } 577 if (status) 578 *status = cmd.resp[0]; 579 580 return 0; 581 } 582