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 static void _mmc_detect_change(struct mmc_host *host, unsigned long delay, 1473 bool cd_irq) 1474 { 1475 /* 1476 * If the device is configured as wakeup, we prevent a new sleep for 1477 * 5 s to give provision for user space to consume the event. 1478 */ 1479 if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL) && 1480 device_can_wakeup(mmc_dev(host))) 1481 pm_wakeup_event(mmc_dev(host), 5000); 1482 1483 host->detect_change = 1; 1484 mmc_schedule_delayed_work(&host->detect, delay); 1485 } 1486 1487 /** 1488 * mmc_detect_change - process change of state on a MMC socket 1489 * @host: host which changed state. 1490 * @delay: optional delay to wait before detection (jiffies) 1491 * 1492 * MMC drivers should call this when they detect a card has been 1493 * inserted or removed. The MMC layer will confirm that any 1494 * present card is still functional, and initialize any newly 1495 * inserted. 1496 */ 1497 void mmc_detect_change(struct mmc_host *host, unsigned long delay) 1498 { 1499 _mmc_detect_change(host, delay, true); 1500 } 1501 EXPORT_SYMBOL(mmc_detect_change); 1502 1503 void mmc_init_erase(struct mmc_card *card) 1504 { 1505 unsigned int sz; 1506 1507 if (is_power_of_2(card->erase_size)) 1508 card->erase_shift = ffs(card->erase_size) - 1; 1509 else 1510 card->erase_shift = 0; 1511 1512 /* 1513 * It is possible to erase an arbitrarily large area of an SD or MMC 1514 * card. That is not desirable because it can take a long time 1515 * (minutes) potentially delaying more important I/O, and also the 1516 * timeout calculations become increasingly hugely over-estimated. 1517 * Consequently, 'pref_erase' is defined as a guide to limit erases 1518 * to that size and alignment. 1519 * 1520 * For SD cards that define Allocation Unit size, limit erases to one 1521 * Allocation Unit at a time. 1522 * For MMC, have a stab at ai good value and for modern cards it will 1523 * end up being 4MiB. Note that if the value is too small, it can end 1524 * up taking longer to erase. Also note, erase_size is already set to 1525 * High Capacity Erase Size if available when this function is called. 1526 */ 1527 if (mmc_card_sd(card) && card->ssr.au) { 1528 card->pref_erase = card->ssr.au; 1529 card->erase_shift = ffs(card->ssr.au) - 1; 1530 } else if (card->erase_size) { 1531 sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11; 1532 if (sz < 128) 1533 card->pref_erase = 512 * 1024 / 512; 1534 else if (sz < 512) 1535 card->pref_erase = 1024 * 1024 / 512; 1536 else if (sz < 1024) 1537 card->pref_erase = 2 * 1024 * 1024 / 512; 1538 else 1539 card->pref_erase = 4 * 1024 * 1024 / 512; 1540 if (card->pref_erase < card->erase_size) 1541 card->pref_erase = card->erase_size; 1542 else { 1543 sz = card->pref_erase % card->erase_size; 1544 if (sz) 1545 card->pref_erase += card->erase_size - sz; 1546 } 1547 } else 1548 card->pref_erase = 0; 1549 } 1550 1551 static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card, 1552 unsigned int arg, unsigned int qty) 1553 { 1554 unsigned int erase_timeout; 1555 1556 if (arg == MMC_DISCARD_ARG || 1557 (arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) { 1558 erase_timeout = card->ext_csd.trim_timeout; 1559 } else if (card->ext_csd.erase_group_def & 1) { 1560 /* High Capacity Erase Group Size uses HC timeouts */ 1561 if (arg == MMC_TRIM_ARG) 1562 erase_timeout = card->ext_csd.trim_timeout; 1563 else 1564 erase_timeout = card->ext_csd.hc_erase_timeout; 1565 } else { 1566 /* CSD Erase Group Size uses write timeout */ 1567 unsigned int mult = (10 << card->csd.r2w_factor); 1568 unsigned int timeout_clks = card->csd.taac_clks * mult; 1569 unsigned int timeout_us; 1570 1571 /* Avoid overflow: e.g. taac_ns=80000000 mult=1280 */ 1572 if (card->csd.taac_ns < 1000000) 1573 timeout_us = (card->csd.taac_ns * mult) / 1000; 1574 else 1575 timeout_us = (card->csd.taac_ns / 1000) * mult; 1576 1577 /* 1578 * ios.clock is only a target. The real clock rate might be 1579 * less but not that much less, so fudge it by multiplying by 2. 1580 */ 1581 timeout_clks <<= 1; 1582 timeout_us += (timeout_clks * 1000) / 1583 (card->host->ios.clock / 1000); 1584 1585 erase_timeout = timeout_us / 1000; 1586 1587 /* 1588 * Theoretically, the calculation could underflow so round up 1589 * to 1ms in that case. 1590 */ 1591 if (!erase_timeout) 1592 erase_timeout = 1; 1593 } 1594 1595 /* Multiplier for secure operations */ 1596 if (arg & MMC_SECURE_ARGS) { 1597 if (arg == MMC_SECURE_ERASE_ARG) 1598 erase_timeout *= card->ext_csd.sec_erase_mult; 1599 else 1600 erase_timeout *= card->ext_csd.sec_trim_mult; 1601 } 1602 1603 erase_timeout *= qty; 1604 1605 /* 1606 * Ensure at least a 1 second timeout for SPI as per 1607 * 'mmc_set_data_timeout()' 1608 */ 1609 if (mmc_host_is_spi(card->host) && erase_timeout < 1000) 1610 erase_timeout = 1000; 1611 1612 return erase_timeout; 1613 } 1614 1615 static unsigned int mmc_sd_erase_timeout(struct mmc_card *card, 1616 unsigned int arg, 1617 unsigned int qty) 1618 { 1619 unsigned int erase_timeout; 1620 1621 /* for DISCARD none of the below calculation applies. 1622 * the busy timeout is 250msec per discard command. 1623 */ 1624 if (arg == SD_DISCARD_ARG) 1625 return SD_DISCARD_TIMEOUT_MS; 1626 1627 if (card->ssr.erase_timeout) { 1628 /* Erase timeout specified in SD Status Register (SSR) */ 1629 erase_timeout = card->ssr.erase_timeout * qty + 1630 card->ssr.erase_offset; 1631 } else { 1632 /* 1633 * Erase timeout not specified in SD Status Register (SSR) so 1634 * use 250ms per write block. 1635 */ 1636 erase_timeout = 250 * qty; 1637 } 1638 1639 /* Must not be less than 1 second */ 1640 if (erase_timeout < 1000) 1641 erase_timeout = 1000; 1642 1643 return erase_timeout; 1644 } 1645 1646 static unsigned int mmc_erase_timeout(struct mmc_card *card, 1647 unsigned int arg, 1648 unsigned int qty) 1649 { 1650 if (mmc_card_sd(card)) 1651 return mmc_sd_erase_timeout(card, arg, qty); 1652 else 1653 return mmc_mmc_erase_timeout(card, arg, qty); 1654 } 1655 1656 static int mmc_do_erase(struct mmc_card *card, unsigned int from, 1657 unsigned int to, unsigned int arg) 1658 { 1659 struct mmc_command cmd = {}; 1660 unsigned int qty = 0, busy_timeout = 0; 1661 bool use_r1b_resp = false; 1662 unsigned long timeout; 1663 int loop_udelay=64, udelay_max=32768; 1664 int err; 1665 1666 mmc_retune_hold(card->host); 1667 1668 /* 1669 * qty is used to calculate the erase timeout which depends on how many 1670 * erase groups (or allocation units in SD terminology) are affected. 1671 * We count erasing part of an erase group as one erase group. 1672 * For SD, the allocation units are always a power of 2. For MMC, the 1673 * erase group size is almost certainly also power of 2, but it does not 1674 * seem to insist on that in the JEDEC standard, so we fall back to 1675 * division in that case. SD may not specify an allocation unit size, 1676 * in which case the timeout is based on the number of write blocks. 1677 * 1678 * Note that the timeout for secure trim 2 will only be correct if the 1679 * number of erase groups specified is the same as the total of all 1680 * preceding secure trim 1 commands. Since the power may have been 1681 * lost since the secure trim 1 commands occurred, it is generally 1682 * impossible to calculate the secure trim 2 timeout correctly. 1683 */ 1684 if (card->erase_shift) 1685 qty += ((to >> card->erase_shift) - 1686 (from >> card->erase_shift)) + 1; 1687 else if (mmc_card_sd(card)) 1688 qty += to - from + 1; 1689 else 1690 qty += ((to / card->erase_size) - 1691 (from / card->erase_size)) + 1; 1692 1693 if (!mmc_card_blockaddr(card)) { 1694 from <<= 9; 1695 to <<= 9; 1696 } 1697 1698 if (mmc_card_sd(card)) 1699 cmd.opcode = SD_ERASE_WR_BLK_START; 1700 else 1701 cmd.opcode = MMC_ERASE_GROUP_START; 1702 cmd.arg = from; 1703 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1704 err = mmc_wait_for_cmd(card->host, &cmd, 0); 1705 if (err) { 1706 pr_err("mmc_erase: group start error %d, " 1707 "status %#x\n", err, cmd.resp[0]); 1708 err = -EIO; 1709 goto out; 1710 } 1711 1712 memset(&cmd, 0, sizeof(struct mmc_command)); 1713 if (mmc_card_sd(card)) 1714 cmd.opcode = SD_ERASE_WR_BLK_END; 1715 else 1716 cmd.opcode = MMC_ERASE_GROUP_END; 1717 cmd.arg = to; 1718 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1719 err = mmc_wait_for_cmd(card->host, &cmd, 0); 1720 if (err) { 1721 pr_err("mmc_erase: group end error %d, status %#x\n", 1722 err, cmd.resp[0]); 1723 err = -EIO; 1724 goto out; 1725 } 1726 1727 memset(&cmd, 0, sizeof(struct mmc_command)); 1728 cmd.opcode = MMC_ERASE; 1729 cmd.arg = arg; 1730 busy_timeout = mmc_erase_timeout(card, arg, qty); 1731 /* 1732 * If the host controller supports busy signalling and the timeout for 1733 * the erase operation does not exceed the max_busy_timeout, we should 1734 * use R1B response. Or we need to prevent the host from doing hw busy 1735 * detection, which is done by converting to a R1 response instead. 1736 */ 1737 if (card->host->max_busy_timeout && 1738 busy_timeout > card->host->max_busy_timeout) { 1739 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 1740 } else { 1741 cmd.flags = MMC_RSP_SPI_R1B | MMC_RSP_R1B | MMC_CMD_AC; 1742 cmd.busy_timeout = busy_timeout; 1743 use_r1b_resp = true; 1744 } 1745 1746 err = mmc_wait_for_cmd(card->host, &cmd, 0); 1747 if (err) { 1748 pr_err("mmc_erase: erase error %d, status %#x\n", 1749 err, cmd.resp[0]); 1750 err = -EIO; 1751 goto out; 1752 } 1753 1754 if (mmc_host_is_spi(card->host)) 1755 goto out; 1756 1757 /* 1758 * In case of when R1B + MMC_CAP_WAIT_WHILE_BUSY is used, the polling 1759 * shall be avoided. 1760 */ 1761 if ((card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp) 1762 goto out; 1763 1764 timeout = jiffies + msecs_to_jiffies(busy_timeout); 1765 do { 1766 memset(&cmd, 0, sizeof(struct mmc_command)); 1767 cmd.opcode = MMC_SEND_STATUS; 1768 cmd.arg = card->rca << 16; 1769 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC; 1770 /* Do not retry else we can't see errors */ 1771 err = mmc_wait_for_cmd(card->host, &cmd, 0); 1772 if (err || R1_STATUS(cmd.resp[0])) { 1773 pr_err("error %d requesting status %#x\n", 1774 err, cmd.resp[0]); 1775 err = -EIO; 1776 goto out; 1777 } 1778 1779 /* Timeout if the device never becomes ready for data and 1780 * never leaves the program state. 1781 */ 1782 if (time_after(jiffies, timeout)) { 1783 pr_err("%s: Card stuck in programming state! %s\n", 1784 mmc_hostname(card->host), __func__); 1785 err = -EIO; 1786 goto out; 1787 } 1788 if ((cmd.resp[0] & R1_READY_FOR_DATA) && 1789 R1_CURRENT_STATE(cmd.resp[0]) != R1_STATE_PRG) 1790 break; 1791 1792 usleep_range(loop_udelay, loop_udelay*2); 1793 if (loop_udelay < udelay_max) 1794 loop_udelay *= 2; 1795 } while (1); 1796 1797 out: 1798 mmc_retune_release(card->host); 1799 return err; 1800 } 1801 1802 static unsigned int mmc_align_erase_size(struct mmc_card *card, 1803 unsigned int *from, 1804 unsigned int *to, 1805 unsigned int nr) 1806 { 1807 unsigned int from_new = *from, nr_new = nr, rem; 1808 1809 /* 1810 * When the 'card->erase_size' is power of 2, we can use round_up/down() 1811 * to align the erase size efficiently. 1812 */ 1813 if (is_power_of_2(card->erase_size)) { 1814 unsigned int temp = from_new; 1815 1816 from_new = round_up(temp, card->erase_size); 1817 rem = from_new - temp; 1818 1819 if (nr_new > rem) 1820 nr_new -= rem; 1821 else 1822 return 0; 1823 1824 nr_new = round_down(nr_new, card->erase_size); 1825 } else { 1826 rem = from_new % card->erase_size; 1827 if (rem) { 1828 rem = card->erase_size - rem; 1829 from_new += rem; 1830 if (nr_new > rem) 1831 nr_new -= rem; 1832 else 1833 return 0; 1834 } 1835 1836 rem = nr_new % card->erase_size; 1837 if (rem) 1838 nr_new -= rem; 1839 } 1840 1841 if (nr_new == 0) 1842 return 0; 1843 1844 *to = from_new + nr_new; 1845 *from = from_new; 1846 1847 return nr_new; 1848 } 1849 1850 /** 1851 * mmc_erase - erase sectors. 1852 * @card: card to erase 1853 * @from: first sector to erase 1854 * @nr: number of sectors to erase 1855 * @arg: erase command argument 1856 * 1857 * Caller must claim host before calling this function. 1858 */ 1859 int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr, 1860 unsigned int arg) 1861 { 1862 unsigned int rem, to = from + nr; 1863 int err; 1864 1865 if (!(card->host->caps & MMC_CAP_ERASE) || 1866 !(card->csd.cmdclass & CCC_ERASE)) 1867 return -EOPNOTSUPP; 1868 1869 if (!card->erase_size) 1870 return -EOPNOTSUPP; 1871 1872 if (mmc_card_sd(card) && arg != SD_ERASE_ARG && arg != SD_DISCARD_ARG) 1873 return -EOPNOTSUPP; 1874 1875 if (mmc_card_mmc(card) && (arg & MMC_SECURE_ARGS) && 1876 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN)) 1877 return -EOPNOTSUPP; 1878 1879 if (mmc_card_mmc(card) && (arg & MMC_TRIM_ARGS) && 1880 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN)) 1881 return -EOPNOTSUPP; 1882 1883 if (arg == MMC_SECURE_ERASE_ARG) { 1884 if (from % card->erase_size || nr % card->erase_size) 1885 return -EINVAL; 1886 } 1887 1888 if (arg == MMC_ERASE_ARG) 1889 nr = mmc_align_erase_size(card, &from, &to, nr); 1890 1891 if (nr == 0) 1892 return 0; 1893 1894 if (to <= from) 1895 return -EINVAL; 1896 1897 /* 'from' and 'to' are inclusive */ 1898 to -= 1; 1899 1900 /* 1901 * Special case where only one erase-group fits in the timeout budget: 1902 * If the region crosses an erase-group boundary on this particular 1903 * case, we will be trimming more than one erase-group which, does not 1904 * fit in the timeout budget of the controller, so we need to split it 1905 * and call mmc_do_erase() twice if necessary. This special case is 1906 * identified by the card->eg_boundary flag. 1907 */ 1908 rem = card->erase_size - (from % card->erase_size); 1909 if ((arg & MMC_TRIM_ARGS) && (card->eg_boundary) && (nr > rem)) { 1910 err = mmc_do_erase(card, from, from + rem - 1, arg); 1911 from += rem; 1912 if ((err) || (to <= from)) 1913 return err; 1914 } 1915 1916 return mmc_do_erase(card, from, to, arg); 1917 } 1918 EXPORT_SYMBOL(mmc_erase); 1919 1920 int mmc_can_erase(struct mmc_card *card) 1921 { 1922 if ((card->host->caps & MMC_CAP_ERASE) && 1923 (card->csd.cmdclass & CCC_ERASE) && card->erase_size) 1924 return 1; 1925 return 0; 1926 } 1927 EXPORT_SYMBOL(mmc_can_erase); 1928 1929 int mmc_can_trim(struct mmc_card *card) 1930 { 1931 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN) && 1932 (!(card->quirks & MMC_QUIRK_TRIM_BROKEN))) 1933 return 1; 1934 return 0; 1935 } 1936 EXPORT_SYMBOL(mmc_can_trim); 1937 1938 int mmc_can_discard(struct mmc_card *card) 1939 { 1940 /* 1941 * As there's no way to detect the discard support bit at v4.5 1942 * use the s/w feature support filed. 1943 */ 1944 if (card->ext_csd.feature_support & MMC_DISCARD_FEATURE) 1945 return 1; 1946 return 0; 1947 } 1948 EXPORT_SYMBOL(mmc_can_discard); 1949 1950 int mmc_can_sanitize(struct mmc_card *card) 1951 { 1952 if (!mmc_can_trim(card) && !mmc_can_erase(card)) 1953 return 0; 1954 if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE) 1955 return 1; 1956 return 0; 1957 } 1958 EXPORT_SYMBOL(mmc_can_sanitize); 1959 1960 int mmc_can_secure_erase_trim(struct mmc_card *card) 1961 { 1962 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN) && 1963 !(card->quirks & MMC_QUIRK_SEC_ERASE_TRIM_BROKEN)) 1964 return 1; 1965 return 0; 1966 } 1967 EXPORT_SYMBOL(mmc_can_secure_erase_trim); 1968 1969 int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from, 1970 unsigned int nr) 1971 { 1972 if (!card->erase_size) 1973 return 0; 1974 if (from % card->erase_size || nr % card->erase_size) 1975 return 0; 1976 return 1; 1977 } 1978 EXPORT_SYMBOL(mmc_erase_group_aligned); 1979 1980 static unsigned int mmc_do_calc_max_discard(struct mmc_card *card, 1981 unsigned int arg) 1982 { 1983 struct mmc_host *host = card->host; 1984 unsigned int max_discard, x, y, qty = 0, max_qty, min_qty, timeout; 1985 unsigned int last_timeout = 0; 1986 unsigned int max_busy_timeout = host->max_busy_timeout ? 1987 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS; 1988 1989 if (card->erase_shift) { 1990 max_qty = UINT_MAX >> card->erase_shift; 1991 min_qty = card->pref_erase >> card->erase_shift; 1992 } else if (mmc_card_sd(card)) { 1993 max_qty = UINT_MAX; 1994 min_qty = card->pref_erase; 1995 } else { 1996 max_qty = UINT_MAX / card->erase_size; 1997 min_qty = card->pref_erase / card->erase_size; 1998 } 1999 2000 /* 2001 * We should not only use 'host->max_busy_timeout' as the limitation 2002 * when deciding the max discard sectors. We should set a balance value 2003 * to improve the erase speed, and it can not get too long timeout at 2004 * the same time. 2005 * 2006 * Here we set 'card->pref_erase' as the minimal discard sectors no 2007 * matter what size of 'host->max_busy_timeout', but if the 2008 * 'host->max_busy_timeout' is large enough for more discard sectors, 2009 * then we can continue to increase the max discard sectors until we 2010 * get a balance value. In cases when the 'host->max_busy_timeout' 2011 * isn't specified, use the default max erase timeout. 2012 */ 2013 do { 2014 y = 0; 2015 for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) { 2016 timeout = mmc_erase_timeout(card, arg, qty + x); 2017 2018 if (qty + x > min_qty && timeout > max_busy_timeout) 2019 break; 2020 2021 if (timeout < last_timeout) 2022 break; 2023 last_timeout = timeout; 2024 y = x; 2025 } 2026 qty += y; 2027 } while (y); 2028 2029 if (!qty) 2030 return 0; 2031 2032 /* 2033 * When specifying a sector range to trim, chances are we might cross 2034 * an erase-group boundary even if the amount of sectors is less than 2035 * one erase-group. 2036 * If we can only fit one erase-group in the controller timeout budget, 2037 * we have to care that erase-group boundaries are not crossed by a 2038 * single trim operation. We flag that special case with "eg_boundary". 2039 * In all other cases we can just decrement qty and pretend that we 2040 * always touch (qty + 1) erase-groups as a simple optimization. 2041 */ 2042 if (qty == 1) 2043 card->eg_boundary = 1; 2044 else 2045 qty--; 2046 2047 /* Convert qty to sectors */ 2048 if (card->erase_shift) 2049 max_discard = qty << card->erase_shift; 2050 else if (mmc_card_sd(card)) 2051 max_discard = qty + 1; 2052 else 2053 max_discard = qty * card->erase_size; 2054 2055 return max_discard; 2056 } 2057 2058 unsigned int mmc_calc_max_discard(struct mmc_card *card) 2059 { 2060 struct mmc_host *host = card->host; 2061 unsigned int max_discard, max_trim; 2062 2063 /* 2064 * Without erase_group_def set, MMC erase timeout depends on clock 2065 * frequence which can change. In that case, the best choice is 2066 * just the preferred erase size. 2067 */ 2068 if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1)) 2069 return card->pref_erase; 2070 2071 max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG); 2072 if (mmc_can_trim(card)) { 2073 max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG); 2074 if (max_trim < max_discard || max_discard == 0) 2075 max_discard = max_trim; 2076 } else if (max_discard < card->erase_size) { 2077 max_discard = 0; 2078 } 2079 pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n", 2080 mmc_hostname(host), max_discard, host->max_busy_timeout ? 2081 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS); 2082 return max_discard; 2083 } 2084 EXPORT_SYMBOL(mmc_calc_max_discard); 2085 2086 bool mmc_card_is_blockaddr(struct mmc_card *card) 2087 { 2088 return card ? mmc_card_blockaddr(card) : false; 2089 } 2090 EXPORT_SYMBOL(mmc_card_is_blockaddr); 2091 2092 int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen) 2093 { 2094 struct mmc_command cmd = {}; 2095 2096 if (mmc_card_blockaddr(card) || mmc_card_ddr52(card) || 2097 mmc_card_hs400(card) || mmc_card_hs400es(card)) 2098 return 0; 2099 2100 cmd.opcode = MMC_SET_BLOCKLEN; 2101 cmd.arg = blocklen; 2102 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC; 2103 return mmc_wait_for_cmd(card->host, &cmd, 5); 2104 } 2105 EXPORT_SYMBOL(mmc_set_blocklen); 2106 2107 static void mmc_hw_reset_for_init(struct mmc_host *host) 2108 { 2109 mmc_pwrseq_reset(host); 2110 2111 if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->hw_reset) 2112 return; 2113 host->ops->hw_reset(host); 2114 } 2115 2116 int mmc_hw_reset(struct mmc_host *host) 2117 { 2118 int ret; 2119 2120 if (!host->card) 2121 return -EINVAL; 2122 2123 mmc_bus_get(host); 2124 if (!host->bus_ops || host->bus_dead || !host->bus_ops->hw_reset) { 2125 mmc_bus_put(host); 2126 return -EOPNOTSUPP; 2127 } 2128 2129 ret = host->bus_ops->hw_reset(host); 2130 mmc_bus_put(host); 2131 2132 if (ret) 2133 pr_warn("%s: tried to HW reset card, got error %d\n", 2134 mmc_hostname(host), ret); 2135 2136 return ret; 2137 } 2138 EXPORT_SYMBOL(mmc_hw_reset); 2139 2140 int mmc_sw_reset(struct mmc_host *host) 2141 { 2142 int ret; 2143 2144 if (!host->card) 2145 return -EINVAL; 2146 2147 mmc_bus_get(host); 2148 if (!host->bus_ops || host->bus_dead || !host->bus_ops->sw_reset) { 2149 mmc_bus_put(host); 2150 return -EOPNOTSUPP; 2151 } 2152 2153 ret = host->bus_ops->sw_reset(host); 2154 mmc_bus_put(host); 2155 2156 if (ret) 2157 pr_warn("%s: tried to SW reset card, got error %d\n", 2158 mmc_hostname(host), ret); 2159 2160 return ret; 2161 } 2162 EXPORT_SYMBOL(mmc_sw_reset); 2163 2164 static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq) 2165 { 2166 host->f_init = freq; 2167 2168 pr_debug("%s: %s: trying to init card at %u Hz\n", 2169 mmc_hostname(host), __func__, host->f_init); 2170 2171 mmc_power_up(host, host->ocr_avail); 2172 2173 /* 2174 * Some eMMCs (with VCCQ always on) may not be reset after power up, so 2175 * do a hardware reset if possible. 2176 */ 2177 mmc_hw_reset_for_init(host); 2178 2179 /* 2180 * sdio_reset sends CMD52 to reset card. Since we do not know 2181 * if the card is being re-initialized, just send it. CMD52 2182 * should be ignored by SD/eMMC cards. 2183 * Skip it if we already know that we do not support SDIO commands 2184 */ 2185 if (!(host->caps2 & MMC_CAP2_NO_SDIO)) 2186 sdio_reset(host); 2187 2188 mmc_go_idle(host); 2189 2190 if (!(host->caps2 & MMC_CAP2_NO_SD)) 2191 mmc_send_if_cond(host, host->ocr_avail); 2192 2193 /* Order's important: probe SDIO, then SD, then MMC */ 2194 if (!(host->caps2 & MMC_CAP2_NO_SDIO)) 2195 if (!mmc_attach_sdio(host)) 2196 return 0; 2197 2198 if (!(host->caps2 & MMC_CAP2_NO_SD)) 2199 if (!mmc_attach_sd(host)) 2200 return 0; 2201 2202 if (!(host->caps2 & MMC_CAP2_NO_MMC)) 2203 if (!mmc_attach_mmc(host)) 2204 return 0; 2205 2206 mmc_power_off(host); 2207 return -EIO; 2208 } 2209 2210 int _mmc_detect_card_removed(struct mmc_host *host) 2211 { 2212 int ret; 2213 2214 if (!host->card || mmc_card_removed(host->card)) 2215 return 1; 2216 2217 ret = host->bus_ops->alive(host); 2218 2219 /* 2220 * Card detect status and alive check may be out of sync if card is 2221 * removed slowly, when card detect switch changes while card/slot 2222 * pads are still contacted in hardware (refer to "SD Card Mechanical 2223 * Addendum, Appendix C: Card Detection Switch"). So reschedule a 2224 * detect work 200ms later for this case. 2225 */ 2226 if (!ret && host->ops->get_cd && !host->ops->get_cd(host)) { 2227 mmc_detect_change(host, msecs_to_jiffies(200)); 2228 pr_debug("%s: card removed too slowly\n", mmc_hostname(host)); 2229 } 2230 2231 if (ret) { 2232 mmc_card_set_removed(host->card); 2233 pr_debug("%s: card remove detected\n", mmc_hostname(host)); 2234 } 2235 2236 return ret; 2237 } 2238 2239 int mmc_detect_card_removed(struct mmc_host *host) 2240 { 2241 struct mmc_card *card = host->card; 2242 int ret; 2243 2244 WARN_ON(!host->claimed); 2245 2246 if (!card) 2247 return 1; 2248 2249 if (!mmc_card_is_removable(host)) 2250 return 0; 2251 2252 ret = mmc_card_removed(card); 2253 /* 2254 * The card will be considered unchanged unless we have been asked to 2255 * detect a change or host requires polling to provide card detection. 2256 */ 2257 if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL)) 2258 return ret; 2259 2260 host->detect_change = 0; 2261 if (!ret) { 2262 ret = _mmc_detect_card_removed(host); 2263 if (ret && (host->caps & MMC_CAP_NEEDS_POLL)) { 2264 /* 2265 * Schedule a detect work as soon as possible to let a 2266 * rescan handle the card removal. 2267 */ 2268 cancel_delayed_work(&host->detect); 2269 _mmc_detect_change(host, 0, false); 2270 } 2271 } 2272 2273 return ret; 2274 } 2275 EXPORT_SYMBOL(mmc_detect_card_removed); 2276 2277 void mmc_rescan(struct work_struct *work) 2278 { 2279 struct mmc_host *host = 2280 container_of(work, struct mmc_host, detect.work); 2281 int i; 2282 2283 if (host->rescan_disable) 2284 return; 2285 2286 /* If there is a non-removable card registered, only scan once */ 2287 if (!mmc_card_is_removable(host) && host->rescan_entered) 2288 return; 2289 host->rescan_entered = 1; 2290 2291 if (host->trigger_card_event && host->ops->card_event) { 2292 mmc_claim_host(host); 2293 host->ops->card_event(host); 2294 mmc_release_host(host); 2295 host->trigger_card_event = false; 2296 } 2297 2298 mmc_bus_get(host); 2299 2300 /* 2301 * if there is a _removable_ card registered, check whether it is 2302 * still present 2303 */ 2304 if (host->bus_ops && !host->bus_dead && mmc_card_is_removable(host)) 2305 host->bus_ops->detect(host); 2306 2307 host->detect_change = 0; 2308 2309 /* 2310 * Let mmc_bus_put() free the bus/bus_ops if we've found that 2311 * the card is no longer present. 2312 */ 2313 mmc_bus_put(host); 2314 mmc_bus_get(host); 2315 2316 /* if there still is a card present, stop here */ 2317 if (host->bus_ops != NULL) { 2318 mmc_bus_put(host); 2319 goto out; 2320 } 2321 2322 /* 2323 * Only we can add a new handler, so it's safe to 2324 * release the lock here. 2325 */ 2326 mmc_bus_put(host); 2327 2328 mmc_claim_host(host); 2329 if (mmc_card_is_removable(host) && host->ops->get_cd && 2330 host->ops->get_cd(host) == 0) { 2331 mmc_power_off(host); 2332 mmc_release_host(host); 2333 goto out; 2334 } 2335 2336 for (i = 0; i < ARRAY_SIZE(freqs); i++) { 2337 if (!mmc_rescan_try_freq(host, max(freqs[i], host->f_min))) 2338 break; 2339 if (freqs[i] <= host->f_min) 2340 break; 2341 } 2342 mmc_release_host(host); 2343 2344 out: 2345 if (host->caps & MMC_CAP_NEEDS_POLL) 2346 mmc_schedule_delayed_work(&host->detect, HZ); 2347 } 2348 2349 void mmc_start_host(struct mmc_host *host) 2350 { 2351 host->f_init = max(freqs[0], host->f_min); 2352 host->rescan_disable = 0; 2353 host->ios.power_mode = MMC_POWER_UNDEFINED; 2354 2355 if (!(host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)) { 2356 mmc_claim_host(host); 2357 mmc_power_up(host, host->ocr_avail); 2358 mmc_release_host(host); 2359 } 2360 2361 mmc_gpiod_request_cd_irq(host); 2362 _mmc_detect_change(host, 0, false); 2363 } 2364 2365 void mmc_stop_host(struct mmc_host *host) 2366 { 2367 if (host->slot.cd_irq >= 0) { 2368 mmc_gpio_set_cd_wake(host, false); 2369 disable_irq(host->slot.cd_irq); 2370 } 2371 2372 host->rescan_disable = 1; 2373 cancel_delayed_work_sync(&host->detect); 2374 2375 /* clear pm flags now and let card drivers set them as needed */ 2376 host->pm_flags = 0; 2377 2378 mmc_bus_get(host); 2379 if (host->bus_ops && !host->bus_dead) { 2380 /* Calling bus_ops->remove() with a claimed host can deadlock */ 2381 host->bus_ops->remove(host); 2382 mmc_claim_host(host); 2383 mmc_detach_bus(host); 2384 mmc_power_off(host); 2385 mmc_release_host(host); 2386 mmc_bus_put(host); 2387 return; 2388 } 2389 mmc_bus_put(host); 2390 2391 mmc_claim_host(host); 2392 mmc_power_off(host); 2393 mmc_release_host(host); 2394 } 2395 2396 #ifdef CONFIG_PM_SLEEP 2397 /* Do the card removal on suspend if card is assumed removeable 2398 * Do that in pm notifier while userspace isn't yet frozen, so we will be able 2399 to sync the card. 2400 */ 2401 static int mmc_pm_notify(struct notifier_block *notify_block, 2402 unsigned long mode, void *unused) 2403 { 2404 struct mmc_host *host = container_of( 2405 notify_block, struct mmc_host, pm_notify); 2406 unsigned long flags; 2407 int err = 0; 2408 2409 switch (mode) { 2410 case PM_HIBERNATION_PREPARE: 2411 case PM_SUSPEND_PREPARE: 2412 case PM_RESTORE_PREPARE: 2413 spin_lock_irqsave(&host->lock, flags); 2414 host->rescan_disable = 1; 2415 spin_unlock_irqrestore(&host->lock, flags); 2416 cancel_delayed_work_sync(&host->detect); 2417 2418 if (!host->bus_ops) 2419 break; 2420 2421 /* Validate prerequisites for suspend */ 2422 if (host->bus_ops->pre_suspend) 2423 err = host->bus_ops->pre_suspend(host); 2424 if (!err) 2425 break; 2426 2427 if (!mmc_card_is_removable(host)) { 2428 dev_warn(mmc_dev(host), 2429 "pre_suspend failed for non-removable host: " 2430 "%d\n", err); 2431 /* Avoid removing non-removable hosts */ 2432 break; 2433 } 2434 2435 /* Calling bus_ops->remove() with a claimed host can deadlock */ 2436 host->bus_ops->remove(host); 2437 mmc_claim_host(host); 2438 mmc_detach_bus(host); 2439 mmc_power_off(host); 2440 mmc_release_host(host); 2441 host->pm_flags = 0; 2442 break; 2443 2444 case PM_POST_SUSPEND: 2445 case PM_POST_HIBERNATION: 2446 case PM_POST_RESTORE: 2447 2448 spin_lock_irqsave(&host->lock, flags); 2449 host->rescan_disable = 0; 2450 spin_unlock_irqrestore(&host->lock, flags); 2451 _mmc_detect_change(host, 0, false); 2452 2453 } 2454 2455 return 0; 2456 } 2457 2458 void mmc_register_pm_notifier(struct mmc_host *host) 2459 { 2460 host->pm_notify.notifier_call = mmc_pm_notify; 2461 register_pm_notifier(&host->pm_notify); 2462 } 2463 2464 void mmc_unregister_pm_notifier(struct mmc_host *host) 2465 { 2466 unregister_pm_notifier(&host->pm_notify); 2467 } 2468 #endif 2469 2470 static int __init mmc_init(void) 2471 { 2472 int ret; 2473 2474 ret = mmc_register_bus(); 2475 if (ret) 2476 return ret; 2477 2478 ret = mmc_register_host_class(); 2479 if (ret) 2480 goto unregister_bus; 2481 2482 ret = sdio_register_bus(); 2483 if (ret) 2484 goto unregister_host_class; 2485 2486 return 0; 2487 2488 unregister_host_class: 2489 mmc_unregister_host_class(); 2490 unregister_bus: 2491 mmc_unregister_bus(); 2492 return ret; 2493 } 2494 2495 static void __exit mmc_exit(void) 2496 { 2497 sdio_unregister_bus(); 2498 mmc_unregister_host_class(); 2499 mmc_unregister_bus(); 2500 } 2501 2502 subsys_initcall(mmc_init); 2503 module_exit(mmc_exit); 2504 2505 MODULE_LICENSE("GPL"); 2506