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 367 int mmc_spi_read_ocr(struct mmc_host *host, int highcap, u32 *ocrp) 368 { 369 struct mmc_command cmd = {0}; 370 int err; 371 372 cmd.opcode = MMC_SPI_READ_OCR; 373 cmd.arg = highcap ? (1 << 30) : 0; 374 cmd.flags = MMC_RSP_SPI_R3; 375 376 err = mmc_wait_for_cmd(host, &cmd, 0); 377 378 *ocrp = cmd.resp[1]; 379 return err; 380 } 381 382 int mmc_spi_set_crc(struct mmc_host *host, int use_crc) 383 { 384 struct mmc_command cmd = {0}; 385 int err; 386 387 cmd.opcode = MMC_SPI_CRC_ON_OFF; 388 cmd.flags = MMC_RSP_SPI_R1; 389 cmd.arg = use_crc; 390 391 err = mmc_wait_for_cmd(host, &cmd, 0); 392 if (!err) 393 host->use_spi_crc = use_crc; 394 return err; 395 } 396 397 /** 398 * __mmc_switch - modify EXT_CSD register 399 * @card: the MMC card associated with the data transfer 400 * @set: cmd set values 401 * @index: EXT_CSD register index 402 * @value: value to program into EXT_CSD register 403 * @timeout_ms: timeout (ms) for operation performed by register write, 404 * timeout of zero implies maximum possible timeout 405 * @use_busy_signal: use the busy signal as response type 406 * 407 * Modifies the EXT_CSD register for selected card. 408 */ 409 int __mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, 410 unsigned int timeout_ms, bool use_busy_signal) 411 { 412 int err; 413 struct mmc_command cmd = {0}; 414 unsigned long timeout; 415 u32 status; 416 417 BUG_ON(!card); 418 BUG_ON(!card->host); 419 420 cmd.opcode = MMC_SWITCH; 421 cmd.arg = (MMC_SWITCH_MODE_WRITE_BYTE << 24) | 422 (index << 16) | 423 (value << 8) | 424 set; 425 cmd.flags = MMC_CMD_AC; 426 if (use_busy_signal) 427 cmd.flags |= MMC_RSP_SPI_R1B | MMC_RSP_R1B; 428 else 429 cmd.flags |= MMC_RSP_SPI_R1 | MMC_RSP_R1; 430 431 432 cmd.cmd_timeout_ms = timeout_ms; 433 434 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 435 if (err) 436 return err; 437 438 /* No need to check card status in case of unblocking command */ 439 if (!use_busy_signal) 440 return 0; 441 442 /* Must check status to be sure of no errors */ 443 timeout = jiffies + msecs_to_jiffies(MMC_OPS_TIMEOUT_MS); 444 do { 445 err = mmc_send_status(card, &status); 446 if (err) 447 return err; 448 if (card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) 449 break; 450 if (mmc_host_is_spi(card->host)) 451 break; 452 453 /* Timeout if the device never leaves the program state. */ 454 if (time_after(jiffies, timeout)) { 455 pr_err("%s: Card stuck in programming state! %s\n", 456 mmc_hostname(card->host), __func__); 457 return -ETIMEDOUT; 458 } 459 } while (R1_CURRENT_STATE(status) == R1_STATE_PRG); 460 461 if (mmc_host_is_spi(card->host)) { 462 if (status & R1_SPI_ILLEGAL_COMMAND) 463 return -EBADMSG; 464 } else { 465 if (status & 0xFDFFA000) 466 pr_warning("%s: unexpected status %#x after " 467 "switch", mmc_hostname(card->host), status); 468 if (status & R1_SWITCH_ERROR) 469 return -EBADMSG; 470 } 471 472 return 0; 473 } 474 EXPORT_SYMBOL_GPL(__mmc_switch); 475 476 int mmc_switch(struct mmc_card *card, u8 set, u8 index, u8 value, 477 unsigned int timeout_ms) 478 { 479 return __mmc_switch(card, set, index, value, timeout_ms, true); 480 } 481 EXPORT_SYMBOL_GPL(mmc_switch); 482 483 int mmc_send_status(struct mmc_card *card, u32 *status) 484 { 485 int err; 486 struct mmc_command cmd = {0}; 487 488 BUG_ON(!card); 489 BUG_ON(!card->host); 490 491 cmd.opcode = MMC_SEND_STATUS; 492 if (!mmc_host_is_spi(card->host)) 493 cmd.arg = card->rca << 16; 494 cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC; 495 496 err = mmc_wait_for_cmd(card->host, &cmd, MMC_CMD_RETRIES); 497 if (err) 498 return err; 499 500 /* NOTE: callers are required to understand the difference 501 * between "native" and SPI format status words! 502 */ 503 if (status) 504 *status = cmd.resp[0]; 505 506 return 0; 507 } 508 509 static int 510 mmc_send_bus_test(struct mmc_card *card, struct mmc_host *host, u8 opcode, 511 u8 len) 512 { 513 struct mmc_request mrq = {NULL}; 514 struct mmc_command cmd = {0}; 515 struct mmc_data data = {0}; 516 struct scatterlist sg; 517 u8 *data_buf; 518 u8 *test_buf; 519 int i, err; 520 static u8 testdata_8bit[8] = { 0x55, 0xaa, 0, 0, 0, 0, 0, 0 }; 521 static u8 testdata_4bit[4] = { 0x5a, 0, 0, 0 }; 522 523 /* dma onto stack is unsafe/nonportable, but callers to this 524 * routine normally provide temporary on-stack buffers ... 525 */ 526 data_buf = kmalloc(len, GFP_KERNEL); 527 if (!data_buf) 528 return -ENOMEM; 529 530 if (len == 8) 531 test_buf = testdata_8bit; 532 else if (len == 4) 533 test_buf = testdata_4bit; 534 else { 535 pr_err("%s: Invalid bus_width %d\n", 536 mmc_hostname(host), len); 537 kfree(data_buf); 538 return -EINVAL; 539 } 540 541 if (opcode == MMC_BUS_TEST_W) 542 memcpy(data_buf, test_buf, len); 543 544 mrq.cmd = &cmd; 545 mrq.data = &data; 546 cmd.opcode = opcode; 547 cmd.arg = 0; 548 549 /* NOTE HACK: the MMC_RSP_SPI_R1 is always correct here, but we 550 * rely on callers to never use this with "native" calls for reading 551 * CSD or CID. Native versions of those commands use the R2 type, 552 * not R1 plus a data block. 553 */ 554 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_ADTC; 555 556 data.blksz = len; 557 data.blocks = 1; 558 if (opcode == MMC_BUS_TEST_R) 559 data.flags = MMC_DATA_READ; 560 else 561 data.flags = MMC_DATA_WRITE; 562 563 data.sg = &sg; 564 data.sg_len = 1; 565 sg_init_one(&sg, data_buf, len); 566 mmc_wait_for_req(host, &mrq); 567 err = 0; 568 if (opcode == MMC_BUS_TEST_R) { 569 for (i = 0; i < len / 4; i++) 570 if ((test_buf[i] ^ data_buf[i]) != 0xff) { 571 err = -EIO; 572 break; 573 } 574 } 575 kfree(data_buf); 576 577 if (cmd.error) 578 return cmd.error; 579 if (data.error) 580 return data.error; 581 582 return err; 583 } 584 585 int mmc_bus_test(struct mmc_card *card, u8 bus_width) 586 { 587 int err, width; 588 589 if (bus_width == MMC_BUS_WIDTH_8) 590 width = 8; 591 else if (bus_width == MMC_BUS_WIDTH_4) 592 width = 4; 593 else if (bus_width == MMC_BUS_WIDTH_1) 594 return 0; /* no need for test */ 595 else 596 return -EINVAL; 597 598 /* 599 * Ignore errors from BUS_TEST_W. BUS_TEST_R will fail if there 600 * is a problem. This improves chances that the test will work. 601 */ 602 mmc_send_bus_test(card, card->host, MMC_BUS_TEST_W, width); 603 err = mmc_send_bus_test(card, card->host, MMC_BUS_TEST_R, width); 604 return err; 605 } 606 607 int mmc_send_hpi_cmd(struct mmc_card *card, u32 *status) 608 { 609 struct mmc_command cmd = {0}; 610 unsigned int opcode; 611 int err; 612 613 if (!card->ext_csd.hpi) { 614 pr_warning("%s: Card didn't support HPI command\n", 615 mmc_hostname(card->host)); 616 return -EINVAL; 617 } 618 619 opcode = card->ext_csd.hpi_cmd; 620 if (opcode == MMC_STOP_TRANSMISSION) 621 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 622 else if (opcode == MMC_SEND_STATUS) 623 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 624 625 cmd.opcode = opcode; 626 cmd.arg = card->rca << 16 | 1; 627 628 err = mmc_wait_for_cmd(card->host, &cmd, 0); 629 if (err) { 630 pr_warn("%s: error %d interrupting operation. " 631 "HPI command response %#x\n", mmc_hostname(card->host), 632 err, cmd.resp[0]); 633 return err; 634 } 635 if (status) 636 *status = cmd.resp[0]; 637 638 return 0; 639 } 640