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