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