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