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 #define MMC_OPS_TIMEOUT_MS (10 * 60 * 1000) /* 10 minute timeout */ 25 26 static int _mmc_select_card(struct mmc_host *host, struct mmc_card *card) 27 { 28 int err; 29 struct mmc_command cmd = {0}; 30 31 BUG_ON(!host); 32 33 cmd.opcode = MMC_SELECT_CARD; 34 35 if (card) { 36 cmd.arg = card->rca << 16; 37 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 38 } else { 39 cmd.arg = 0; 40 cmd.flags = MMC_RSP_NONE | MMC_CMD_AC; 41 } 42 43 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 44 if (err) 45 return err; 46 47 return 0; 48 } 49 50 int mmc_select_card(struct mmc_card *card) 51 { 52 BUG_ON(!card); 53 54 return _mmc_select_card(card->host, card); 55 } 56 57 int mmc_deselect_cards(struct mmc_host *host) 58 { 59 return _mmc_select_card(host, NULL); 60 } 61 62 int mmc_card_sleepawake(struct mmc_host *host, int sleep) 63 { 64 struct mmc_command cmd = {0}; 65 struct mmc_card *card = host->card; 66 int err; 67 68 if (sleep) 69 mmc_deselect_cards(host); 70 71 cmd.opcode = MMC_SLEEP_AWAKE; 72 cmd.arg = card->rca << 16; 73 if (sleep) 74 cmd.arg |= 1 << 15; 75 76 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 77 err = mmc_wait_for_cmd(host, &cmd, 0); 78 if (err) 79 return err; 80 81 /* 82 * If the host does not wait while the card signals busy, then we will 83 * will have to wait the sleep/awake timeout. Note, we cannot use the 84 * SEND_STATUS command to poll the status because that command (and most 85 * others) is invalid while the card sleeps. 86 */ 87 if (!(host->caps & MMC_CAP_WAIT_WHILE_BUSY)) 88 mmc_delay(DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000)); 89 90 if (!sleep) 91 err = mmc_select_card(card); 92 93 return err; 94 } 95 96 int mmc_go_idle(struct mmc_host *host) 97 { 98 int err; 99 struct mmc_command cmd = {0}; 100 101 /* 102 * Non-SPI hosts need to prevent chipselect going active during 103 * GO_IDLE; that would put chips into SPI mode. Remind them of 104 * that in case of hardware that won't pull up DAT3/nCS otherwise. 105 * 106 * SPI hosts ignore ios.chip_select; it's managed according to 107 * rules that must accommodate non-MMC slaves which this layer 108 * won't even know about. 109 */ 110 if (!mmc_host_is_spi(host)) { 111 mmc_set_chip_select(host, MMC_CS_HIGH); 112 mmc_delay(1); 113 } 114 115 cmd.opcode = MMC_GO_IDLE_STATE; 116 cmd.arg = 0; 117 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_NONE | MMC_CMD_BC; 118 119 err = mmc_wait_for_cmd(host, &cmd, 0); 120 121 mmc_delay(1); 122 123 if (!mmc_host_is_spi(host)) { 124 mmc_set_chip_select(host, MMC_CS_DONTCARE); 125 mmc_delay(1); 126 } 127 128 host->use_spi_crc = 0; 129 130 return err; 131 } 132 133 int mmc_send_op_cond(struct mmc_host *host, u32 ocr, u32 *rocr) 134 { 135 struct mmc_command cmd = {0}; 136 int i, err = 0; 137 138 BUG_ON(!host); 139 140 cmd.opcode = MMC_SEND_OP_COND; 141 cmd.arg = mmc_host_is_spi(host) ? 0 : ocr; 142 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R3 | MMC_CMD_BCR; 143 144 for (i = 100; i; i--) { 145 err = mmc_wait_for_cmd(host, &cmd, 0); 146 if (err) 147 break; 148 149 /* if we're just probing, do a single pass */ 150 if (ocr == 0) 151 break; 152 153 /* otherwise wait until reset completes */ 154 if (mmc_host_is_spi(host)) { 155 if (!(cmd.resp[0] & R1_SPI_IDLE)) 156 break; 157 } else { 158 if (cmd.resp[0] & MMC_CARD_BUSY) 159 break; 160 } 161 162 err = -ETIMEDOUT; 163 164 mmc_delay(10); 165 } 166 167 if (rocr && !mmc_host_is_spi(host)) 168 *rocr = cmd.resp[0]; 169 170 return err; 171 } 172 173 int mmc_all_send_cid(struct mmc_host *host, u32 *cid) 174 { 175 int err; 176 struct mmc_command cmd = {0}; 177 178 BUG_ON(!host); 179 BUG_ON(!cid); 180 181 cmd.opcode = MMC_ALL_SEND_CID; 182 cmd.arg = 0; 183 cmd.flags = MMC_RSP_R2 | MMC_CMD_BCR; 184 185 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 186 if (err) 187 return err; 188 189 memcpy(cid, cmd.resp, sizeof(u32) * 4); 190 191 return 0; 192 } 193 194 int mmc_set_relative_addr(struct mmc_card *card) 195 { 196 int err; 197 struct mmc_command cmd = {0}; 198 199 BUG_ON(!card); 200 BUG_ON(!card->host); 201 202 cmd.opcode = MMC_SET_RELATIVE_ADDR; 203 cmd.arg = card->rca << 16; 204 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 205 206 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 207 if (err) 208 return err; 209 210 return 0; 211 } 212 213 static int 214 mmc_send_cxd_native(struct mmc_host *host, u32 arg, u32 *cxd, int opcode) 215 { 216 int err; 217 struct mmc_command cmd = {0}; 218 219 BUG_ON(!host); 220 BUG_ON(!cxd); 221 222 cmd.opcode = opcode; 223 cmd.arg = arg; 224 cmd.flags = MMC_RSP_R2 | MMC_CMD_AC; 225 226 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES); 227 if (err) 228 return err; 229 230 memcpy(cxd, cmd.resp, sizeof(u32) * 4); 231 232 return 0; 233 } 234 235 /* 236 * NOTE: void *buf, caller for the buf is required to use DMA-capable 237 * buffer or on-stack buffer (with some overhead in callee). 238 */ 239 static int 240 mmc_send_cxd_data(struct mmc_card *card, struct mmc_host *host, 241 u32 opcode, void *buf, unsigned len) 242 { 243 struct mmc_request mrq = {NULL}; 244 struct mmc_command cmd = {0}; 245 struct mmc_data data = {0}; 246 struct scatterlist sg; 247 void *data_buf; 248 int is_on_stack; 249 250 is_on_stack = object_is_on_stack(buf); 251 if (is_on_stack) { 252 /* 253 * dma onto stack is unsafe/nonportable, but callers to this 254 * routine normally provide temporary on-stack buffers ... 255 */ 256 data_buf = kmalloc(len, GFP_KERNEL); 257 if (!data_buf) 258 return -ENOMEM; 259 } else 260 data_buf = buf; 261 262 mrq.cmd = &cmd; 263 mrq.data = &data; 264 265 cmd.opcode = opcode; 266 cmd.arg = 0; 267 268 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we 269 * rely on callers to never use this with "native" calls for reading 270 * CSD or CID. Native versions of those commands use the R2 type, 271 * not R1 plus a data block. 272 */ 273 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 274 275 data.blksz = len; 276 data.blocks = 1; 277 data.flags = MMC_DATA_READ; 278 data.sg = &sg; 279 data.sg_len = 1; 280 281 sg_init_one(&sg, data_buf, len); 282 283 if (opcode == MMC_SEND_CSD || opcode == MMC_SEND_CID) { 284 /* 285 * The spec states that CSR and CID accesses have a timeout 286 * of 64 clock cycles. 287 */ 288 data.timeout_ns = 0; 289 data.timeout_clks = 64; 290 } else 291 mmc_set_data_timeout(&data, card); 292 293 mmc_wait_for_req(host, &mrq); 294 295 if (is_on_stack) { 296 memcpy(buf, data_buf, len); 297 kfree(data_buf); 298 } 299 300 if (cmd.error) 301 return cmd.error; 302 if (data.error) 303 return data.error; 304 305 return 0; 306 } 307 308 int mmc_send_csd(struct mmc_card *card, u32 *csd) 309 { 310 int ret, i; 311 u32 *csd_tmp; 312 313 if (!mmc_host_is_spi(card->host)) 314 return mmc_send_cxd_native(card->host, card->rca << 16, 315 csd, MMC_SEND_CSD); 316 317 csd_tmp = kmalloc(16, GFP_KERNEL); 318 if (!csd_tmp) 319 return -ENOMEM; 320 321 ret = mmc_send_cxd_data(card, card->host, MMC_SEND_CSD, csd_tmp, 16); 322 if (ret) 323 goto err; 324 325 for (i = 0;i < 4;i++) 326 csd[i] = be32_to_cpu(csd_tmp[i]); 327 328 err: 329 kfree(csd_tmp); 330 return ret; 331 } 332 333 int mmc_send_cid(struct mmc_host *host, u32 *cid) 334 { 335 int ret, i; 336 u32 *cid_tmp; 337 338 if (!mmc_host_is_spi(host)) { 339 if (!host->card) 340 return -EINVAL; 341 return mmc_send_cxd_native(host, host->card->rca << 16, 342 cid, MMC_SEND_CID); 343 } 344 345 cid_tmp = kmalloc(16, GFP_KERNEL); 346 if (!cid_tmp) 347 return -ENOMEM; 348 349 ret = mmc_send_cxd_data(NULL, host, MMC_SEND_CID, cid_tmp, 16); 350 if (ret) 351 goto err; 352 353 for (i = 0;i < 4;i++) 354 cid[i] = be32_to_cpu(cid_tmp[i]); 355 356 err: 357 kfree(cid_tmp); 358 return ret; 359 } 360 361 int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd) 362 { 363 return mmc_send_cxd_data(card, card->host, MMC_SEND_EXT_CSD, 364 ext_csd, 512); 365 } 366 EXPORT_SYMBOL_GPL(mmc_send_ext_csd); 367 368 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp) 369 { 370 struct mmc_command cmd = {0}; 371 int err; 372 373 cmd.opcode = MMC_SPI_READ_OCR; 374 cmd.arg = highcap ? (1 << 30) : 0; 375 cmd.flags = MMC_RSP_SPI_R3; 376 377 err = mmc_wait_for_cmd(host, &cmd, 0); 378 379 *ocrp = cmd.resp[1]; 380 return err; 381 } 382 383 int mmc_spi_set_crc(struct mmc_host *host, int use_crc) 384 { 385 struct mmc_command cmd = {0}; 386 int err; 387 388 cmd.opcode = MMC_SPI_CRC_ON_OFF; 389 cmd.flags = MMC_RSP_SPI_R1; 390 cmd.arg = use_crc; 391 392 err = mmc_wait_for_cmd(host, &cmd, 0); 393 if (!err) 394 host->use_spi_crc = use_crc; 395 return err; 396 } 397 398 /** 399 * __mmc_switch - modify EXT_CSD register 400 * @card: the MMC card associated with the data transfer 401 * @set: cmd set values 402 * @index: EXT_CSD register index 403 * @value: value to program into EXT_CSD register 404 * @timeout_ms: timeout (ms) for operation performed by register write, 405 * timeout of zero implies maximum possible timeout 406 * @use_busy_signal: use the busy signal as response type 407 * 408 * Modifies the EXT_CSD register for selected card. 409 */ 410 int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, 411 unsigned int timeout_ms, bool use_busy_signal) 412 { 413 int err; 414 struct mmc_command cmd = {0}; 415 unsigned long timeout; 416 u32 status; 417 418 BUG_ON(!card); 419 BUG_ON(!card->host); 420 421 cmd.opcode = MMC_SWITCH; 422 cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 423 (index << 16) | 424 (value << 8) | 425 set; 426 cmd.flags = MMC_CMD_AC; 427 if (use_busy_signal) 428 cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B; 429 else 430 cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1; 431 432 433 cmd.cmd_timeout_ms = timeout_ms; 434 435 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 436 if (err) 437 return err; 438 439 /* No need to check card status in case of unblocking command */ 440 if (!use_busy_signal) 441 return 0; 442 443 /* Must check status to be sure of no errors */ 444 timeout = jiffies + msecs_to_jiffies(MMC_OPS_TIMEOUT_MS); 445 do { 446 err = mmc_send_status(card, &status); 447 if (err) 448 return err; 449 if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) 450 break; 451 if (mmc_host_is_spi(card->host)) 452 break; 453 454 /* Timeout if the device never leaves the program state. */ 455 if (time_after(jiffies, timeout)) { 456 pr_err("%s: Card stuck in programming state! %s\n", 457 mmc_hostname(card->host), __func__); 458 return -ETIMEDOUT; 459 } 460 } while (R1_CURRENT_STATE(status) == R1_STATE_PRG); 461 462 if (mmc_host_is_spi(card->host)) { 463 if (status & R1_SPI_ILLEGAL_COMMAND) 464 return -EBADMSG; 465 } else { 466 if (status & 0xFDFFA000) 467 pr_warning("%s: unexpected status %#x after " 468 "switch", mmc_hostname(card->host), status); 469 if (status & R1_SWITCH_ERROR) 470 return -EBADMSG; 471 } 472 473 return 0; 474 } 475 EXPORT_SYMBOL_GPL(__mmc_switch); 476 477 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, 478 unsigned int timeout_ms) 479 { 480 return __mmc_switch(card, set, index, value, timeout_ms, true); 481 } 482 EXPORT_SYMBOL_GPL(mmc_switch); 483 484 int mmc_send_status(struct mmc_card *card, u32 *status) 485 { 486 int err; 487 struct mmc_command cmd = {0}; 488 489 BUG_ON(!card); 490 BUG_ON(!card->host); 491 492 cmd.opcode = MMC_SEND_STATUS; 493 if (!mmc_host_is_spi(card->host)) 494 cmd.arg = card->rca << 16; 495 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; 496 497 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 498 if (err) 499 return err; 500 501 /* NOTE: callers are required to understand the difference 502 * between "native" and SPI format status words! 503 */ 504 if (status) 505 *status = cmd.resp[0]; 506 507 return 0; 508 } 509 510 static int 511 mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode, 512 u8 len) 513 { 514 struct mmc_request mrq = {NULL}; 515 struct mmc_command cmd = {0}; 516 struct mmc_data data = {0}; 517 struct scatterlist sg; 518 u8 *data_buf; 519 u8 *test_buf; 520 int i, err; 521 static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 }; 522 static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 }; 523 524 /* dma onto stack is unsafe/nonportable, but callers to this 525 * routine normally provide temporary on-stack buffers ... 526 */ 527 data_buf = kmalloc(len, GFP_KERNEL); 528 if (!data_buf) 529 return -ENOMEM; 530 531 if (len == 8) 532 test_buf = testdata_8bit; 533 else if (len == 4) 534 test_buf = testdata_4bit; 535 else { 536 pr_err("%s: Invalid bus_width %d\n", 537 mmc_hostname(host), len); 538 kfree(data_buf); 539 return -EINVAL; 540 } 541 542 if (opcode == MMC_BUS_TEST_W) 543 memcpy(data_buf, test_buf, len); 544 545 mrq.cmd = &cmd; 546 mrq.data = &data; 547 cmd.opcode = opcode; 548 cmd.arg = 0; 549 550 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we 551 * rely on callers to never use this with "native" calls for reading 552 * CSD or CID. Native versions of those commands use the R2 type, 553 * not R1 plus a data block. 554 */ 555 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 556 557 data.blksz = len; 558 data.blocks = 1; 559 if (opcode == MMC_BUS_TEST_R) 560 data.flags = MMC_DATA_READ; 561 else 562 data.flags = MMC_DATA_WRITE; 563 564 data.sg = &sg; 565 data.sg_len = 1; 566 sg_init_one(&sg, data_buf, len); 567 mmc_wait_for_req(host, &mrq); 568 err = 0; 569 if (opcode == MMC_BUS_TEST_R) { 570 for (i = 0; i < len / 4; i++) 571 if ((test_buf[i] ^ data_buf[i]) != 0xff) { 572 err = -EIO; 573 break; 574 } 575 } 576 kfree(data_buf); 577 578 if (cmd.error) 579 return cmd.error; 580 if (data.error) 581 return data.error; 582 583 return err; 584 } 585 586 int mmc_bus_test(struct mmc_card *card, u8 bus_width) 587 { 588 int err, width; 589 590 if (bus_width == MMC_BUS_WIDTH_8) 591 width = 8; 592 else if (bus_width == MMC_BUS_WIDTH_4) 593 width = 4; 594 else if (bus_width == MMC_BUS_WIDTH_1) 595 return 0; /* no need for test */ 596 else 597 return -EINVAL; 598 599 /* 600 * Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there 601 * is a problem. This improves chances that the test will work. 602 */ 603 mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width); 604 err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width); 605 return err; 606 } 607 608 int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status) 609 { 610 struct mmc_command cmd = {0}; 611 unsigned int opcode; 612 int err; 613 614 if (!card->ext_csd.hpi) { 615 pr_warning("%s: Card didn't support HPI command\n", 616 mmc_hostname(card->host)); 617 return -EINVAL; 618 } 619 620 opcode = card->ext_csd.hpi_cmd; 621 if (opcode == MMC_STOP_TRANSMISSION) 622 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 623 else if (opcode == MMC_SEND_STATUS) 624 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 625 626 cmd.opcode = opcode; 627 cmd.arg = card->rca << 16 | 1; 628 629 err = mmc_wait_for_cmd(card->host, &cmd, 0); 630 if (err) { 631 pr_warn("%s: error %d interrupting operation. " 632 "HPI command response %#x\n", mmc_hostname(card->host), 633 err, cmd.resp[0]); 634 return err; 635 } 636 if (status) 637 *status = cmd.resp[0]; 638 639 return 0; 640 } 641