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