1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/drivers/mmc/core/core.c 4 * 5 * Copyright (C) 2003-2004 Russell King, All Rights Reserved. 6 * SD support Copyright (C) 2004 Ian Molton, All Rights Reserved. 7 * Copyright (C) 2005-2008 Pierre Ossman, All Rights Reserved. 8 * MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved. 9 */ 10 #include <linux/module.h> 11 #include <linux/init.h> 12 #include <linux/interrupt.h> 13 #include <linux/completion.h> 14 #include <linux/device.h> 15 #include <linux/delay.h> 16 #include <linux/pagemap.h> 17 #include <linux/err.h> 18 #include <linux/leds.h> 19 #include <linux/scatterlist.h> 20 #include <linux/log2.h> 21 #include <linux/pm_runtime.h> 22 #include <linux/pm_wakeup.h> 23 #include <linux/suspend.h> 24 #include <linux/fault-inject.h> 25 #include <linux/random.h> 26 #include <linux/slab.h> 27 #include <linux/of.h> 28 29 #include <linux/mmc/card.h> 30 #include <linux/mmc/host.h> 31 #include <linux/mmc/mmc.h> 32 #include <linux/mmc/sd.h> 33 #include <linux/mmc/slot-gpio.h> 34 35 #define CREATE_TRACE_POINTS 36 #include <trace/events/mmc.h> 37 38 #include "core.h" 39 #include "card.h" 40 #include "crypto.h" 41 #include "bus.h" 42 #include "host.h" 43 #include "sdio_bus.h" 44 #include "pwrseq.h" 45 46 #include "mmc_ops.h" 47 #include "sd_ops.h" 48 #include "sdio_ops.h" 49 50 /* The max erase timeout, used when host->max_busy_timeout isn't specified */ 51 #define MMC_ERASE_TIMEOUT_MS (60 * 1000) /* 60 s */ 52 #define SD_DISCARD_TIMEOUT_MS (250) 53 54 static const unsigned freqs[] = { 400000, 300000, 200000, 100000 }; 55 56 /* 57 * Enabling software CRCs on the data blocks can be a significant (30%) 58 * performance cost, and for other reasons may not always be desired. 59 * So we allow it to be disabled. 60 */ 61 bool use_spi_crc = 1; 62 module_param(use_spi_crc, bool, 0); 63 64 static int mmc_schedule_delayed_work(struct delayed_work *work, 65 unsigned long delay) 66 { 67 /* 68 * We use the system_freezable_wq, because of two reasons. 69 * First, it allows several works (not the same work item) to be 70 * executed simultaneously. Second, the queue becomes frozen when 71 * userspace becomes frozen during system PM. 72 */ 73 return queue_delayed_work(system_freezable_wq, work, delay); 74 } 75 76 #ifdef CONFIG_FAIL_MMC_REQUEST 77 78 /* 79 * Internal function. Inject random data errors. 80 * If mmc_data is NULL no errors are injected. 81 */ 82 static void mmc_should_fail_request(struct mmc_host *host, 83 struct mmc_request *mrq) 84 { 85 struct mmc_command *cmd = mrq->cmd; 86 struct mmc_data *data = mrq->data; 87 static const int data_errors[] = { 88 -ETIMEDOUT, 89 -EILSEQ, 90 -EIO, 91 }; 92 93 if (!data) 94 return; 95 96 if ((cmd && cmd->error) || data->error || 97 !should_fail(&host->fail_mmc_request, data->blksz * data->blocks)) 98 return; 99 100 data->error = data_errors[get_random_u32_below(ARRAY_SIZE(data_errors))]; 101 data->bytes_xfered = get_random_u32_below(data->bytes_xfered >> 9) << 9; 102 } 103 104 #else /* CONFIG_FAIL_MMC_REQUEST */ 105 106 static inline void mmc_should_fail_request(struct mmc_host *host, 107 struct mmc_request *mrq) 108 { 109 } 110 111 #endif /* CONFIG_FAIL_MMC_REQUEST */ 112 113 static inline void mmc_complete_cmd(struct mmc_request *mrq) 114 { 115 if (mrq->cap_cmd_during_tfr && !completion_done(&mrq->cmd_completion)) 116 complete_all(&mrq->cmd_completion); 117 } 118 119 void mmc_command_done(struct mmc_host *host, struct mmc_request *mrq) 120 { 121 if (!mrq->cap_cmd_during_tfr) 122 return; 123 124 mmc_complete_cmd(mrq); 125 126 pr_debug("%s: cmd done, tfr ongoing (CMD%u)\n", 127 mmc_hostname(host), mrq->cmd->opcode); 128 } 129 EXPORT_SYMBOL(mmc_command_done); 130 131 /** 132 * mmc_request_done - finish processing an MMC request 133 * @host: MMC host which completed request 134 * @mrq: MMC request which request 135 * 136 * MMC drivers should call this function when they have completed 137 * their processing of a request. 138 */ 139 void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq) 140 { 141 struct mmc_command *cmd = mrq->cmd; 142 int err = cmd->error; 143 144 /* Flag re-tuning needed on CRC errors */ 145 if (!mmc_op_tuning(cmd->opcode) && 146 !host->retune_crc_disable && 147 (err == -EILSEQ || (mrq->sbc && mrq->sbc->error == -EILSEQ) || 148 (mrq->data && mrq->data->error == -EILSEQ) || 149 (mrq->stop && mrq->stop->error == -EILSEQ))) 150 mmc_retune_needed(host); 151 152 if (err && cmd->retries && mmc_host_is_spi(host)) { 153 if (cmd->resp[0] & R1_SPI_ILLEGAL_COMMAND) 154 cmd->retries = 0; 155 } 156 157 if (host->ongoing_mrq == mrq) 158 host->ongoing_mrq = NULL; 159 160 mmc_complete_cmd(mrq); 161 162 trace_mmc_request_done(host, mrq); 163 164 /* 165 * We list various conditions for the command to be considered 166 * properly done: 167 * 168 * - There was no error, OK fine then 169 * - We are not doing some kind of retry 170 * - The card was removed (...so just complete everything no matter 171 * if there are errors or retries) 172 */ 173 if (!err || !cmd->retries || mmc_card_removed(host->card)) { 174 mmc_should_fail_request(host, mrq); 175 176 if (!host->ongoing_mrq) 177 led_trigger_event(host->led, LED_OFF); 178 179 if (mrq->sbc) { 180 pr_debug("%s: req done <CMD%u>: %d: %08x %08x %08x %08x\n", 181 mmc_hostname(host), mrq->sbc->opcode, 182 mrq->sbc->error, 183 mrq->sbc->resp[0], mrq->sbc->resp[1], 184 mrq->sbc->resp[2], mrq->sbc->resp[3]); 185 } 186 187 pr_debug("%s: req done (CMD%u): %d: %08x %08x %08x %08x\n", 188 mmc_hostname(host), cmd->opcode, err, 189 cmd->resp[0], cmd->resp[1], 190 cmd->resp[2], cmd->resp[3]); 191 192 if (mrq->data) { 193 pr_debug("%s: %d bytes transferred: %d\n", 194 mmc_hostname(host), 195 mrq->data->bytes_xfered, mrq->data->error); 196 } 197 198 if (mrq->stop) { 199 pr_debug("%s: (CMD%u): %d: %08x %08x %08x %08x\n", 200 mmc_hostname(host), mrq->stop->opcode, 201 mrq->stop->error, 202 mrq->stop->resp[0], mrq->stop->resp[1], 203 mrq->stop->resp[2], mrq->stop->resp[3]); 204 } 205 } 206 /* 207 * Request starter must handle retries - see 208 * mmc_wait_for_req_done(). 209 */ 210 if (mrq->done) 211 mrq->done(mrq); 212 } 213 214 EXPORT_SYMBOL(mmc_request_done); 215 216 static void __mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) 217 { 218 int err; 219 220 /* Assumes host controller has been runtime resumed by mmc_claim_host */ 221 err = mmc_retune(host); 222 if (err) { 223 mrq->cmd->error = err; 224 mmc_request_done(host, mrq); 225 return; 226 } 227 228 /* 229 * For sdio rw commands we must wait for card busy otherwise some 230 * sdio devices won't work properly. 231 * And bypass I/O abort, reset and bus suspend operations. 232 */ 233 if (sdio_is_io_busy(mrq->cmd->opcode, mrq->cmd->arg) && 234 host->ops->card_busy) { 235 int tries = 500; /* Wait aprox 500ms at maximum */ 236 237 while (host->ops->card_busy(host) && --tries) 238 mmc_delay(1); 239 240 if (tries == 0) { 241 mrq->cmd->error = -EBUSY; 242 mmc_request_done(host, mrq); 243 return; 244 } 245 } 246 247 if (mrq->cap_cmd_during_tfr) { 248 host->ongoing_mrq = mrq; 249 /* 250 * Retry path could come through here without having waiting on 251 * cmd_completion, so ensure it is reinitialised. 252 */ 253 reinit_completion(&mrq->cmd_completion); 254 } 255 256 trace_mmc_request_start(host, mrq); 257 258 if (host->cqe_on) 259 host->cqe_ops->cqe_off(host); 260 261 host->ops->request(host, mrq); 262 } 263 264 static void mmc_mrq_pr_debug(struct mmc_host *host, struct mmc_request *mrq, 265 bool cqe) 266 { 267 if (mrq->sbc) { 268 pr_debug("<%s: starting CMD%u arg %08x flags %08x>\n", 269 mmc_hostname(host), mrq->sbc->opcode, 270 mrq->sbc->arg, mrq->sbc->flags); 271 } 272 273 if (mrq->cmd) { 274 pr_debug("%s: starting %sCMD%u arg %08x flags %08x\n", 275 mmc_hostname(host), cqe ? "CQE direct " : "", 276 mrq->cmd->opcode, mrq->cmd->arg, mrq->cmd->flags); 277 } else if (cqe) { 278 pr_debug("%s: starting CQE transfer for tag %d blkaddr %u\n", 279 mmc_hostname(host), mrq->tag, mrq->data->blk_addr); 280 } 281 282 if (mrq->data) { 283 pr_debug("%s: blksz %d blocks %d flags %08x " 284 "tsac %d ms nsac %d\n", 285 mmc_hostname(host), mrq->data->blksz, 286 mrq->data->blocks, mrq->data->flags, 287 mrq->data->timeout_ns / 1000000, 288 mrq->data->timeout_clks); 289 } 290 291 if (mrq->stop) { 292 pr_debug("%s: CMD%u arg %08x flags %08x\n", 293 mmc_hostname(host), mrq->stop->opcode, 294 mrq->stop->arg, mrq->stop->flags); 295 } 296 } 297 298 static int mmc_mrq_prep(struct mmc_host *host, struct mmc_request *mrq) 299 { 300 unsigned int i, sz = 0; 301 struct scatterlist *sg; 302 303 if (mrq->cmd) { 304 mrq->cmd->error = 0; 305 mrq->cmd->mrq = mrq; 306 mrq->cmd->data = mrq->data; 307 } 308 if (mrq->sbc) { 309 mrq->sbc->error = 0; 310 mrq->sbc->mrq = mrq; 311 } 312 if (mrq->data) { 313 if (mrq->data->blksz > host->max_blk_size || 314 mrq->data->blocks > host->max_blk_count || 315 mrq->data->blocks * mrq->data->blksz > host->max_req_size) 316 return -EINVAL; 317 318 for_each_sg(mrq->data->sg, sg, mrq->data->sg_len, i) 319 sz += sg->length; 320 if (sz != mrq->data->blocks * mrq->data->blksz) 321 return -EINVAL; 322 323 mrq->data->error = 0; 324 mrq->data->mrq = mrq; 325 if (mrq->stop) { 326 mrq->data->stop = mrq->stop; 327 mrq->stop->error = 0; 328 mrq->stop->mrq = mrq; 329 } 330 } 331 332 return 0; 333 } 334 335 int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq) 336 { 337 int err; 338 339 init_completion(&mrq->cmd_completion); 340 341 mmc_retune_hold(host); 342 343 if (mmc_card_removed(host->card)) 344 return -ENOMEDIUM; 345 346 mmc_mrq_pr_debug(host, mrq, false); 347 348 WARN_ON(!host->claimed); 349 350 err = mmc_mrq_prep(host, mrq); 351 if (err) 352 return err; 353 354 led_trigger_event(host->led, LED_FULL); 355 __mmc_start_request(host, mrq); 356 357 return 0; 358 } 359 EXPORT_SYMBOL(mmc_start_request); 360 361 static void mmc_wait_done(struct mmc_request *mrq) 362 { 363 complete(&mrq->completion); 364 } 365 366 static inline void mmc_wait_ongoing_tfr_cmd(struct mmc_host *host) 367 { 368 struct mmc_request *ongoing_mrq = READ_ONCE(host->ongoing_mrq); 369 370 /* 371 * If there is an ongoing transfer, wait for the command line to become 372 * available. 373 */ 374 if (ongoing_mrq && !completion_done(&ongoing_mrq->cmd_completion)) 375 wait_for_completion(&ongoing_mrq->cmd_completion); 376 } 377 378 static int __mmc_start_req(struct mmc_host *host, struct mmc_request *mrq) 379 { 380 int err; 381 382 mmc_wait_ongoing_tfr_cmd(host); 383 384 init_completion(&mrq->completion); 385 mrq->done = mmc_wait_done; 386 387 err = mmc_start_request(host, mrq); 388 if (err) { 389 mrq->cmd->error = err; 390 mmc_complete_cmd(mrq); 391 complete(&mrq->completion); 392 } 393 394 return err; 395 } 396 397 void mmc_wait_for_req_done(struct mmc_host *host, struct mmc_request *mrq) 398 { 399 struct mmc_command *cmd; 400 401 while (1) { 402 wait_for_completion(&mrq->completion); 403 404 cmd = mrq->cmd; 405 406 if (!cmd->error || !cmd->retries || 407 mmc_card_removed(host->card)) 408 break; 409 410 mmc_retune_recheck(host); 411 412 pr_debug("%s: req failed (CMD%u): %d, retrying...\n", 413 mmc_hostname(host), cmd->opcode, cmd->error); 414 cmd->retries--; 415 cmd->error = 0; 416 __mmc_start_request(host, mrq); 417 } 418 419 mmc_retune_release(host); 420 } 421 EXPORT_SYMBOL(mmc_wait_for_req_done); 422 423 /* 424 * mmc_cqe_start_req - Start a CQE request. 425 * @host: MMC host to start the request 426 * @mrq: request to start 427 * 428 * Start the request, re-tuning if needed and it is possible. Returns an error 429 * code if the request fails to start or -EBUSY if CQE is busy. 430 */ 431 int mmc_cqe_start_req(struct mmc_host *host, struct mmc_request *mrq) 432 { 433 int err; 434 435 /* 436 * CQE cannot process re-tuning commands. Caller must hold retuning 437 * while CQE is in use. Re-tuning can happen here only when CQE has no 438 * active requests i.e. this is the first. Note, re-tuning will call 439 * ->cqe_off(). 440 */ 441 err = mmc_retune(host); 442 if (err) 443 goto out_err; 444 445 mrq->host = host; 446 447 mmc_mrq_pr_debug(host, mrq, true); 448 449 err = mmc_mrq_prep(host, mrq); 450 if (err) 451 goto out_err; 452 453 err = host->cqe_ops->cqe_request(host, mrq); 454 if (err) 455 goto out_err; 456 457 trace_mmc_request_start(host, mrq); 458 459 return 0; 460 461 out_err: 462 if (mrq->cmd) { 463 pr_debug("%s: failed to start CQE direct CMD%u, error %d\n", 464 mmc_hostname(host), mrq->cmd->opcode, err); 465 } else { 466 pr_debug("%s: failed to start CQE transfer for tag %d, error %d\n", 467 mmc_hostname(host), mrq->tag, err); 468 } 469 return err; 470 } 471 EXPORT_SYMBOL(mmc_cqe_start_req); 472 473 /** 474 * mmc_cqe_request_done - CQE has finished processing an MMC request 475 * @host: MMC host which completed request 476 * @mrq: MMC request which completed 477 * 478 * CQE drivers should call this function when they have completed 479 * their processing of a request. 480 */ 481 void mmc_cqe_request_done(struct mmc_host *host, struct mmc_request *mrq) 482 { 483 mmc_should_fail_request(host, mrq); 484 485 /* Flag re-tuning needed on CRC errors */ 486 if ((mrq->cmd && mrq->cmd->error == -EILSEQ) || 487 (mrq->data && mrq->data->error == -EILSEQ)) 488 mmc_retune_needed(host); 489 490 trace_mmc_request_done(host, mrq); 491 492 if (mrq->cmd) { 493 pr_debug("%s: CQE req done (direct CMD%u): %d\n", 494 mmc_hostname(host), mrq->cmd->opcode, mrq->cmd->error); 495 } else { 496 pr_debug("%s: CQE transfer done tag %d\n", 497 mmc_hostname(host), mrq->tag); 498 } 499 500 if (mrq->data) { 501 pr_debug("%s: %d bytes transferred: %d\n", 502 mmc_hostname(host), 503 mrq->data->bytes_xfered, mrq->data->error); 504 } 505 506 mrq->done(mrq); 507 } 508 EXPORT_SYMBOL(mmc_cqe_request_done); 509 510 /** 511 * mmc_cqe_post_req - CQE post process of a completed MMC request 512 * @host: MMC host 513 * @mrq: MMC request to be processed 514 */ 515 void mmc_cqe_post_req(struct mmc_host *host, struct mmc_request *mrq) 516 { 517 if (host->cqe_ops->cqe_post_req) 518 host->cqe_ops->cqe_post_req(host, mrq); 519 } 520 EXPORT_SYMBOL(mmc_cqe_post_req); 521 522 /* Arbitrary 1 second timeout */ 523 #define MMC_CQE_RECOVERY_TIMEOUT 1000 524 525 /* 526 * mmc_cqe_recovery - Recover from CQE errors. 527 * @host: MMC host to recover 528 * 529 * Recovery consists of stopping CQE, stopping eMMC, discarding the queue 530 * in eMMC, and discarding the queue in CQE. CQE must call 531 * mmc_cqe_request_done() on all requests. An error is returned if the eMMC 532 * fails to discard its queue. 533 */ 534 int mmc_cqe_recovery(struct mmc_host *host) 535 { 536 struct mmc_command cmd; 537 int err; 538 539 mmc_retune_hold_now(host); 540 541 /* 542 * Recovery is expected seldom, if at all, but it reduces performance, 543 * so make sure it is not completely silent. 544 */ 545 pr_warn("%s: running CQE recovery\n", mmc_hostname(host)); 546 547 host->cqe_ops->cqe_recovery_start(host); 548 549 memset(&cmd, 0, sizeof(cmd)); 550 cmd.opcode = MMC_STOP_TRANSMISSION; 551 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 552 cmd.flags &= ~MMC_RSP_CRC; /* Ignore CRC */ 553 cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT; 554 mmc_wait_for_cmd(host, &cmd, 0); 555 556 memset(&cmd, 0, sizeof(cmd)); 557 cmd.opcode = MMC_CMDQ_TASK_MGMT; 558 cmd.arg = 1; /* Discard entire queue */ 559 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC; 560 cmd.flags &= ~MMC_RSP_CRC; /* Ignore CRC */ 561 cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT; 562 err = mmc_wait_for_cmd(host, &cmd, 0); 563 564 host->cqe_ops->cqe_recovery_finish(host); 565 566 mmc_retune_release(host); 567 568 return err; 569 } 570 EXPORT_SYMBOL(mmc_cqe_recovery); 571 572 /** 573 * mmc_is_req_done - Determine if a 'cap_cmd_during_tfr' request is done 574 * @host: MMC host 575 * @mrq: MMC request 576 * 577 * mmc_is_req_done() is used with requests that have 578 * mrq->cap_cmd_during_tfr = true. mmc_is_req_done() must be called after 579 * starting a request and before waiting for it to complete. That is, 580 * either in between calls to mmc_start_req(), or after mmc_wait_for_req() 581 * and before mmc_wait_for_req_done(). If it is called at other times the 582 * result is not meaningful. 583 */ 584 bool mmc_is_req_done(struct mmc_host *host, struct mmc_request *mrq) 585 { 586 return completion_done(&mrq->completion); 587 } 588 EXPORT_SYMBOL(mmc_is_req_done); 589 590 /** 591 * mmc_wait_for_req - start a request and wait for completion 592 * @host: MMC host to start command 593 * @mrq: MMC request to start 594 * 595 * Start a new MMC custom command request for a host, and wait 596 * for the command to complete. In the case of 'cap_cmd_during_tfr' 597 * requests, the transfer is ongoing and the caller can issue further 598 * commands that do not use the data lines, and then wait by calling 599 * mmc_wait_for_req_done(). 600 * Does not attempt to parse the response. 601 */ 602 void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq) 603 { 604 __mmc_start_req(host, mrq); 605 606 if (!mrq->cap_cmd_during_tfr) 607 mmc_wait_for_req_done(host, mrq); 608 } 609 EXPORT_SYMBOL(mmc_wait_for_req); 610 611 /** 612 * mmc_wait_for_cmd - start a command and wait for completion 613 * @host: MMC host to start command 614 * @cmd: MMC command to start 615 * @retries: maximum number of retries 616 * 617 * Start a new MMC command for a host, and wait for the command 618 * to complete. Return any error that occurred while the command 619 * was executing. Do not attempt to parse the response. 620 */ 621 int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries) 622 { 623 struct mmc_request mrq = {}; 624 625 WARN_ON(!host->claimed); 626 627 memset(cmd->resp, 0, sizeof(cmd->resp)); 628 cmd->retries = retries; 629 630 mrq.cmd = cmd; 631 cmd->data = NULL; 632 633 mmc_wait_for_req(host, &mrq); 634 635 return cmd->error; 636 } 637 638 EXPORT_SYMBOL(mmc_wait_for_cmd); 639 640 /** 641 * mmc_set_data_timeout - set the timeout for a data command 642 * @data: data phase for command 643 * @card: the MMC card associated with the data transfer 644 * 645 * Computes the data timeout parameters according to the 646 * correct algorithm given the card type. 647 */ 648 void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card) 649 { 650 unsigned int mult; 651 652 /* 653 * SDIO cards only define an upper 1 s limit on access. 654 */ 655 if (mmc_card_sdio(card)) { 656 data->timeout_ns = 1000000000; 657 data->timeout_clks = 0; 658 return; 659 } 660 661 /* 662 * SD cards use a 100 multiplier rather than 10 663 */ 664 mult = mmc_card_sd(card) ? 100 : 10; 665 666 /* 667 * Scale up the multiplier (and therefore the timeout) by 668 * the r2w factor for writes. 669 */ 670 if (data->flags & MMC_DATA_WRITE) 671 mult <<= card->csd.r2w_factor; 672 673 data->timeout_ns = card->csd.taac_ns * mult; 674 data->timeout_clks = card->csd.taac_clks * mult; 675 676 /* 677 * SD cards also have an upper limit on the timeout. 678 */ 679 if (mmc_card_sd(card)) { 680 unsigned int timeout_us, limit_us; 681 682 timeout_us = data->timeout_ns / 1000; 683 if (card->host->ios.clock) 684 timeout_us += data->timeout_clks * 1000 / 685 (card->host->ios.clock / 1000); 686 687 if (data->flags & MMC_DATA_WRITE) 688 /* 689 * The MMC spec "It is strongly recommended 690 * for hosts to implement more than 500ms 691 * timeout value even if the card indicates 692 * the 250ms maximum busy length." Even the 693 * previous value of 300ms is known to be 694 * insufficient for some cards. 695 */ 696 limit_us = 3000000; 697 else 698 limit_us = 100000; 699 700 /* 701 * SDHC cards always use these fixed values. 702 */ 703 if (timeout_us > limit_us) { 704 data->timeout_ns = limit_us * 1000; 705 data->timeout_clks = 0; 706 } 707 708 /* assign limit value if invalid */ 709 if (timeout_us == 0) 710 data->timeout_ns = limit_us * 1000; 711 } 712 713 /* 714 * Some cards require longer data read timeout than indicated in CSD. 715 * Address this by setting the read timeout to a "reasonably high" 716 * value. For the cards tested, 600ms has proven enough. If necessary, 717 * this value can be increased if other problematic cards require this. 718 */ 719 if (mmc_card_long_read_time(card) && data->flags & MMC_DATA_READ) { 720 data->timeout_ns = 600000000; 721 data->timeout_clks = 0; 722 } 723 724 /* 725 * Some cards need very high timeouts if driven in SPI mode. 726 * The worst observed timeout was 900ms after writing a 727 * continuous stream of data until the internal logic 728 * overflowed. 729 */ 730 if (mmc_host_is_spi(card->host)) { 731 if (data->flags & MMC_DATA_WRITE) { 732 if (data->timeout_ns < 1000000000) 733 data->timeout_ns = 1000000000; /* 1s */ 734 } else { 735 if (data->timeout_ns < 100000000) 736 data->timeout_ns = 100000000; /* 100ms */ 737 } 738 } 739 } 740 EXPORT_SYMBOL(mmc_set_data_timeout); 741 742 /* 743 * Allow claiming an already claimed host if the context is the same or there is 744 * no context but the task is the same. 745 */ 746 static inline bool mmc_ctx_matches(struct mmc_host *host, struct mmc_ctx *ctx, 747 struct task_struct *task) 748 { 749 return host->claimer == ctx || 750 (!ctx && task && host->claimer->task == task); 751 } 752 753 static inline void mmc_ctx_set_claimer(struct mmc_host *host, 754 struct mmc_ctx *ctx, 755 struct task_struct *task) 756 { 757 if (!host->claimer) { 758 if (ctx) 759 host->claimer = ctx; 760 else 761 host->claimer = &host->default_ctx; 762 } 763 if (task) 764 host->claimer->task = task; 765 } 766 767 /** 768 * __mmc_claim_host - exclusively claim a host 769 * @host: mmc host to claim 770 * @ctx: context that claims the host or NULL in which case the default 771 * context will be used 772 * @abort: whether or not the operation should be aborted 773 * 774 * Claim a host for a set of operations. If @abort is non null and 775 * dereference a non-zero value then this will return prematurely with 776 * that non-zero value without acquiring the lock. Returns zero 777 * with the lock held otherwise. 778 */ 779 int __mmc_claim_host(struct mmc_host *host, struct mmc_ctx *ctx, 780 atomic_t *abort) 781 { 782 struct task_struct *task = ctx ? NULL : current; 783 DECLARE_WAITQUEUE(wait, current); 784 unsigned long flags; 785 int stop; 786 bool pm = false; 787 788 might_sleep(); 789 790 add_wait_queue(&host->wq, &wait); 791 spin_lock_irqsave(&host->lock, flags); 792 while (1) { 793 set_current_state(TASK_UNINTERRUPTIBLE); 794 stop = abort ? atomic_read(abort) : 0; 795 if (stop || !host->claimed || mmc_ctx_matches(host, ctx, task)) 796 break; 797 spin_unlock_irqrestore(&host->lock, flags); 798 schedule(); 799 spin_lock_irqsave(&host->lock, flags); 800 } 801 set_current_state(TASK_RUNNING); 802 if (!stop) { 803 host->claimed = 1; 804 mmc_ctx_set_claimer(host, ctx, task); 805 host->claim_cnt += 1; 806 if (host->claim_cnt == 1) 807 pm = true; 808 } else 809 wake_up(&host->wq); 810 spin_unlock_irqrestore(&host->lock, flags); 811 remove_wait_queue(&host->wq, &wait); 812 813 if (pm) 814 pm_runtime_get_sync(mmc_dev(host)); 815 816 return stop; 817 } 818 EXPORT_SYMBOL(__mmc_claim_host); 819 820 /** 821 * mmc_release_host - release a host 822 * @host: mmc host to release 823 * 824 * Release a MMC host, allowing others to claim the host 825 * for their operations. 826 */ 827 void mmc_release_host(struct mmc_host *host) 828 { 829 unsigned long flags; 830 831 WARN_ON(!host->claimed); 832 833 spin_lock_irqsave(&host->lock, flags); 834 if (--host->claim_cnt) { 835 /* Release for nested claim */ 836 spin_unlock_irqrestore(&host->lock, flags); 837 } else { 838 host->claimed = 0; 839 host->claimer->task = NULL; 840 host->claimer = NULL; 841 spin_unlock_irqrestore(&host->lock, flags); 842 wake_up(&host->wq); 843 pm_runtime_mark_last_busy(mmc_dev(host)); 844 if (host->caps & MMC_CAP_SYNC_RUNTIME_PM) 845 pm_runtime_put_sync_suspend(mmc_dev(host)); 846 else 847 pm_runtime_put_autosuspend(mmc_dev(host)); 848 } 849 } 850 EXPORT_SYMBOL(mmc_release_host); 851 852 /* 853 * This is a helper function, which fetches a runtime pm reference for the 854 * card device and also claims the host. 855 */ 856 void mmc_get_card(struct mmc_card *card, struct mmc_ctx *ctx) 857 { 858 pm_runtime_get_sync(&card->dev); 859 __mmc_claim_host(card->host, ctx, NULL); 860 } 861 EXPORT_SYMBOL(mmc_get_card); 862 863 /* 864 * This is a helper function, which releases the host and drops the runtime 865 * pm reference for the card device. 866 */ 867 void mmc_put_card(struct mmc_card *card, struct mmc_ctx *ctx) 868 { 869 struct mmc_host *host = card->host; 870 871 WARN_ON(ctx && host->claimer != ctx); 872 873 mmc_release_host(host); 874 pm_runtime_mark_last_busy(&card->dev); 875 pm_runtime_put_autosuspend(&card->dev); 876 } 877 EXPORT_SYMBOL(mmc_put_card); 878 879 /* 880 * Internal function that does the actual ios call to the host driver, 881 * optionally printing some debug output. 882 */ 883 static inline void mmc_set_ios(struct mmc_host *host) 884 { 885 struct mmc_ios *ios = &host->ios; 886 887 pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u " 888 "width %u timing %u\n", 889 mmc_hostname(host), ios->clock, ios->bus_mode, 890 ios->power_mode, ios->chip_select, ios->vdd, 891 1 << ios->bus_width, ios->timing); 892 893 host->ops->set_ios(host, ios); 894 } 895 896 /* 897 * Control chip select pin on a host. 898 */ 899 void mmc_set_chip_select(struct mmc_host *host, int mode) 900 { 901 host->ios.chip_select = mode; 902 mmc_set_ios(host); 903 } 904 905 /* 906 * Sets the host clock to the highest possible frequency that 907 * is below "hz". 908 */ 909 void mmc_set_clock(struct mmc_host *host, unsigned int hz) 910 { 911 WARN_ON(hz && hz < host->f_min); 912 913 if (hz > host->f_max) 914 hz = host->f_max; 915 916 host->ios.clock = hz; 917 mmc_set_ios(host); 918 } 919 920 int mmc_execute_tuning(struct mmc_card *card) 921 { 922 struct mmc_host *host = card->host; 923 u32 opcode; 924 int err; 925 926 if (!host->ops->execute_tuning) 927 return 0; 928 929 if (host->cqe_on) 930 host->cqe_ops->cqe_off(host); 931 932 if (mmc_card_mmc(card)) 933 opcode = MMC_SEND_TUNING_BLOCK_HS200; 934 else 935 opcode = MMC_SEND_TUNING_BLOCK; 936 937 err = host->ops->execute_tuning(host, opcode); 938 if (!err) { 939 mmc_retune_clear(host); 940 mmc_retune_enable(host); 941 return 0; 942 } 943 944 /* Only print error when we don't check for card removal */ 945 if (!host->detect_change) { 946 pr_err("%s: tuning execution failed: %d\n", 947 mmc_hostname(host), err); 948 mmc_debugfs_err_stats_inc(host, MMC_ERR_TUNING); 949 } 950 951 return err; 952 } 953 954 /* 955 * Change the bus mode (open drain/push-pull) of a host. 956 */ 957 void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode) 958 { 959 host->ios.bus_mode = mode; 960 mmc_set_ios(host); 961 } 962 963 /* 964 * Change data bus width of a host. 965 */ 966 void mmc_set_bus_width(struct mmc_host *host, unsigned int width) 967 { 968 host->ios.bus_width = width; 969 mmc_set_ios(host); 970 } 971 972 /* 973 * Set initial state after a power cycle or a hw_reset. 974 */ 975 void mmc_set_initial_state(struct mmc_host *host) 976 { 977 if (host->cqe_on) 978 host->cqe_ops->cqe_off(host); 979 980 mmc_retune_disable(host); 981 982 if (mmc_host_is_spi(host)) 983 host->ios.chip_select = MMC_CS_HIGH; 984 else 985 host->ios.chip_select = MMC_CS_DONTCARE; 986 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL; 987 host->ios.bus_width = MMC_BUS_WIDTH_1; 988 host->ios.timing = MMC_TIMING_LEGACY; 989 host->ios.drv_type = 0; 990 host->ios.enhanced_strobe = false; 991 992 /* 993 * Make sure we are in non-enhanced strobe mode before we 994 * actually enable it in ext_csd. 995 */ 996 if ((host->caps2 & MMC_CAP2_HS400_ES) && 997 host->ops->hs400_enhanced_strobe) 998 host->ops->hs400_enhanced_strobe(host, &host->ios); 999 1000 mmc_set_ios(host); 1001 1002 mmc_crypto_set_initial_state(host); 1003 } 1004 1005 /** 1006 * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number 1007 * @vdd: voltage (mV) 1008 * @low_bits: prefer low bits in boundary cases 1009 * 1010 * This function returns the OCR bit number according to the provided @vdd 1011 * value. If conversion is not possible a negative errno value returned. 1012 * 1013 * Depending on the @low_bits flag the function prefers low or high OCR bits 1014 * on boundary voltages. For example, 1015 * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33); 1016 * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34); 1017 * 1018 * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21). 1019 */ 1020 static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits) 1021 { 1022 const int max_bit = ilog2(MMC_VDD_35_36); 1023 int bit; 1024 1025 if (vdd < 1650 || vdd > 3600) 1026 return -EINVAL; 1027 1028 if (vdd >= 1650 && vdd <= 1950) 1029 return ilog2(MMC_VDD_165_195); 1030 1031 if (low_bits) 1032 vdd -= 1; 1033 1034 /* Base 2000 mV, step 100 mV, bit's base 8. */ 1035 bit = (vdd - 2000) / 100 + 8; 1036 if (bit > max_bit) 1037 return max_bit; 1038 return bit; 1039 } 1040 1041 /** 1042 * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask 1043 * @vdd_min: minimum voltage value (mV) 1044 * @vdd_max: maximum voltage value (mV) 1045 * 1046 * This function returns the OCR mask bits according to the provided @vdd_min 1047 * and @vdd_max values. If conversion is not possible the function returns 0. 1048 * 1049 * Notes wrt boundary cases: 1050 * This function sets the OCR bits for all boundary voltages, for example 1051 * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 | 1052 * MMC_VDD_34_35 mask. 1053 */ 1054 u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max) 1055 { 1056 u32 mask = 0; 1057 1058 if (vdd_max < vdd_min) 1059 return 0; 1060 1061 /* Prefer high bits for the boundary vdd_max values. */ 1062 vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false); 1063 if (vdd_max < 0) 1064 return 0; 1065 1066 /* Prefer low bits for the boundary vdd_min values. */ 1067 vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true); 1068 if (vdd_min < 0) 1069 return 0; 1070 1071 /* Fill the mask, from max bit to min bit. */ 1072 while (vdd_max >= vdd_min) 1073 mask |= 1 << vdd_max--; 1074 1075 return mask; 1076 } 1077 1078 static int mmc_of_get_func_num(struct device_node *node) 1079 { 1080 u32 reg; 1081 int ret; 1082 1083 ret = of_property_read_u32(node, "reg", ®); 1084 if (ret < 0) 1085 return ret; 1086 1087 return reg; 1088 } 1089 1090 struct device_node *mmc_of_find_child_device(struct mmc_host *host, 1091 unsigned func_num) 1092 { 1093 struct device_node *node; 1094 1095 if (!host->parent || !host->parent->of_node) 1096 return NULL; 1097 1098 for_each_child_of_node(host->parent->of_node, node) { 1099 if (mmc_of_get_func_num(node) == func_num) 1100 return node; 1101 } 1102 1103 return NULL; 1104 } 1105 1106 /* 1107 * Mask off any voltages we don't support and select 1108 * the lowest voltage 1109 */ 1110 u32 mmc_select_voltage(struct mmc_host *host, u32 ocr) 1111 { 1112 int bit; 1113 1114 /* 1115 * Sanity check the voltages that the card claims to 1116 * support. 1117 */ 1118 if (ocr & 0x7F) { 1119 dev_warn(mmc_dev(host), 1120 "card claims to support voltages below defined range\n"); 1121 ocr &= ~0x7F; 1122 } 1123 1124 ocr &= host->ocr_avail; 1125 if (!ocr) { 1126 dev_warn(mmc_dev(host), "no support for card's volts\n"); 1127 return 0; 1128 } 1129 1130 if (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) { 1131 bit = ffs(ocr) - 1; 1132 ocr &= 3 << bit; 1133 mmc_power_cycle(host, ocr); 1134 } else { 1135 bit = fls(ocr) - 1; 1136 /* 1137 * The bit variable represents the highest voltage bit set in 1138 * the OCR register. 1139 * To keep a range of 2 values (e.g. 3.2V/3.3V and 3.3V/3.4V), 1140 * we must shift the mask '3' with (bit - 1). 1141 */ 1142 ocr &= 3 << (bit - 1); 1143 if (bit != host->ios.vdd) 1144 dev_warn(mmc_dev(host), "exceeding card's volts\n"); 1145 } 1146 1147 return ocr; 1148 } 1149 1150 int mmc_set_signal_voltage(struct mmc_host *host, int signal_voltage) 1151 { 1152 int err = 0; 1153 int old_signal_voltage = host->ios.signal_voltage; 1154 1155 host->ios.signal_voltage = signal_voltage; 1156 if (host->ops->start_signal_voltage_switch) 1157 err = host->ops->start_signal_voltage_switch(host, &host->ios); 1158 1159 if (err) 1160 host->ios.signal_voltage = old_signal_voltage; 1161 1162 return err; 1163 1164 } 1165 1166 void mmc_set_initial_signal_voltage(struct mmc_host *host) 1167 { 1168 /* Try to set signal voltage to 3.3V but fall back to 1.8v or 1.2v */ 1169 if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330)) 1170 dev_dbg(mmc_dev(host), "Initial signal voltage of 3.3v\n"); 1171 else if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180)) 1172 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.8v\n"); 1173 else if (!mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120)) 1174 dev_dbg(mmc_dev(host), "Initial signal voltage of 1.2v\n"); 1175 } 1176 1177 int mmc_host_set_uhs_voltage(struct mmc_host *host) 1178 { 1179 u32 clock; 1180 1181 /* 1182 * During a signal voltage level switch, the clock must be gated 1183 * for 5 ms according to the SD spec 1184 */ 1185 clock = host->ios.clock; 1186 host->ios.clock = 0; 1187 mmc_set_ios(host); 1188 1189 if (mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180)) 1190 return -EAGAIN; 1191 1192 /* Keep clock gated for at least 10 ms, though spec only says 5 ms */ 1193 mmc_delay(10); 1194 host->ios.clock = clock; 1195 mmc_set_ios(host); 1196 1197 return 0; 1198 } 1199 1200 int mmc_set_uhs_voltage(struct mmc_host *host, u32 ocr) 1201 { 1202 struct mmc_command cmd = {}; 1203 int err = 0; 1204 1205 /* 1206 * If we cannot switch voltages, return failure so the caller 1207 * can continue without UHS mode 1208 */ 1209 if (!host->ops->start_signal_voltage_switch) 1210 return -EPERM; 1211 if (!host->ops->card_busy) 1212 pr_warn("%s: cannot verify signal voltage switch\n", 1213 mmc_hostname(host)); 1214 1215 cmd.opcode = SD_SWITCH_VOLTAGE; 1216 cmd.arg = 0; 1217 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1218 1219 err = mmc_wait_for_cmd(host, &cmd, 0); 1220 if (err) 1221 goto power_cycle; 1222 1223 if (!mmc_host_is_spi(host) && (cmd.resp[0] & R1_ERROR)) 1224 return -EIO; 1225 1226 /* 1227 * The card should drive cmd and dat[0:3] low immediately 1228 * after the response of cmd11, but wait 1 ms to be sure 1229 */ 1230 mmc_delay(1); 1231 if (host->ops->card_busy && !host->ops->card_busy(host)) { 1232 err = -EAGAIN; 1233 goto power_cycle; 1234 } 1235 1236 if (mmc_host_set_uhs_voltage(host)) { 1237 /* 1238 * Voltages may not have been switched, but we've already 1239 * sent CMD11, so a power cycle is required anyway 1240 */ 1241 err = -EAGAIN; 1242 goto power_cycle; 1243 } 1244 1245 /* Wait for at least 1 ms according to spec */ 1246 mmc_delay(1); 1247 1248 /* 1249 * Failure to switch is indicated by the card holding 1250 * dat[0:3] low 1251 */ 1252 if (host->ops->card_busy && host->ops->card_busy(host)) 1253 err = -EAGAIN; 1254 1255 power_cycle: 1256 if (err) { 1257 pr_debug("%s: Signal voltage switch failed, " 1258 "power cycling card\n", mmc_hostname(host)); 1259 mmc_power_cycle(host, ocr); 1260 } 1261 1262 return err; 1263 } 1264 1265 /* 1266 * Select timing parameters for host. 1267 */ 1268 void mmc_set_timing(struct mmc_host *host, unsigned int timing) 1269 { 1270 host->ios.timing = timing; 1271 mmc_set_ios(host); 1272 } 1273 1274 /* 1275 * Select appropriate driver type for host. 1276 */ 1277 void mmc_set_driver_type(struct mmc_host *host, unsigned int drv_type) 1278 { 1279 host->ios.drv_type = drv_type; 1280 mmc_set_ios(host); 1281 } 1282 1283 int mmc_select_drive_strength(struct mmc_card *card, unsigned int max_dtr, 1284 int card_drv_type, int *drv_type) 1285 { 1286 struct mmc_host *host = card->host; 1287 int host_drv_type = SD_DRIVER_TYPE_B; 1288 1289 *drv_type = 0; 1290 1291 if (!host->ops->select_drive_strength) 1292 return 0; 1293 1294 /* Use SD definition of driver strength for hosts */ 1295 if (host->caps & MMC_CAP_DRIVER_TYPE_A) 1296 host_drv_type |= SD_DRIVER_TYPE_A; 1297 1298 if (host->caps & MMC_CAP_DRIVER_TYPE_C) 1299 host_drv_type |= SD_DRIVER_TYPE_C; 1300 1301 if (host->caps & MMC_CAP_DRIVER_TYPE_D) 1302 host_drv_type |= SD_DRIVER_TYPE_D; 1303 1304 /* 1305 * The drive strength that the hardware can support 1306 * depends on the board design. Pass the appropriate 1307 * information and let the hardware specific code 1308 * return what is possible given the options 1309 */ 1310 return host->ops->select_drive_strength(card, max_dtr, 1311 host_drv_type, 1312 card_drv_type, 1313 drv_type); 1314 } 1315 1316 /* 1317 * Apply power to the MMC stack. This is a two-stage process. 1318 * First, we enable power to the card without the clock running. 1319 * We then wait a bit for the power to stabilise. Finally, 1320 * enable the bus drivers and clock to the card. 1321 * 1322 * We must _NOT_ enable the clock prior to power stablising. 1323 * 1324 * If a host does all the power sequencing itself, ignore the 1325 * initial MMC_POWER_UP stage. 1326 */ 1327 void mmc_power_up(struct mmc_host *host, u32 ocr) 1328 { 1329 if (host->ios.power_mode == MMC_POWER_ON) 1330 return; 1331 1332 mmc_pwrseq_pre_power_on(host); 1333 1334 host->ios.vdd = fls(ocr) - 1; 1335 host->ios.power_mode = MMC_POWER_UP; 1336 /* Set initial state and call mmc_set_ios */ 1337 mmc_set_initial_state(host); 1338 1339 mmc_set_initial_signal_voltage(host); 1340 1341 /* 1342 * This delay should be sufficient to allow the power supply 1343 * to reach the minimum voltage. 1344 */ 1345 mmc_delay(host->ios.power_delay_ms); 1346 1347 mmc_pwrseq_post_power_on(host); 1348 1349 host->ios.clock = host->f_init; 1350 1351 host->ios.power_mode = MMC_POWER_ON; 1352 mmc_set_ios(host); 1353 1354 /* 1355 * This delay must be at least 74 clock sizes, or 1 ms, or the 1356 * time required to reach a stable voltage. 1357 */ 1358 mmc_delay(host->ios.power_delay_ms); 1359 } 1360 1361 void mmc_power_off(struct mmc_host *host) 1362 { 1363 if (host->ios.power_mode == MMC_POWER_OFF) 1364 return; 1365 1366 mmc_pwrseq_power_off(host); 1367 1368 host->ios.clock = 0; 1369 host->ios.vdd = 0; 1370 1371 host->ios.power_mode = MMC_POWER_OFF; 1372 /* Set initial state and call mmc_set_ios */ 1373 mmc_set_initial_state(host); 1374 1375 /* 1376 * Some configurations, such as the 802.11 SDIO card in the OLPC 1377 * XO-1.5, require a short delay after poweroff before the card 1378 * can be successfully turned on again. 1379 */ 1380 mmc_delay(1); 1381 } 1382 1383 void mmc_power_cycle(struct mmc_host *host, u32 ocr) 1384 { 1385 mmc_power_off(host); 1386 /* Wait at least 1 ms according to SD spec */ 1387 mmc_delay(1); 1388 mmc_power_up(host, ocr); 1389 } 1390 1391 /* 1392 * Assign a mmc bus handler to a host. Only one bus handler may control a 1393 * host at any given time. 1394 */ 1395 void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops) 1396 { 1397 host->bus_ops = ops; 1398 } 1399 1400 /* 1401 * Remove the current bus handler from a host. 1402 */ 1403 void mmc_detach_bus(struct mmc_host *host) 1404 { 1405 host->bus_ops = NULL; 1406 } 1407 1408 void _mmc_detect_change(struct mmc_host *host, unsigned long delay, bool cd_irq) 1409 { 1410 /* 1411 * Prevent system sleep for 5s to allow user space to consume the 1412 * corresponding uevent. This is especially useful, when CD irq is used 1413 * as a system wakeup, but doesn't hurt in other cases. 1414 */ 1415 if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL)) 1416 __pm_wakeup_event(host->ws, 5000); 1417 1418 host->detect_change = 1; 1419 mmc_schedule_delayed_work(&host->detect, delay); 1420 } 1421 1422 /** 1423 * mmc_detect_change - process change of state on a MMC socket 1424 * @host: host which changed state. 1425 * @delay: optional delay to wait before detection (jiffies) 1426 * 1427 * MMC drivers should call this when they detect a card has been 1428 * inserted or removed. The MMC layer will confirm that any 1429 * present card is still functional, and initialize any newly 1430 * inserted. 1431 */ 1432 void mmc_detect_change(struct mmc_host *host, unsigned long delay) 1433 { 1434 _mmc_detect_change(host, delay, true); 1435 } 1436 EXPORT_SYMBOL(mmc_detect_change); 1437 1438 void mmc_init_erase(struct mmc_card *card) 1439 { 1440 unsigned int sz; 1441 1442 if (is_power_of_2(card->erase_size)) 1443 card->erase_shift = ffs(card->erase_size) - 1; 1444 else 1445 card->erase_shift = 0; 1446 1447 /* 1448 * It is possible to erase an arbitrarily large area of an SD or MMC 1449 * card. That is not desirable because it can take a long time 1450 * (minutes) potentially delaying more important I/O, and also the 1451 * timeout calculations become increasingly hugely over-estimated. 1452 * Consequently, 'pref_erase' is defined as a guide to limit erases 1453 * to that size and alignment. 1454 * 1455 * For SD cards that define Allocation Unit size, limit erases to one 1456 * Allocation Unit at a time. 1457 * For MMC, have a stab at ai good value and for modern cards it will 1458 * end up being 4MiB. Note that if the value is too small, it can end 1459 * up taking longer to erase. Also note, erase_size is already set to 1460 * High Capacity Erase Size if available when this function is called. 1461 */ 1462 if (mmc_card_sd(card) && card->ssr.au) { 1463 card->pref_erase = card->ssr.au; 1464 card->erase_shift = ffs(card->ssr.au) - 1; 1465 } else if (card->erase_size) { 1466 sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11; 1467 if (sz < 128) 1468 card->pref_erase = 512 * 1024 / 512; 1469 else if (sz < 512) 1470 card->pref_erase = 1024 * 1024 / 512; 1471 else if (sz < 1024) 1472 card->pref_erase = 2 * 1024 * 1024 / 512; 1473 else 1474 card->pref_erase = 4 * 1024 * 1024 / 512; 1475 if (card->pref_erase < card->erase_size) 1476 card->pref_erase = card->erase_size; 1477 else { 1478 sz = card->pref_erase % card->erase_size; 1479 if (sz) 1480 card->pref_erase += card->erase_size - sz; 1481 } 1482 } else 1483 card->pref_erase = 0; 1484 } 1485 1486 static bool is_trim_arg(unsigned int arg) 1487 { 1488 return (arg & MMC_TRIM_OR_DISCARD_ARGS) && arg != MMC_DISCARD_ARG; 1489 } 1490 1491 static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card, 1492 unsigned int arg, unsigned int qty) 1493 { 1494 unsigned int erase_timeout; 1495 1496 if (arg == MMC_DISCARD_ARG || 1497 (arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) { 1498 erase_timeout = card->ext_csd.trim_timeout; 1499 } else if (card->ext_csd.erase_group_def & 1) { 1500 /* High Capacity Erase Group Size uses HC timeouts */ 1501 if (arg == MMC_TRIM_ARG) 1502 erase_timeout = card->ext_csd.trim_timeout; 1503 else 1504 erase_timeout = card->ext_csd.hc_erase_timeout; 1505 } else { 1506 /* CSD Erase Group Size uses write timeout */ 1507 unsigned int mult = (10 << card->csd.r2w_factor); 1508 unsigned int timeout_clks = card->csd.taac_clks * mult; 1509 unsigned int timeout_us; 1510 1511 /* Avoid overflow: e.g. taac_ns=80000000 mult=1280 */ 1512 if (card->csd.taac_ns < 1000000) 1513 timeout_us = (card->csd.taac_ns * mult) / 1000; 1514 else 1515 timeout_us = (card->csd.taac_ns / 1000) * mult; 1516 1517 /* 1518 * ios.clock is only a target. The real clock rate might be 1519 * less but not that much less, so fudge it by multiplying by 2. 1520 */ 1521 timeout_clks <<= 1; 1522 timeout_us += (timeout_clks * 1000) / 1523 (card->host->ios.clock / 1000); 1524 1525 erase_timeout = timeout_us / 1000; 1526 1527 /* 1528 * Theoretically, the calculation could underflow so round up 1529 * to 1ms in that case. 1530 */ 1531 if (!erase_timeout) 1532 erase_timeout = 1; 1533 } 1534 1535 /* Multiplier for secure operations */ 1536 if (arg & MMC_SECURE_ARGS) { 1537 if (arg == MMC_SECURE_ERASE_ARG) 1538 erase_timeout *= card->ext_csd.sec_erase_mult; 1539 else 1540 erase_timeout *= card->ext_csd.sec_trim_mult; 1541 } 1542 1543 erase_timeout *= qty; 1544 1545 /* 1546 * Ensure at least a 1 second timeout for SPI as per 1547 * 'mmc_set_data_timeout()' 1548 */ 1549 if (mmc_host_is_spi(card->host) && erase_timeout < 1000) 1550 erase_timeout = 1000; 1551 1552 return erase_timeout; 1553 } 1554 1555 static unsigned int mmc_sd_erase_timeout(struct mmc_card *card, 1556 unsigned int arg, 1557 unsigned int qty) 1558 { 1559 unsigned int erase_timeout; 1560 1561 /* for DISCARD none of the below calculation applies. 1562 * the busy timeout is 250msec per discard command. 1563 */ 1564 if (arg == SD_DISCARD_ARG) 1565 return SD_DISCARD_TIMEOUT_MS; 1566 1567 if (card->ssr.erase_timeout) { 1568 /* Erase timeout specified in SD Status Register (SSR) */ 1569 erase_timeout = card->ssr.erase_timeout * qty + 1570 card->ssr.erase_offset; 1571 } else { 1572 /* 1573 * Erase timeout not specified in SD Status Register (SSR) so 1574 * use 250ms per write block. 1575 */ 1576 erase_timeout = 250 * qty; 1577 } 1578 1579 /* Must not be less than 1 second */ 1580 if (erase_timeout < 1000) 1581 erase_timeout = 1000; 1582 1583 return erase_timeout; 1584 } 1585 1586 static unsigned int mmc_erase_timeout(struct mmc_card *card, 1587 unsigned int arg, 1588 unsigned int qty) 1589 { 1590 if (mmc_card_sd(card)) 1591 return mmc_sd_erase_timeout(card, arg, qty); 1592 else 1593 return mmc_mmc_erase_timeout(card, arg, qty); 1594 } 1595 1596 static int mmc_do_erase(struct mmc_card *card, unsigned int from, 1597 unsigned int to, unsigned int arg) 1598 { 1599 struct mmc_command cmd = {}; 1600 unsigned int qty = 0, busy_timeout = 0; 1601 bool use_r1b_resp; 1602 int err; 1603 1604 mmc_retune_hold(card->host); 1605 1606 /* 1607 * qty is used to calculate the erase timeout which depends on how many 1608 * erase groups (or allocation units in SD terminology) are affected. 1609 * We count erasing part of an erase group as one erase group. 1610 * For SD, the allocation units are always a power of 2. For MMC, the 1611 * erase group size is almost certainly also power of 2, but it does not 1612 * seem to insist on that in the JEDEC standard, so we fall back to 1613 * division in that case. SD may not specify an allocation unit size, 1614 * in which case the timeout is based on the number of write blocks. 1615 * 1616 * Note that the timeout for secure trim 2 will only be correct if the 1617 * number of erase groups specified is the same as the total of all 1618 * preceding secure trim 1 commands. Since the power may have been 1619 * lost since the secure trim 1 commands occurred, it is generally 1620 * impossible to calculate the secure trim 2 timeout correctly. 1621 */ 1622 if (card->erase_shift) 1623 qty += ((to >> card->erase_shift) - 1624 (from >> card->erase_shift)) + 1; 1625 else if (mmc_card_sd(card)) 1626 qty += to - from + 1; 1627 else 1628 qty += ((to / card->erase_size) - 1629 (from / card->erase_size)) + 1; 1630 1631 if (!mmc_card_blockaddr(card)) { 1632 from <<= 9; 1633 to <<= 9; 1634 } 1635 1636 if (mmc_card_sd(card)) 1637 cmd.opcode = SD_ERASE_WR_BLK_START; 1638 else 1639 cmd.opcode = MMC_ERASE_GROUP_START; 1640 cmd.arg = from; 1641 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1642 err = mmc_wait_for_cmd(card->host, &cmd, 0); 1643 if (err) { 1644 pr_err("mmc_erase: group start error %d, " 1645 "status %#x\n", err, cmd.resp[0]); 1646 err = -EIO; 1647 goto out; 1648 } 1649 1650 memset(&cmd, 0, sizeof(struct mmc_command)); 1651 if (mmc_card_sd(card)) 1652 cmd.opcode = SD_ERASE_WR_BLK_END; 1653 else 1654 cmd.opcode = MMC_ERASE_GROUP_END; 1655 cmd.arg = to; 1656 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1657 err = mmc_wait_for_cmd(card->host, &cmd, 0); 1658 if (err) { 1659 pr_err("mmc_erase: group end error %d, status %#x\n", 1660 err, cmd.resp[0]); 1661 err = -EIO; 1662 goto out; 1663 } 1664 1665 memset(&cmd, 0, sizeof(struct mmc_command)); 1666 cmd.opcode = MMC_ERASE; 1667 cmd.arg = arg; 1668 busy_timeout = mmc_erase_timeout(card, arg, qty); 1669 use_r1b_resp = mmc_prepare_busy_cmd(card->host, &cmd, busy_timeout); 1670 1671 err = mmc_wait_for_cmd(card->host, &cmd, 0); 1672 if (err) { 1673 pr_err("mmc_erase: erase error %d, status %#x\n", 1674 err, cmd.resp[0]); 1675 err = -EIO; 1676 goto out; 1677 } 1678 1679 if (mmc_host_is_spi(card->host)) 1680 goto out; 1681 1682 /* 1683 * In case of when R1B + MMC_CAP_WAIT_WHILE_BUSY is used, the polling 1684 * shall be avoided. 1685 */ 1686 if ((card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp) 1687 goto out; 1688 1689 /* Let's poll to find out when the erase operation completes. */ 1690 err = mmc_poll_for_busy(card, busy_timeout, false, MMC_BUSY_ERASE); 1691 1692 out: 1693 mmc_retune_release(card->host); 1694 return err; 1695 } 1696 1697 static unsigned int mmc_align_erase_size(struct mmc_card *card, 1698 unsigned int *from, 1699 unsigned int *to, 1700 unsigned int nr) 1701 { 1702 unsigned int from_new = *from, nr_new = nr, rem; 1703 1704 /* 1705 * When the 'card->erase_size' is power of 2, we can use round_up/down() 1706 * to align the erase size efficiently. 1707 */ 1708 if (is_power_of_2(card->erase_size)) { 1709 unsigned int temp = from_new; 1710 1711 from_new = round_up(temp, card->erase_size); 1712 rem = from_new - temp; 1713 1714 if (nr_new > rem) 1715 nr_new -= rem; 1716 else 1717 return 0; 1718 1719 nr_new = round_down(nr_new, card->erase_size); 1720 } else { 1721 rem = from_new % card->erase_size; 1722 if (rem) { 1723 rem = card->erase_size - rem; 1724 from_new += rem; 1725 if (nr_new > rem) 1726 nr_new -= rem; 1727 else 1728 return 0; 1729 } 1730 1731 rem = nr_new % card->erase_size; 1732 if (rem) 1733 nr_new -= rem; 1734 } 1735 1736 if (nr_new == 0) 1737 return 0; 1738 1739 *to = from_new + nr_new; 1740 *from = from_new; 1741 1742 return nr_new; 1743 } 1744 1745 /** 1746 * mmc_erase - erase sectors. 1747 * @card: card to erase 1748 * @from: first sector to erase 1749 * @nr: number of sectors to erase 1750 * @arg: erase command argument 1751 * 1752 * Caller must claim host before calling this function. 1753 */ 1754 int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr, 1755 unsigned int arg) 1756 { 1757 unsigned int rem, to = from + nr; 1758 int err; 1759 1760 if (!(card->csd.cmdclass & CCC_ERASE)) 1761 return -EOPNOTSUPP; 1762 1763 if (!card->erase_size) 1764 return -EOPNOTSUPP; 1765 1766 if (mmc_card_sd(card) && arg != SD_ERASE_ARG && arg != SD_DISCARD_ARG) 1767 return -EOPNOTSUPP; 1768 1769 if (mmc_card_mmc(card) && (arg & MMC_SECURE_ARGS) && 1770 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)) 1771 return -EOPNOTSUPP; 1772 1773 if (mmc_card_mmc(card) && is_trim_arg(arg) && 1774 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)) 1775 return -EOPNOTSUPP; 1776 1777 if (arg == MMC_SECURE_ERASE_ARG) { 1778 if (from % card->erase_size || nr % card->erase_size) 1779 return -EINVAL; 1780 } 1781 1782 if (arg == MMC_ERASE_ARG) 1783 nr = mmc_align_erase_size(card, &from, &to, nr); 1784 1785 if (nr == 0) 1786 return 0; 1787 1788 if (to <= from) 1789 return -EINVAL; 1790 1791 /* 'from' and 'to' are inclusive */ 1792 to -= 1; 1793 1794 /* 1795 * Special case where only one erase-group fits in the timeout budget: 1796 * If the region crosses an erase-group boundary on this particular 1797 * case, we will be trimming more than one erase-group which, does not 1798 * fit in the timeout budget of the controller, so we need to split it 1799 * and call mmc_do_erase() twice if necessary. This special case is 1800 * identified by the card->eg_boundary flag. 1801 */ 1802 rem = card->erase_size - (from % card->erase_size); 1803 if ((arg & MMC_TRIM_OR_DISCARD_ARGS) && card->eg_boundary && nr > rem) { 1804 err = mmc_do_erase(card, from, from + rem - 1, arg); 1805 from += rem; 1806 if ((err) || (to <= from)) 1807 return err; 1808 } 1809 1810 return mmc_do_erase(card, from, to, arg); 1811 } 1812 EXPORT_SYMBOL(mmc_erase); 1813 1814 int mmc_can_erase(struct mmc_card *card) 1815 { 1816 if (card->csd.cmdclass & CCC_ERASE && card->erase_size) 1817 return 1; 1818 return 0; 1819 } 1820 EXPORT_SYMBOL(mmc_can_erase); 1821 1822 int mmc_can_trim(struct mmc_card *card) 1823 { 1824 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN) && 1825 (!(card->quirks & MMC_QUIRK_TRIM_BROKEN))) 1826 return 1; 1827 return 0; 1828 } 1829 EXPORT_SYMBOL(mmc_can_trim); 1830 1831 int mmc_can_discard(struct mmc_card *card) 1832 { 1833 /* 1834 * As there's no way to detect the discard support bit at v4.5 1835 * use the s/w feature support filed. 1836 */ 1837 if (card->ext_csd.feature_support & MMC_DISCARD_FEATURE) 1838 return 1; 1839 return 0; 1840 } 1841 EXPORT_SYMBOL(mmc_can_discard); 1842 1843 int mmc_can_sanitize(struct mmc_card *card) 1844 { 1845 if (!mmc_can_trim(card) && !mmc_can_erase(card)) 1846 return 0; 1847 if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE) 1848 return 1; 1849 return 0; 1850 } 1851 1852 int mmc_can_secure_erase_trim(struct mmc_card *card) 1853 { 1854 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN) && 1855 !(card->quirks & MMC_QUIRK_SEC_ERASE_TRIM_BROKEN)) 1856 return 1; 1857 return 0; 1858 } 1859 EXPORT_SYMBOL(mmc_can_secure_erase_trim); 1860 1861 int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from, 1862 unsigned int nr) 1863 { 1864 if (!card->erase_size) 1865 return 0; 1866 if (from % card->erase_size || nr % card->erase_size) 1867 return 0; 1868 return 1; 1869 } 1870 EXPORT_SYMBOL(mmc_erase_group_aligned); 1871 1872 static unsigned int mmc_do_calc_max_discard(struct mmc_card *card, 1873 unsigned int arg) 1874 { 1875 struct mmc_host *host = card->host; 1876 unsigned int max_discard, x, y, qty = 0, max_qty, min_qty, timeout; 1877 unsigned int last_timeout = 0; 1878 unsigned int max_busy_timeout = host->max_busy_timeout ? 1879 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS; 1880 1881 if (card->erase_shift) { 1882 max_qty = UINT_MAX >> card->erase_shift; 1883 min_qty = card->pref_erase >> card->erase_shift; 1884 } else if (mmc_card_sd(card)) { 1885 max_qty = UINT_MAX; 1886 min_qty = card->pref_erase; 1887 } else { 1888 max_qty = UINT_MAX / card->erase_size; 1889 min_qty = card->pref_erase / card->erase_size; 1890 } 1891 1892 /* 1893 * We should not only use 'host->max_busy_timeout' as the limitation 1894 * when deciding the max discard sectors. We should set a balance value 1895 * to improve the erase speed, and it can not get too long timeout at 1896 * the same time. 1897 * 1898 * Here we set 'card->pref_erase' as the minimal discard sectors no 1899 * matter what size of 'host->max_busy_timeout', but if the 1900 * 'host->max_busy_timeout' is large enough for more discard sectors, 1901 * then we can continue to increase the max discard sectors until we 1902 * get a balance value. In cases when the 'host->max_busy_timeout' 1903 * isn't specified, use the default max erase timeout. 1904 */ 1905 do { 1906 y = 0; 1907 for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) { 1908 timeout = mmc_erase_timeout(card, arg, qty + x); 1909 1910 if (qty + x > min_qty && timeout > max_busy_timeout) 1911 break; 1912 1913 if (timeout < last_timeout) 1914 break; 1915 last_timeout = timeout; 1916 y = x; 1917 } 1918 qty += y; 1919 } while (y); 1920 1921 if (!qty) 1922 return 0; 1923 1924 /* 1925 * When specifying a sector range to trim, chances are we might cross 1926 * an erase-group boundary even if the amount of sectors is less than 1927 * one erase-group. 1928 * If we can only fit one erase-group in the controller timeout budget, 1929 * we have to care that erase-group boundaries are not crossed by a 1930 * single trim operation. We flag that special case with "eg_boundary". 1931 * In all other cases we can just decrement qty and pretend that we 1932 * always touch (qty + 1) erase-groups as a simple optimization. 1933 */ 1934 if (qty == 1) 1935 card->eg_boundary = 1; 1936 else 1937 qty--; 1938 1939 /* Convert qty to sectors */ 1940 if (card->erase_shift) 1941 max_discard = qty << card->erase_shift; 1942 else if (mmc_card_sd(card)) 1943 max_discard = qty + 1; 1944 else 1945 max_discard = qty * card->erase_size; 1946 1947 return max_discard; 1948 } 1949 1950 unsigned int mmc_calc_max_discard(struct mmc_card *card) 1951 { 1952 struct mmc_host *host = card->host; 1953 unsigned int max_discard, max_trim; 1954 1955 /* 1956 * Without erase_group_def set, MMC erase timeout depends on clock 1957 * frequence which can change. In that case, the best choice is 1958 * just the preferred erase size. 1959 */ 1960 if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1)) 1961 return card->pref_erase; 1962 1963 max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG); 1964 if (mmc_can_trim(card)) { 1965 max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG); 1966 if (max_trim < max_discard || max_discard == 0) 1967 max_discard = max_trim; 1968 } else if (max_discard < card->erase_size) { 1969 max_discard = 0; 1970 } 1971 pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n", 1972 mmc_hostname(host), max_discard, host->max_busy_timeout ? 1973 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS); 1974 return max_discard; 1975 } 1976 EXPORT_SYMBOL(mmc_calc_max_discard); 1977 1978 bool mmc_card_is_blockaddr(struct mmc_card *card) 1979 { 1980 return card ? mmc_card_blockaddr(card) : false; 1981 } 1982 EXPORT_SYMBOL(mmc_card_is_blockaddr); 1983 1984 int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen) 1985 { 1986 struct mmc_command cmd = {}; 1987 1988 if (mmc_card_blockaddr(card) || mmc_card_ddr52(card) || 1989 mmc_card_hs400(card) || mmc_card_hs400es(card)) 1990 return 0; 1991 1992 cmd.opcode = MMC_SET_BLOCKLEN; 1993 cmd.arg = blocklen; 1994 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1995 return mmc_wait_for_cmd(card->host, &cmd, 5); 1996 } 1997 EXPORT_SYMBOL(mmc_set_blocklen); 1998 1999 static void mmc_hw_reset_for_init(struct mmc_host *host) 2000 { 2001 mmc_pwrseq_reset(host); 2002 2003 if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->card_hw_reset) 2004 return; 2005 host->ops->card_hw_reset(host); 2006 } 2007 2008 /** 2009 * mmc_hw_reset - reset the card in hardware 2010 * @card: card to be reset 2011 * 2012 * Hard reset the card. This function is only for upper layers, like the 2013 * block layer or card drivers. You cannot use it in host drivers (struct 2014 * mmc_card might be gone then). 2015 * 2016 * Return: 0 on success, -errno on failure 2017 */ 2018 int mmc_hw_reset(struct mmc_card *card) 2019 { 2020 struct mmc_host *host = card->host; 2021 int ret; 2022 2023 ret = host->bus_ops->hw_reset(host); 2024 if (ret < 0) 2025 pr_warn("%s: tried to HW reset card, got error %d\n", 2026 mmc_hostname(host), ret); 2027 2028 return ret; 2029 } 2030 EXPORT_SYMBOL(mmc_hw_reset); 2031 2032 int mmc_sw_reset(struct mmc_card *card) 2033 { 2034 struct mmc_host *host = card->host; 2035 int ret; 2036 2037 if (!host->bus_ops->sw_reset) 2038 return -EOPNOTSUPP; 2039 2040 ret = host->bus_ops->sw_reset(host); 2041 if (ret) 2042 pr_warn("%s: tried to SW reset card, got error %d\n", 2043 mmc_hostname(host), ret); 2044 2045 return ret; 2046 } 2047 EXPORT_SYMBOL(mmc_sw_reset); 2048 2049 static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq) 2050 { 2051 host->f_init = freq; 2052 2053 pr_debug("%s: %s: trying to init card at %u Hz\n", 2054 mmc_hostname(host), __func__, host->f_init); 2055 2056 mmc_power_up(host, host->ocr_avail); 2057 2058 /* 2059 * Some eMMCs (with VCCQ always on) may not be reset after power up, so 2060 * do a hardware reset if possible. 2061 */ 2062 mmc_hw_reset_for_init(host); 2063 2064 /* 2065 * sdio_reset sends CMD52 to reset card. Since we do not know 2066 * if the card is being re-initialized, just send it. CMD52 2067 * should be ignored by SD/eMMC cards. 2068 * Skip it if we already know that we do not support SDIO commands 2069 */ 2070 if (!(host->caps2 & MMC_CAP2_NO_SDIO)) 2071 sdio_reset(host); 2072 2073 mmc_go_idle(host); 2074 2075 if (!(host->caps2 & MMC_CAP2_NO_SD)) { 2076 if (mmc_send_if_cond_pcie(host, host->ocr_avail)) 2077 goto out; 2078 if (mmc_card_sd_express(host)) 2079 return 0; 2080 } 2081 2082 /* Order's important: probe SDIO, then SD, then MMC */ 2083 if (!(host->caps2 & MMC_CAP2_NO_SDIO)) 2084 if (!mmc_attach_sdio(host)) 2085 return 0; 2086 2087 if (!(host->caps2 & MMC_CAP2_NO_SD)) 2088 if (!mmc_attach_sd(host)) 2089 return 0; 2090 2091 if (!(host->caps2 & MMC_CAP2_NO_MMC)) 2092 if (!mmc_attach_mmc(host)) 2093 return 0; 2094 2095 out: 2096 mmc_power_off(host); 2097 return -EIO; 2098 } 2099 2100 int _mmc_detect_card_removed(struct mmc_host *host) 2101 { 2102 int ret; 2103 2104 if (!host->card || mmc_card_removed(host->card)) 2105 return 1; 2106 2107 ret = host->bus_ops->alive(host); 2108 2109 /* 2110 * Card detect status and alive check may be out of sync if card is 2111 * removed slowly, when card detect switch changes while card/slot 2112 * pads are still contacted in hardware (refer to "SD Card Mechanical 2113 * Addendum, Appendix C: Card Detection Switch"). So reschedule a 2114 * detect work 200ms later for this case. 2115 */ 2116 if (!ret && host->ops->get_cd && !host->ops->get_cd(host)) { 2117 mmc_detect_change(host, msecs_to_jiffies(200)); 2118 pr_debug("%s: card removed too slowly\n", mmc_hostname(host)); 2119 } 2120 2121 if (ret) { 2122 mmc_card_set_removed(host->card); 2123 pr_debug("%s: card remove detected\n", mmc_hostname(host)); 2124 } 2125 2126 return ret; 2127 } 2128 2129 int mmc_detect_card_removed(struct mmc_host *host) 2130 { 2131 struct mmc_card *card = host->card; 2132 int ret; 2133 2134 WARN_ON(!host->claimed); 2135 2136 if (!card) 2137 return 1; 2138 2139 if (!mmc_card_is_removable(host)) 2140 return 0; 2141 2142 ret = mmc_card_removed(card); 2143 /* 2144 * The card will be considered unchanged unless we have been asked to 2145 * detect a change or host requires polling to provide card detection. 2146 */ 2147 if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL)) 2148 return ret; 2149 2150 host->detect_change = 0; 2151 if (!ret) { 2152 ret = _mmc_detect_card_removed(host); 2153 if (ret && (host->caps & MMC_CAP_NEEDS_POLL)) { 2154 /* 2155 * Schedule a detect work as soon as possible to let a 2156 * rescan handle the card removal. 2157 */ 2158 cancel_delayed_work(&host->detect); 2159 _mmc_detect_change(host, 0, false); 2160 } 2161 } 2162 2163 return ret; 2164 } 2165 EXPORT_SYMBOL(mmc_detect_card_removed); 2166 2167 int mmc_card_alternative_gpt_sector(struct mmc_card *card, sector_t *gpt_sector) 2168 { 2169 unsigned int boot_sectors_num; 2170 2171 if ((!(card->host->caps2 & MMC_CAP2_ALT_GPT_TEGRA))) 2172 return -EOPNOTSUPP; 2173 2174 /* filter out unrelated cards */ 2175 if (card->ext_csd.rev < 3 || 2176 !mmc_card_mmc(card) || 2177 !mmc_card_is_blockaddr(card) || 2178 mmc_card_is_removable(card->host)) 2179 return -ENOENT; 2180 2181 /* 2182 * eMMC storage has two special boot partitions in addition to the 2183 * main one. NVIDIA's bootloader linearizes eMMC boot0->boot1->main 2184 * accesses, this means that the partition table addresses are shifted 2185 * by the size of boot partitions. In accordance with the eMMC 2186 * specification, the boot partition size is calculated as follows: 2187 * 2188 * boot partition size = 128K byte x BOOT_SIZE_MULT 2189 * 2190 * Calculate number of sectors occupied by the both boot partitions. 2191 */ 2192 boot_sectors_num = card->ext_csd.raw_boot_mult * SZ_128K / 2193 SZ_512 * MMC_NUM_BOOT_PARTITION; 2194 2195 /* Defined by NVIDIA and used by Android devices. */ 2196 *gpt_sector = card->ext_csd.sectors - boot_sectors_num - 1; 2197 2198 return 0; 2199 } 2200 EXPORT_SYMBOL(mmc_card_alternative_gpt_sector); 2201 2202 void mmc_rescan(struct work_struct *work) 2203 { 2204 struct mmc_host *host = 2205 container_of(work, struct mmc_host, detect.work); 2206 int i; 2207 2208 if (host->rescan_disable) 2209 return; 2210 2211 /* If there is a non-removable card registered, only scan once */ 2212 if (!mmc_card_is_removable(host) && host->rescan_entered) 2213 return; 2214 host->rescan_entered = 1; 2215 2216 if (host->trigger_card_event && host->ops->card_event) { 2217 mmc_claim_host(host); 2218 host->ops->card_event(host); 2219 mmc_release_host(host); 2220 host->trigger_card_event = false; 2221 } 2222 2223 /* Verify a registered card to be functional, else remove it. */ 2224 if (host->bus_ops) 2225 host->bus_ops->detect(host); 2226 2227 host->detect_change = 0; 2228 2229 /* if there still is a card present, stop here */ 2230 if (host->bus_ops != NULL) 2231 goto out; 2232 2233 mmc_claim_host(host); 2234 if (mmc_card_is_removable(host) && host->ops->get_cd && 2235 host->ops->get_cd(host) == 0) { 2236 mmc_power_off(host); 2237 mmc_release_host(host); 2238 goto out; 2239 } 2240 2241 /* If an SD express card is present, then leave it as is. */ 2242 if (mmc_card_sd_express(host)) { 2243 mmc_release_host(host); 2244 goto out; 2245 } 2246 2247 for (i = 0; i < ARRAY_SIZE(freqs); i++) { 2248 unsigned int freq = freqs[i]; 2249 if (freq > host->f_max) { 2250 if (i + 1 < ARRAY_SIZE(freqs)) 2251 continue; 2252 freq = host->f_max; 2253 } 2254 if (!mmc_rescan_try_freq(host, max(freq, host->f_min))) 2255 break; 2256 if (freqs[i] <= host->f_min) 2257 break; 2258 } 2259 2260 /* A non-removable card should have been detected by now. */ 2261 if (!mmc_card_is_removable(host) && !host->bus_ops) 2262 pr_info("%s: Failed to initialize a non-removable card", 2263 mmc_hostname(host)); 2264 2265 /* 2266 * Ignore the command timeout errors observed during 2267 * the card init as those are excepted. 2268 */ 2269 host->err_stats[MMC_ERR_CMD_TIMEOUT] = 0; 2270 mmc_release_host(host); 2271 2272 out: 2273 if (host->caps & MMC_CAP_NEEDS_POLL) 2274 mmc_schedule_delayed_work(&host->detect, HZ); 2275 } 2276 2277 void mmc_start_host(struct mmc_host *host) 2278 { 2279 host->f_init = max(min(freqs[0], host->f_max), host->f_min); 2280 host->rescan_disable = 0; 2281 2282 if (!(host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)) { 2283 mmc_claim_host(host); 2284 mmc_power_up(host, host->ocr_avail); 2285 mmc_release_host(host); 2286 } 2287 2288 mmc_gpiod_request_cd_irq(host); 2289 _mmc_detect_change(host, 0, false); 2290 } 2291 2292 void __mmc_stop_host(struct mmc_host *host) 2293 { 2294 if (host->slot.cd_irq >= 0) { 2295 mmc_gpio_set_cd_wake(host, false); 2296 disable_irq(host->slot.cd_irq); 2297 } 2298 2299 host->rescan_disable = 1; 2300 cancel_delayed_work_sync(&host->detect); 2301 } 2302 2303 void mmc_stop_host(struct mmc_host *host) 2304 { 2305 __mmc_stop_host(host); 2306 2307 /* clear pm flags now and let card drivers set them as needed */ 2308 host->pm_flags = 0; 2309 2310 if (host->bus_ops) { 2311 /* Calling bus_ops->remove() with a claimed host can deadlock */ 2312 host->bus_ops->remove(host); 2313 mmc_claim_host(host); 2314 mmc_detach_bus(host); 2315 mmc_power_off(host); 2316 mmc_release_host(host); 2317 return; 2318 } 2319 2320 mmc_claim_host(host); 2321 mmc_power_off(host); 2322 mmc_release_host(host); 2323 } 2324 2325 static int __init mmc_init(void) 2326 { 2327 int ret; 2328 2329 ret = mmc_register_bus(); 2330 if (ret) 2331 return ret; 2332 2333 ret = mmc_register_host_class(); 2334 if (ret) 2335 goto unregister_bus; 2336 2337 ret = sdio_register_bus(); 2338 if (ret) 2339 goto unregister_host_class; 2340 2341 return 0; 2342 2343 unregister_host_class: 2344 mmc_unregister_host_class(); 2345 unregister_bus: 2346 mmc_unregister_bus(); 2347 return ret; 2348 } 2349 2350 static void __exit mmc_exit(void) 2351 { 2352 sdio_unregister_bus(); 2353 mmc_unregister_host_class(); 2354 mmc_unregister_bus(); 2355 } 2356 2357 subsys_initcall(mmc_init); 2358 module_exit(mmc_exit); 2359 2360 MODULE_LICENSE("GPL"); 2361