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