2367 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * linux/drivers/mmc/core/core.c4 *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_POINTS36#include <trace/events/mmc.h>37 38#include "core.h"39#include "card.h"40#include "crypto.h"41#include "bus.h"42#include "host.h"43#include "sdio_bus.h"44#include "pwrseq.h"45 46#include "mmc_ops.h"47#include "sd_ops.h"48#include "sdio_ops.h"49 50/* The max erase timeout, used when host->max_busy_timeout isn't specified */51#define MMC_ERASE_TIMEOUT_MS (60 * 1000) /* 60 s */52#define SD_DISCARD_TIMEOUT_MS (250)53 54static const unsigned freqs[] = { 400000, 300000, 200000, 100000 };55 56/*57 * Enabling software CRCs on the data blocks can be a significant (30%)58 * performance cost, and for other reasons may not always be desired.59 * So we allow it to be disabled.60 */61bool use_spi_crc = 1;62module_param(use_spi_crc, bool, 0);63 64static int mmc_schedule_delayed_work(struct delayed_work *work,65 unsigned long delay)66{67 /*68 * We use the system_freezable_wq, because of two reasons.69 * First, it allows several works (not the same work item) to be70 * executed simultaneously. Second, the queue becomes frozen when71 * userspace becomes frozen during system PM.72 */73 return queue_delayed_work(system_freezable_wq, work, delay);74}75 76#ifdef CONFIG_FAIL_MMC_REQUEST77 78/*79 * Internal function. Inject random data errors.80 * If mmc_data is NULL no errors are injected.81 */82static void mmc_should_fail_request(struct mmc_host *host,83 struct mmc_request *mrq)84{85 struct mmc_command *cmd = mrq->cmd;86 struct mmc_data *data = mrq->data;87 static const int data_errors[] = {88 -ETIMEDOUT,89 -EILSEQ,90 -EIO,91 };92 93 if (!data)94 return;95 96 if ((cmd && cmd->error) || data->error ||97 !should_fail(&host->fail_mmc_request, data->blksz * data->blocks))98 return;99 100 data->error = data_errors[get_random_u32_below(ARRAY_SIZE(data_errors))];101 data->bytes_xfered = get_random_u32_below(data->bytes_xfered >> 9) << 9;102}103 104#else /* CONFIG_FAIL_MMC_REQUEST */105 106static inline void mmc_should_fail_request(struct mmc_host *host,107 struct mmc_request *mrq)108{109}110 111#endif /* CONFIG_FAIL_MMC_REQUEST */112 113static inline void mmc_complete_cmd(struct mmc_request *mrq)114{115 if (mrq->cap_cmd_during_tfr && !completion_done(&mrq->cmd_completion))116 complete_all(&mrq->cmd_completion);117}118 119void mmc_command_done(struct mmc_host *host, struct mmc_request *mrq)120{121 if (!mrq->cap_cmd_during_tfr)122 return;123 124 mmc_complete_cmd(mrq);125 126 pr_debug("%s: cmd done, tfr ongoing (CMD%u)\n",127 mmc_hostname(host), mrq->cmd->opcode);128}129EXPORT_SYMBOL(mmc_command_done);130 131/**132 * mmc_request_done - finish processing an MMC request133 * @host: MMC host which completed request134 * @mrq: MMC request which request135 *136 * MMC drivers should call this function when they have completed137 * their processing of a request.138 */139void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)140{141 struct mmc_command *cmd = mrq->cmd;142 int err = cmd->error;143 144 /* Flag re-tuning needed on CRC errors */145 if (!mmc_op_tuning(cmd->opcode) &&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 considered166 * properly done:167 *168 * - There was no error, OK fine then169 * - We are not doing some kind of retry170 * - The card was removed (...so just complete everything no matter171 * 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 - see208 * mmc_wait_for_req_done().209 */210 if (mrq->done)211 mrq->done(mrq);212}213 214EXPORT_SYMBOL(mmc_request_done);215 216static 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 some230 * 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 on251 * 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 264static 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 298static 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 335int 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}359EXPORT_SYMBOL(mmc_start_request);360 361static void mmc_wait_done(struct mmc_request *mrq)362{363 complete(&mrq->completion);364}365 366static 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 become372 * available.373 */374 if (ongoing_mrq && !completion_done(&ongoing_mrq->cmd_completion))375 wait_for_completion(&ongoing_mrq->cmd_completion);376}377 378static 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 397void mmc_wait_for_req_done(struct mmc_host *host, struct mmc_request *mrq)398{399 struct mmc_command *cmd;400 401 while (1) {402 wait_for_completion(&mrq->completion);403 404 cmd = mrq->cmd;405 406 if (!cmd->error || !cmd->retries ||407 mmc_card_removed(host->card))408 break;409 410 mmc_retune_recheck(host);411 412 pr_debug("%s: req failed (CMD%u): %d, retrying...\n",413 mmc_hostname(host), cmd->opcode, cmd->error);414 cmd->retries--;415 cmd->error = 0;416 __mmc_start_request(host, mrq);417 }418 419 mmc_retune_release(host);420}421EXPORT_SYMBOL(mmc_wait_for_req_done);422 423/*424 * mmc_cqe_start_req - Start a CQE request.425 * @host: MMC host to start the request426 * @mrq: request to start427 *428 * Start the request, re-tuning if needed and it is possible. Returns an error429 * code if the request fails to start or -EBUSY if CQE is busy.430 */431int mmc_cqe_start_req(struct mmc_host *host, struct mmc_request *mrq)432{433 int err;434 435 /*436 * CQE cannot process re-tuning commands. Caller must hold retuning437 * while CQE is in use. Re-tuning can happen here only when CQE has no438 * active requests i.e. this is the first. Note, re-tuning will call439 * ->cqe_off().440 */441 err = mmc_retune(host);442 if (err)443 goto out_err;444 445 mrq->host = host;446 447 mmc_mrq_pr_debug(host, mrq, true);448 449 err = mmc_mrq_prep(host, mrq);450 if (err)451 goto out_err;452 453 err = host->cqe_ops->cqe_request(host, mrq);454 if (err)455 goto out_err;456 457 trace_mmc_request_start(host, mrq);458 459 return 0;460 461out_err:462 if (mrq->cmd) {463 pr_debug("%s: failed to start CQE direct CMD%u, error %d\n",464 mmc_hostname(host), mrq->cmd->opcode, err);465 } else {466 pr_debug("%s: failed to start CQE transfer for tag %d, error %d\n",467 mmc_hostname(host), mrq->tag, err);468 }469 return err;470}471EXPORT_SYMBOL(mmc_cqe_start_req);472 473/**474 * mmc_cqe_request_done - CQE has finished processing an MMC request475 * @host: MMC host which completed request476 * @mrq: MMC request which completed477 *478 * CQE drivers should call this function when they have completed479 * their processing of a request.480 */481void mmc_cqe_request_done(struct mmc_host *host, struct mmc_request *mrq)482{483 mmc_should_fail_request(host, mrq);484 485 /* Flag re-tuning needed on CRC errors */486 if ((mrq->cmd && mrq->cmd->error == -EILSEQ) ||487 (mrq->data && mrq->data->error == -EILSEQ))488 mmc_retune_needed(host);489 490 trace_mmc_request_done(host, mrq);491 492 if (mrq->cmd) {493 pr_debug("%s: CQE req done (direct CMD%u): %d\n",494 mmc_hostname(host), mrq->cmd->opcode, mrq->cmd->error);495 } else {496 pr_debug("%s: CQE transfer done tag %d\n",497 mmc_hostname(host), mrq->tag);498 }499 500 if (mrq->data) {501 pr_debug("%s: %d bytes transferred: %d\n",502 mmc_hostname(host),503 mrq->data->bytes_xfered, mrq->data->error);504 }505 506 mrq->done(mrq);507}508EXPORT_SYMBOL(mmc_cqe_request_done);509 510/**511 * mmc_cqe_post_req - CQE post process of a completed MMC request512 * @host: MMC host513 * @mrq: MMC request to be processed514 */515void mmc_cqe_post_req(struct mmc_host *host, struct mmc_request *mrq)516{517 if (host->cqe_ops->cqe_post_req)518 host->cqe_ops->cqe_post_req(host, mrq);519}520EXPORT_SYMBOL(mmc_cqe_post_req);521 522/* Arbitrary 1 second timeout */523#define MMC_CQE_RECOVERY_TIMEOUT 1000524 525/*526 * mmc_cqe_recovery - Recover from CQE errors.527 * @host: MMC host to recover528 *529 * Recovery consists of stopping CQE, stopping eMMC, discarding the queue530 * in eMMC, and discarding the queue in CQE. CQE must call531 * mmc_cqe_request_done() on all requests. An error is returned if the eMMC532 * fails to discard its queue.533 */534int mmc_cqe_recovery(struct mmc_host *host)535{536 struct mmc_command cmd;537 int err;538 539 mmc_retune_hold_now(host);540 541 /*542 * Recovery is expected seldom, if at all, but it reduces performance,543 * so make sure it is not completely silent.544 */545 pr_warn("%s: running CQE recovery\n", mmc_hostname(host));546 547 host->cqe_ops->cqe_recovery_start(host);548 549 memset(&cmd, 0, sizeof(cmd));550 cmd.opcode = MMC_STOP_TRANSMISSION;551 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;552 cmd.flags &= ~MMC_RSP_CRC; /* Ignore CRC */553 cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT;554 mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);555 556 mmc_poll_for_busy(host->card, MMC_CQE_RECOVERY_TIMEOUT, true, MMC_BUSY_IO);557 558 memset(&cmd, 0, sizeof(cmd));559 cmd.opcode = MMC_CMDQ_TASK_MGMT;560 cmd.arg = 1; /* Discard entire queue */561 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;562 cmd.flags &= ~MMC_RSP_CRC; /* Ignore CRC */563 cmd.busy_timeout = MMC_CQE_RECOVERY_TIMEOUT;564 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);565 566 host->cqe_ops->cqe_recovery_finish(host);567 568 if (err)569 err = mmc_wait_for_cmd(host, &cmd, MMC_CMD_RETRIES);570 571 mmc_retune_release(host);572 573 return err;574}575EXPORT_SYMBOL(mmc_cqe_recovery);576 577/**578 * mmc_is_req_done - Determine if a 'cap_cmd_during_tfr' request is done579 * @host: MMC host580 * @mrq: MMC request581 *582 * mmc_is_req_done() is used with requests that have583 * mrq->cap_cmd_during_tfr = true. mmc_is_req_done() must be called after584 * starting a request and before waiting for it to complete. That is,585 * either in between calls to mmc_start_req(), or after mmc_wait_for_req()586 * and before mmc_wait_for_req_done(). If it is called at other times the587 * result is not meaningful.588 */589bool mmc_is_req_done(struct mmc_host *host, struct mmc_request *mrq)590{591 return completion_done(&mrq->completion);592}593EXPORT_SYMBOL(mmc_is_req_done);594 595/**596 * mmc_wait_for_req - start a request and wait for completion597 * @host: MMC host to start command598 * @mrq: MMC request to start599 *600 * Start a new MMC custom command request for a host, and wait601 * for the command to complete. In the case of 'cap_cmd_during_tfr'602 * requests, the transfer is ongoing and the caller can issue further603 * commands that do not use the data lines, and then wait by calling604 * mmc_wait_for_req_done().605 * Does not attempt to parse the response.606 */607void mmc_wait_for_req(struct mmc_host *host, struct mmc_request *mrq)608{609 __mmc_start_req(host, mrq);610 611 if (!mrq->cap_cmd_during_tfr)612 mmc_wait_for_req_done(host, mrq);613}614EXPORT_SYMBOL(mmc_wait_for_req);615 616/**617 * mmc_wait_for_cmd - start a command and wait for completion618 * @host: MMC host to start command619 * @cmd: MMC command to start620 * @retries: maximum number of retries621 *622 * Start a new MMC command for a host, and wait for the command623 * to complete. Return any error that occurred while the command624 * was executing. Do not attempt to parse the response.625 */626int mmc_wait_for_cmd(struct mmc_host *host, struct mmc_command *cmd, int retries)627{628 struct mmc_request mrq = {};629 630 WARN_ON(!host->claimed);631 632 memset(cmd->resp, 0, sizeof(cmd->resp));633 cmd->retries = retries;634 635 mrq.cmd = cmd;636 cmd->data = NULL;637 638 mmc_wait_for_req(host, &mrq);639 640 return cmd->error;641}642 643EXPORT_SYMBOL(mmc_wait_for_cmd);644 645/**646 * mmc_set_data_timeout - set the timeout for a data command647 * @data: data phase for command648 * @card: the MMC card associated with the data transfer649 *650 * Computes the data timeout parameters according to the651 * correct algorithm given the card type.652 */653void mmc_set_data_timeout(struct mmc_data *data, const struct mmc_card *card)654{655 unsigned int mult;656 657 /*658 * SDIO cards only define an upper 1 s limit on access.659 */660 if (mmc_card_sdio(card)) {661 data->timeout_ns = 1000000000;662 data->timeout_clks = 0;663 return;664 }665 666 /*667 * SD cards use a 100 multiplier rather than 10668 */669 mult = mmc_card_sd(card) ? 100 : 10;670 671 /*672 * Scale up the multiplier (and therefore the timeout) by673 * the r2w factor for writes.674 */675 if (data->flags & MMC_DATA_WRITE)676 mult <<= card->csd.r2w_factor;677 678 data->timeout_ns = card->csd.taac_ns * mult;679 data->timeout_clks = card->csd.taac_clks * mult;680 681 /*682 * SD cards also have an upper limit on the timeout.683 */684 if (mmc_card_sd(card)) {685 unsigned int timeout_us, limit_us;686 687 timeout_us = data->timeout_ns / 1000;688 if (card->host->ios.clock)689 timeout_us += data->timeout_clks * 1000 /690 (card->host->ios.clock / 1000);691 692 if (data->flags & MMC_DATA_WRITE)693 /*694 * The MMC spec "It is strongly recommended695 * for hosts to implement more than 500ms696 * timeout value even if the card indicates697 * the 250ms maximum busy length." Even the698 * previous value of 300ms is known to be699 * insufficient for some cards.700 */701 limit_us = 3000000;702 else703 limit_us = 100000;704 705 /*706 * SDHC cards always use these fixed values.707 */708 if (timeout_us > limit_us) {709 data->timeout_ns = limit_us * 1000;710 data->timeout_clks = 0;711 }712 713 /* assign limit value if invalid */714 if (timeout_us == 0)715 data->timeout_ns = limit_us * 1000;716 }717 718 /*719 * Some cards require longer data read timeout than indicated in CSD.720 * Address this by setting the read timeout to a "reasonably high"721 * value. For the cards tested, 600ms has proven enough. If necessary,722 * this value can be increased if other problematic cards require this.723 */724 if (mmc_card_long_read_time(card) && data->flags & MMC_DATA_READ) {725 data->timeout_ns = 600000000;726 data->timeout_clks = 0;727 }728 729 /*730 * Some cards need very high timeouts if driven in SPI mode.731 * The worst observed timeout was 900ms after writing a732 * continuous stream of data until the internal logic733 * overflowed.734 */735 if (mmc_host_is_spi(card->host)) {736 if (data->flags & MMC_DATA_WRITE) {737 if (data->timeout_ns < 1000000000)738 data->timeout_ns = 1000000000; /* 1s */739 } else {740 if (data->timeout_ns < 100000000)741 data->timeout_ns = 100000000; /* 100ms */742 }743 }744}745EXPORT_SYMBOL(mmc_set_data_timeout);746 747/*748 * Allow claiming an already claimed host if the context is the same or there is749 * no context but the task is the same.750 */751static inline bool mmc_ctx_matches(struct mmc_host *host, struct mmc_ctx *ctx,752 struct task_struct *task)753{754 return host->claimer == ctx ||755 (!ctx && task && host->claimer->task == task);756}757 758static inline void mmc_ctx_set_claimer(struct mmc_host *host,759 struct mmc_ctx *ctx,760 struct task_struct *task)761{762 if (!host->claimer) {763 if (ctx)764 host->claimer = ctx;765 else766 host->claimer = &host->default_ctx;767 }768 if (task)769 host->claimer->task = task;770}771 772/**773 * __mmc_claim_host - exclusively claim a host774 * @host: mmc host to claim775 * @ctx: context that claims the host or NULL in which case the default776 * context will be used777 * @abort: whether or not the operation should be aborted778 *779 * Claim a host for a set of operations. If @abort is non null and780 * dereference a non-zero value then this will return prematurely with781 * that non-zero value without acquiring the lock. Returns zero782 * with the lock held otherwise.783 */784int __mmc_claim_host(struct mmc_host *host, struct mmc_ctx *ctx,785 atomic_t *abort)786{787 struct task_struct *task = ctx ? NULL : current;788 DECLARE_WAITQUEUE(wait, current);789 unsigned long flags;790 int stop;791 bool pm = false;792 793 might_sleep();794 795 add_wait_queue(&host->wq, &wait);796 spin_lock_irqsave(&host->lock, flags);797 while (1) {798 set_current_state(TASK_UNINTERRUPTIBLE);799 stop = abort ? atomic_read(abort) : 0;800 if (stop || !host->claimed || mmc_ctx_matches(host, ctx, task))801 break;802 spin_unlock_irqrestore(&host->lock, flags);803 schedule();804 spin_lock_irqsave(&host->lock, flags);805 }806 set_current_state(TASK_RUNNING);807 if (!stop) {808 host->claimed = 1;809 mmc_ctx_set_claimer(host, ctx, task);810 host->claim_cnt += 1;811 if (host->claim_cnt == 1)812 pm = true;813 } else814 wake_up(&host->wq);815 spin_unlock_irqrestore(&host->lock, flags);816 remove_wait_queue(&host->wq, &wait);817 818 if (pm)819 pm_runtime_get_sync(mmc_dev(host));820 821 return stop;822}823EXPORT_SYMBOL(__mmc_claim_host);824 825/**826 * mmc_release_host - release a host827 * @host: mmc host to release828 *829 * Release a MMC host, allowing others to claim the host830 * for their operations.831 */832void mmc_release_host(struct mmc_host *host)833{834 unsigned long flags;835 836 WARN_ON(!host->claimed);837 838 spin_lock_irqsave(&host->lock, flags);839 if (--host->claim_cnt) {840 /* Release for nested claim */841 spin_unlock_irqrestore(&host->lock, flags);842 } else {843 host->claimed = 0;844 host->claimer->task = NULL;845 host->claimer = NULL;846 spin_unlock_irqrestore(&host->lock, flags);847 wake_up(&host->wq);848 pm_runtime_mark_last_busy(mmc_dev(host));849 if (host->caps & MMC_CAP_SYNC_RUNTIME_PM)850 pm_runtime_put_sync_suspend(mmc_dev(host));851 else852 pm_runtime_put_autosuspend(mmc_dev(host));853 }854}855EXPORT_SYMBOL(mmc_release_host);856 857/*858 * This is a helper function, which fetches a runtime pm reference for the859 * card device and also claims the host.860 */861void mmc_get_card(struct mmc_card *card, struct mmc_ctx *ctx)862{863 pm_runtime_get_sync(&card->dev);864 __mmc_claim_host(card->host, ctx, NULL);865}866EXPORT_SYMBOL(mmc_get_card);867 868/*869 * This is a helper function, which releases the host and drops the runtime870 * pm reference for the card device.871 */872void mmc_put_card(struct mmc_card *card, struct mmc_ctx *ctx)873{874 struct mmc_host *host = card->host;875 876 WARN_ON(ctx && host->claimer != ctx);877 878 mmc_release_host(host);879 pm_runtime_mark_last_busy(&card->dev);880 pm_runtime_put_autosuspend(&card->dev);881}882EXPORT_SYMBOL(mmc_put_card);883 884/*885 * Internal function that does the actual ios call to the host driver,886 * optionally printing some debug output.887 */888static inline void mmc_set_ios(struct mmc_host *host)889{890 struct mmc_ios *ios = &host->ios;891 892 pr_debug("%s: clock %uHz busmode %u powermode %u cs %u Vdd %u "893 "width %u timing %u\n",894 mmc_hostname(host), ios->clock, ios->bus_mode,895 ios->power_mode, ios->chip_select, ios->vdd,896 1 << ios->bus_width, ios->timing);897 898 host->ops->set_ios(host, ios);899}900 901/*902 * Control chip select pin on a host.903 */904void mmc_set_chip_select(struct mmc_host *host, int mode)905{906 host->ios.chip_select = mode;907 mmc_set_ios(host);908}909 910/*911 * Sets the host clock to the highest possible frequency that912 * is below "hz".913 */914void mmc_set_clock(struct mmc_host *host, unsigned int hz)915{916 WARN_ON(hz && hz < host->f_min);917 918 if (hz > host->f_max)919 hz = host->f_max;920 921 host->ios.clock = hz;922 mmc_set_ios(host);923}924 925int mmc_execute_tuning(struct mmc_card *card)926{927 struct mmc_host *host = card->host;928 u32 opcode;929 int err;930 931 if (!host->ops->execute_tuning)932 return 0;933 934 if (host->cqe_on)935 host->cqe_ops->cqe_off(host);936 937 if (mmc_card_mmc(card))938 opcode = MMC_SEND_TUNING_BLOCK_HS200;939 else940 opcode = MMC_SEND_TUNING_BLOCK;941 942 err = host->ops->execute_tuning(host, opcode);943 if (!err) {944 mmc_retune_clear(host);945 mmc_retune_enable(host);946 return 0;947 }948 949 /* Only print error when we don't check for card removal */950 if (!host->detect_change) {951 pr_err("%s: tuning execution failed: %d\n",952 mmc_hostname(host), err);953 mmc_debugfs_err_stats_inc(host, MMC_ERR_TUNING);954 }955 956 return err;957}958 959/*960 * Change the bus mode (open drain/push-pull) of a host.961 */962void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode)963{964 host->ios.bus_mode = mode;965 mmc_set_ios(host);966}967 968/*969 * Change data bus width of a host.970 */971void mmc_set_bus_width(struct mmc_host *host, unsigned int width)972{973 host->ios.bus_width = width;974 mmc_set_ios(host);975}976 977/*978 * Set initial state after a power cycle or a hw_reset.979 */980void mmc_set_initial_state(struct mmc_host *host)981{982 if (host->cqe_on)983 host->cqe_ops->cqe_off(host);984 985 mmc_retune_disable(host);986 987 if (mmc_host_is_spi(host))988 host->ios.chip_select = MMC_CS_HIGH;989 else990 host->ios.chip_select = MMC_CS_DONTCARE;991 host->ios.bus_mode = MMC_BUSMODE_PUSHPULL;992 host->ios.bus_width = MMC_BUS_WIDTH_1;993 host->ios.timing = MMC_TIMING_LEGACY;994 host->ios.drv_type = 0;995 host->ios.enhanced_strobe = false;996 997 /*998 * Make sure we are in non-enhanced strobe mode before we999 * actually enable it in ext_csd.1000 */1001 if ((host->caps2 & MMC_CAP2_HS400_ES) &&1002 host->ops->hs400_enhanced_strobe)1003 host->ops->hs400_enhanced_strobe(host, &host->ios);1004 1005 mmc_set_ios(host);1006 1007 mmc_crypto_set_initial_state(host);1008}1009 1010/**1011 * mmc_vdd_to_ocrbitnum - Convert a voltage to the OCR bit number1012 * @vdd: voltage (mV)1013 * @low_bits: prefer low bits in boundary cases1014 *1015 * This function returns the OCR bit number according to the provided @vdd1016 * value. If conversion is not possible a negative errno value returned.1017 *1018 * Depending on the @low_bits flag the function prefers low or high OCR bits1019 * on boundary voltages. For example,1020 * with @low_bits = true, 3300 mV translates to ilog2(MMC_VDD_32_33);1021 * with @low_bits = false, 3300 mV translates to ilog2(MMC_VDD_33_34);1022 *1023 * Any value in the [1951:1999] range translates to the ilog2(MMC_VDD_20_21).1024 */1025static int mmc_vdd_to_ocrbitnum(int vdd, bool low_bits)1026{1027 const int max_bit = ilog2(MMC_VDD_35_36);1028 int bit;1029 1030 if (vdd < 1650 || vdd > 3600)1031 return -EINVAL;1032 1033 if (vdd >= 1650 && vdd <= 1950)1034 return ilog2(MMC_VDD_165_195);1035 1036 if (low_bits)1037 vdd -= 1;1038 1039 /* Base 2000 mV, step 100 mV, bit's base 8. */1040 bit = (vdd - 2000) / 100 + 8;1041 if (bit > max_bit)1042 return max_bit;1043 return bit;1044}1045 1046/**1047 * mmc_vddrange_to_ocrmask - Convert a voltage range to the OCR mask1048 * @vdd_min: minimum voltage value (mV)1049 * @vdd_max: maximum voltage value (mV)1050 *1051 * This function returns the OCR mask bits according to the provided @vdd_min1052 * and @vdd_max values. If conversion is not possible the function returns 0.1053 *1054 * Notes wrt boundary cases:1055 * This function sets the OCR bits for all boundary voltages, for example1056 * [3300:3400] range is translated to MMC_VDD_32_33 | MMC_VDD_33_34 |1057 * MMC_VDD_34_35 mask.1058 */1059u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max)1060{1061 u32 mask = 0;1062 1063 if (vdd_max < vdd_min)1064 return 0;1065 1066 /* Prefer high bits for the boundary vdd_max values. */1067 vdd_max = mmc_vdd_to_ocrbitnum(vdd_max, false);1068 if (vdd_max < 0)1069 return 0;1070 1071 /* Prefer low bits for the boundary vdd_min values. */1072 vdd_min = mmc_vdd_to_ocrbitnum(vdd_min, true);1073 if (vdd_min < 0)1074 return 0;1075 1076 /* Fill the mask, from max bit to min bit. */1077 while (vdd_max >= vdd_min)1078 mask |= 1 << vdd_max--;1079 1080 return mask;1081}1082 1083static int mmc_of_get_func_num(struct device_node *node)1084{1085 u32 reg;1086 int ret;1087 1088 ret = of_property_read_u32(node, "reg", ®);1089 if (ret < 0)1090 return ret;1091 1092 return reg;1093}1094 1095struct device_node *mmc_of_find_child_device(struct mmc_host *host,1096 unsigned func_num)1097{1098 struct device_node *node;1099 1100 if (!host->parent || !host->parent->of_node)1101 return NULL;1102 1103 for_each_child_of_node(host->parent->of_node, node) {1104 if (mmc_of_get_func_num(node) == func_num)1105 return node;1106 }1107 1108 return NULL;1109}1110 1111/*1112 * Mask off any voltages we don't support and select1113 * the lowest voltage1114 */1115u32 mmc_select_voltage(struct mmc_host *host, u32 ocr)1116{1117 int bit;1118 1119 /*1120 * Sanity check the voltages that the card claims to1121 * support.1122 */1123 if (ocr & 0x7F) {1124 dev_warn(mmc_dev(host),1125 "card claims to support voltages below defined range\n");1126 ocr &= ~0x7F;1127 }1128 1129 ocr &= host->ocr_avail;1130 if (!ocr) {1131 dev_warn(mmc_dev(host), "no support for card's volts\n");1132 return 0;1133 }1134 1135 if (host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) {1136 bit = ffs(ocr) - 1;1137 ocr &= 3 << bit;1138 mmc_power_cycle(host, ocr);1139 } else {1140 bit = fls(ocr) - 1;1141 /*1142 * The bit variable represents the highest voltage bit set in1143 * the OCR register.1144 * To keep a range of 2 values (e.g. 3.2V/3.3V and 3.3V/3.4V),1145 * we must shift the mask '3' with (bit - 1).1146 */1147 ocr &= 3 << (bit - 1);1148 if (bit != host->ios.vdd)1149 dev_warn(mmc_dev(host), "exceeding card's volts\n");1150 }1151 1152 return ocr;1153}1154 1155int 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 1171void 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 1182int 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 gated1188 * for 5 ms according to the SD spec1189 */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 1205int 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 caller1212 * can continue without UHS mode1213 */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 goto power_cycle;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 immediately1233 * after the response of cmd11, but wait 1 ms to be sure1234 */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 already1244 * sent CMD11, so a power cycle is required anyway1245 */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 holding1255 * dat[0:3] low1256 */1257 if (host->ops->card_busy && host->ops->card_busy(host))1258 err = -EAGAIN;1259 1260power_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 */1273void 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 */1282void 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 1288int 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 support1311 * depends on the board design. Pass the appropriate1312 * information and let the hardware specific code1313 * return what is possible given the options1314 */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 the1330 * initial MMC_POWER_UP stage.1331 */1332void 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 supply1348 * 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 the1361 * time required to reach a stable voltage.1362 */1363 mmc_delay(host->ios.power_delay_ms);1364}1365 1366void 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 OLPC1382 * XO-1.5, require a short delay after poweroff before the card1383 * can be successfully turned on again.1384 */1385 mmc_delay(1);1386}1387 1388void 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 * Assign a mmc bus handler to a host. Only one bus handler may control a1398 * host at any given time.1399 */1400void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops)1401{1402 host->bus_ops = ops;1403}1404 1405/*1406 * Remove the current bus handler from a host.1407 */1408void mmc_detach_bus(struct mmc_host *host)1409{1410 host->bus_ops = NULL;1411}1412 1413void _mmc_detect_change(struct mmc_host *host, unsigned long delay, bool cd_irq)1414{1415 /*1416 * Prevent system sleep for 5s to allow user space to consume the1417 * corresponding uevent. This is especially useful, when CD irq is used1418 * as a system wakeup, but doesn't hurt in other cases.1419 */1420 if (cd_irq && !(host->caps & MMC_CAP_NEEDS_POLL))1421 __pm_wakeup_event(host->ws, 5000);1422 1423 host->detect_change = 1;1424 mmc_schedule_delayed_work(&host->detect, delay);1425}1426 1427/**1428 * mmc_detect_change - process change of state on a MMC socket1429 * @host: host which changed state.1430 * @delay: optional delay to wait before detection (jiffies)1431 *1432 * MMC drivers should call this when they detect a card has been1433 * inserted or removed. The MMC layer will confirm that any1434 * present card is still functional, and initialize any newly1435 * inserted.1436 */1437void mmc_detect_change(struct mmc_host *host, unsigned long delay)1438{1439 _mmc_detect_change(host, delay, true);1440}1441EXPORT_SYMBOL(mmc_detect_change);1442 1443void mmc_init_erase(struct mmc_card *card)1444{1445 unsigned int sz;1446 1447 if (is_power_of_2(card->erase_size))1448 card->erase_shift = ffs(card->erase_size) - 1;1449 else1450 card->erase_shift = 0;1451 1452 /*1453 * It is possible to erase an arbitrarily large area of an SD or MMC1454 * card. That is not desirable because it can take a long time1455 * (minutes) potentially delaying more important I/O, and also the1456 * timeout calculations become increasingly hugely over-estimated.1457 * Consequently, 'pref_erase' is defined as a guide to limit erases1458 * to that size and alignment.1459 *1460 * For SD cards that define Allocation Unit size, limit erases to one1461 * Allocation Unit at a time.1462 * For MMC, have a stab at ai good value and for modern cards it will1463 * end up being 4MiB. Note that if the value is too small, it can end1464 * up taking longer to erase. Also note, erase_size is already set to1465 * High Capacity Erase Size if available when this function is called.1466 */1467 if (mmc_card_sd(card) && card->ssr.au) {1468 card->pref_erase = card->ssr.au;1469 card->erase_shift = ffs(card->ssr.au) - 1;1470 } else if (card->erase_size) {1471 sz = (card->csd.capacity << (card->csd.read_blkbits - 9)) >> 11;1472 if (sz < 128)1473 card->pref_erase = 512 * 1024 / 512;1474 else if (sz < 512)1475 card->pref_erase = 1024 * 1024 / 512;1476 else if (sz < 1024)1477 card->pref_erase = 2 * 1024 * 1024 / 512;1478 else1479 card->pref_erase = 4 * 1024 * 1024 / 512;1480 if (card->pref_erase < card->erase_size)1481 card->pref_erase = card->erase_size;1482 else {1483 sz = card->pref_erase % card->erase_size;1484 if (sz)1485 card->pref_erase += card->erase_size - sz;1486 }1487 } else1488 card->pref_erase = 0;1489}1490 1491static bool is_trim_arg(unsigned int arg)1492{1493 return (arg & MMC_TRIM_OR_DISCARD_ARGS) && arg != MMC_DISCARD_ARG;1494}1495 1496static unsigned int mmc_mmc_erase_timeout(struct mmc_card *card,1497 unsigned int arg, unsigned int qty)1498{1499 unsigned int erase_timeout;1500 1501 if (arg == MMC_DISCARD_ARG ||1502 (arg == MMC_TRIM_ARG && card->ext_csd.rev >= 6)) {1503 erase_timeout = card->ext_csd.trim_timeout;1504 } else if (card->ext_csd.erase_group_def & 1) {1505 /* High Capacity Erase Group Size uses HC timeouts */1506 if (arg == MMC_TRIM_ARG)1507 erase_timeout = card->ext_csd.trim_timeout;1508 else1509 erase_timeout = card->ext_csd.hc_erase_timeout;1510 } else {1511 /* CSD Erase Group Size uses write timeout */1512 unsigned int mult = (10 << card->csd.r2w_factor);1513 unsigned int timeout_clks = card->csd.taac_clks * mult;1514 unsigned int timeout_us;1515 1516 /* Avoid overflow: e.g. taac_ns=80000000 mult=1280 */1517 if (card->csd.taac_ns < 1000000)1518 timeout_us = (card->csd.taac_ns * mult) / 1000;1519 else1520 timeout_us = (card->csd.taac_ns / 1000) * mult;1521 1522 /*1523 * ios.clock is only a target. The real clock rate might be1524 * less but not that much less, so fudge it by multiplying by 2.1525 */1526 timeout_clks <<= 1;1527 timeout_us += (timeout_clks * 1000) /1528 (card->host->ios.clock / 1000);1529 1530 erase_timeout = timeout_us / 1000;1531 1532 /*1533 * Theoretically, the calculation could underflow so round up1534 * to 1ms in that case.1535 */1536 if (!erase_timeout)1537 erase_timeout = 1;1538 }1539 1540 /* Multiplier for secure operations */1541 if (arg & MMC_SECURE_ARGS) {1542 if (arg == MMC_SECURE_ERASE_ARG)1543 erase_timeout *= card->ext_csd.sec_erase_mult;1544 else1545 erase_timeout *= card->ext_csd.sec_trim_mult;1546 }1547 1548 erase_timeout *= qty;1549 1550 /*1551 * Ensure at least a 1 second timeout for SPI as per1552 * 'mmc_set_data_timeout()'1553 */1554 if (mmc_host_is_spi(card->host) && erase_timeout < 1000)1555 erase_timeout = 1000;1556 1557 return erase_timeout;1558}1559 1560static unsigned int mmc_sd_erase_timeout(struct mmc_card *card,1561 unsigned int arg,1562 unsigned int qty)1563{1564 unsigned int erase_timeout;1565 1566 /* for DISCARD none of the below calculation applies.1567 * the busy timeout is 250msec per discard command.1568 */1569 if (arg == SD_DISCARD_ARG)1570 return SD_DISCARD_TIMEOUT_MS;1571 1572 if (card->ssr.erase_timeout) {1573 /* Erase timeout specified in SD Status Register (SSR) */1574 erase_timeout = card->ssr.erase_timeout * qty +1575 card->ssr.erase_offset;1576 } else {1577 /*1578 * Erase timeout not specified in SD Status Register (SSR) so1579 * use 250ms per write block.1580 */1581 erase_timeout = 250 * qty;1582 }1583 1584 /* Must not be less than 1 second */1585 if (erase_timeout < 1000)1586 erase_timeout = 1000;1587 1588 return erase_timeout;1589}1590 1591static unsigned int mmc_erase_timeout(struct mmc_card *card,1592 unsigned int arg,1593 unsigned int qty)1594{1595 if (mmc_card_sd(card))1596 return mmc_sd_erase_timeout(card, arg, qty);1597 else1598 return mmc_mmc_erase_timeout(card, arg, qty);1599}1600 1601static int mmc_do_erase(struct mmc_card *card, unsigned int from,1602 unsigned int to, unsigned int arg)1603{1604 struct mmc_command cmd = {};1605 unsigned int qty = 0, busy_timeout = 0;1606 bool use_r1b_resp;1607 int err;1608 1609 mmc_retune_hold(card->host);1610 1611 /*1612 * qty is used to calculate the erase timeout which depends on how many1613 * erase groups (or allocation units in SD terminology) are affected.1614 * We count erasing part of an erase group as one erase group.1615 * For SD, the allocation units are always a power of 2. For MMC, the1616 * erase group size is almost certainly also power of 2, but it does not1617 * seem to insist on that in the JEDEC standard, so we fall back to1618 * division in that case. SD may not specify an allocation unit size,1619 * in which case the timeout is based on the number of write blocks.1620 *1621 * Note that the timeout for secure trim 2 will only be correct if the1622 * number of erase groups specified is the same as the total of all1623 * preceding secure trim 1 commands. Since the power may have been1624 * lost since the secure trim 1 commands occurred, it is generally1625 * impossible to calculate the secure trim 2 timeout correctly.1626 */1627 if (card->erase_shift)1628 qty += ((to >> card->erase_shift) -1629 (from >> card->erase_shift)) + 1;1630 else if (mmc_card_sd(card))1631 qty += to - from + 1;1632 else1633 qty += ((to / card->erase_size) -1634 (from / card->erase_size)) + 1;1635 1636 if (!mmc_card_blockaddr(card)) {1637 from <<= 9;1638 to <<= 9;1639 }1640 1641 if (mmc_card_sd(card))1642 cmd.opcode = SD_ERASE_WR_BLK_START;1643 else1644 cmd.opcode = MMC_ERASE_GROUP_START;1645 cmd.arg = from;1646 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;1647 err = mmc_wait_for_cmd(card->host, &cmd, 0);1648 if (err) {1649 pr_err("mmc_erase: group start error %d, "1650 "status %#x\n", err, cmd.resp[0]);1651 err = -EIO;1652 goto out;1653 }1654 1655 memset(&cmd, 0, sizeof(struct mmc_command));1656 if (mmc_card_sd(card))1657 cmd.opcode = SD_ERASE_WR_BLK_END;1658 else1659 cmd.opcode = MMC_ERASE_GROUP_END;1660 cmd.arg = to;1661 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;1662 err = mmc_wait_for_cmd(card->host, &cmd, 0);1663 if (err) {1664 pr_err("mmc_erase: group end error %d, status %#x\n",1665 err, cmd.resp[0]);1666 err = -EIO;1667 goto out;1668 }1669 1670 memset(&cmd, 0, sizeof(struct mmc_command));1671 cmd.opcode = MMC_ERASE;1672 cmd.arg = arg;1673 busy_timeout = mmc_erase_timeout(card, arg, qty);1674 use_r1b_resp = mmc_prepare_busy_cmd(card->host, &cmd, busy_timeout);1675 1676 err = mmc_wait_for_cmd(card->host, &cmd, 0);1677 if (err) {1678 pr_err("mmc_erase: erase error %d, status %#x\n",1679 err, cmd.resp[0]);1680 err = -EIO;1681 goto out;1682 }1683 1684 if (mmc_host_is_spi(card->host))1685 goto out;1686 1687 /*1688 * In case of when R1B + MMC_CAP_WAIT_WHILE_BUSY is used, the polling1689 * shall be avoided.1690 */1691 if ((card->host->caps & MMC_CAP_WAIT_WHILE_BUSY) && use_r1b_resp)1692 goto out;1693 1694 /* Let's poll to find out when the erase operation completes. */1695 err = mmc_poll_for_busy(card, busy_timeout, false, MMC_BUSY_ERASE);1696 1697out:1698 mmc_retune_release(card->host);1699 return err;1700}1701 1702static unsigned int mmc_align_erase_size(struct mmc_card *card,1703 unsigned int *from,1704 unsigned int *to,1705 unsigned int nr)1706{1707 unsigned int from_new = *from, nr_new = nr, rem;1708 1709 /*1710 * When the 'card->erase_size' is power of 2, we can use round_up/down()1711 * to align the erase size efficiently.1712 */1713 if (is_power_of_2(card->erase_size)) {1714 unsigned int temp = from_new;1715 1716 from_new = round_up(temp, card->erase_size);1717 rem = from_new - temp;1718 1719 if (nr_new > rem)1720 nr_new -= rem;1721 else1722 return 0;1723 1724 nr_new = round_down(nr_new, card->erase_size);1725 } else {1726 rem = from_new % card->erase_size;1727 if (rem) {1728 rem = card->erase_size - rem;1729 from_new += rem;1730 if (nr_new > rem)1731 nr_new -= rem;1732 else1733 return 0;1734 }1735 1736 rem = nr_new % card->erase_size;1737 if (rem)1738 nr_new -= rem;1739 }1740 1741 if (nr_new == 0)1742 return 0;1743 1744 *to = from_new + nr_new;1745 *from = from_new;1746 1747 return nr_new;1748}1749 1750/**1751 * mmc_erase - erase sectors.1752 * @card: card to erase1753 * @from: first sector to erase1754 * @nr: number of sectors to erase1755 * @arg: erase command argument1756 *1757 * Caller must claim host before calling this function.1758 */1759int mmc_erase(struct mmc_card *card, unsigned int from, unsigned int nr,1760 unsigned int arg)1761{1762 unsigned int rem, to = from + nr;1763 int err;1764 1765 if (!(card->csd.cmdclass & CCC_ERASE))1766 return -EOPNOTSUPP;1767 1768 if (!card->erase_size)1769 return -EOPNOTSUPP;1770 1771 if (mmc_card_sd(card) && arg != SD_ERASE_ARG && arg != SD_DISCARD_ARG)1772 return -EOPNOTSUPP;1773 1774 if (mmc_card_mmc(card) && (arg & MMC_SECURE_ARGS) &&1775 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN))1776 return -EOPNOTSUPP;1777 1778 if (mmc_card_mmc(card) && is_trim_arg(arg) &&1779 !(card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN))1780 return -EOPNOTSUPP;1781 1782 if (arg == MMC_SECURE_ERASE_ARG) {1783 if (from % card->erase_size || nr % card->erase_size)1784 return -EINVAL;1785 }1786 1787 if (arg == MMC_ERASE_ARG)1788 nr = mmc_align_erase_size(card, &from, &to, nr);1789 1790 if (nr == 0)1791 return 0;1792 1793 if (to <= from)1794 return -EINVAL;1795 1796 /* 'from' and 'to' are inclusive */1797 to -= 1;1798 1799 /*1800 * Special case where only one erase-group fits in the timeout budget:1801 * If the region crosses an erase-group boundary on this particular1802 * case, we will be trimming more than one erase-group which, does not1803 * fit in the timeout budget of the controller, so we need to split it1804 * and call mmc_do_erase() twice if necessary. This special case is1805 * identified by the card->eg_boundary flag.1806 */1807 rem = card->erase_size - (from % card->erase_size);1808 if ((arg & MMC_TRIM_OR_DISCARD_ARGS) && card->eg_boundary && nr > rem) {1809 err = mmc_do_erase(card, from, from + rem - 1, arg);1810 from += rem;1811 if ((err) || (to <= from))1812 return err;1813 }1814 1815 return mmc_do_erase(card, from, to, arg);1816}1817EXPORT_SYMBOL(mmc_erase);1818 1819int mmc_can_erase(struct mmc_card *card)1820{1821 if (card->csd.cmdclass & CCC_ERASE && card->erase_size)1822 return 1;1823 return 0;1824}1825EXPORT_SYMBOL(mmc_can_erase);1826 1827int mmc_can_trim(struct mmc_card *card)1828{1829 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_GB_CL_EN) &&1830 (!(card->quirks & MMC_QUIRK_TRIM_BROKEN)))1831 return 1;1832 return 0;1833}1834EXPORT_SYMBOL(mmc_can_trim);1835 1836int mmc_can_discard(struct mmc_card *card)1837{1838 /*1839 * As there's no way to detect the discard support bit at v4.51840 * use the s/w feature support filed.1841 */1842 if (card->ext_csd.feature_support & MMC_DISCARD_FEATURE)1843 return 1;1844 return 0;1845}1846EXPORT_SYMBOL(mmc_can_discard);1847 1848int mmc_can_sanitize(struct mmc_card *card)1849{1850 if (!mmc_can_trim(card) && !mmc_can_erase(card))1851 return 0;1852 if (card->ext_csd.sec_feature_support & EXT_CSD_SEC_SANITIZE)1853 return 1;1854 return 0;1855}1856 1857int mmc_can_secure_erase_trim(struct mmc_card *card)1858{1859 if ((card->ext_csd.sec_feature_support & EXT_CSD_SEC_ER_EN) &&1860 !(card->quirks & MMC_QUIRK_SEC_ERASE_TRIM_BROKEN))1861 return 1;1862 return 0;1863}1864EXPORT_SYMBOL(mmc_can_secure_erase_trim);1865 1866int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,1867 unsigned int nr)1868{1869 if (!card->erase_size)1870 return 0;1871 if (from % card->erase_size || nr % card->erase_size)1872 return 0;1873 return 1;1874}1875EXPORT_SYMBOL(mmc_erase_group_aligned);1876 1877static unsigned int mmc_do_calc_max_discard(struct mmc_card *card,1878 unsigned int arg)1879{1880 struct mmc_host *host = card->host;1881 unsigned int max_discard, x, y, qty = 0, max_qty, min_qty, timeout;1882 unsigned int last_timeout = 0;1883 unsigned int max_busy_timeout = host->max_busy_timeout ?1884 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS;1885 1886 if (card->erase_shift) {1887 max_qty = UINT_MAX >> card->erase_shift;1888 min_qty = card->pref_erase >> card->erase_shift;1889 } else if (mmc_card_sd(card)) {1890 max_qty = UINT_MAX;1891 min_qty = card->pref_erase;1892 } else {1893 max_qty = UINT_MAX / card->erase_size;1894 min_qty = card->pref_erase / card->erase_size;1895 }1896 1897 /*1898 * We should not only use 'host->max_busy_timeout' as the limitation1899 * when deciding the max discard sectors. We should set a balance value1900 * to improve the erase speed, and it can not get too long timeout at1901 * the same time.1902 *1903 * Here we set 'card->pref_erase' as the minimal discard sectors no1904 * matter what size of 'host->max_busy_timeout', but if the1905 * 'host->max_busy_timeout' is large enough for more discard sectors,1906 * then we can continue to increase the max discard sectors until we1907 * get a balance value. In cases when the 'host->max_busy_timeout'1908 * isn't specified, use the default max erase timeout.1909 */1910 do {1911 y = 0;1912 for (x = 1; x && x <= max_qty && max_qty - x >= qty; x <<= 1) {1913 timeout = mmc_erase_timeout(card, arg, qty + x);1914 1915 if (qty + x > min_qty && timeout > max_busy_timeout)1916 break;1917 1918 if (timeout < last_timeout)1919 break;1920 last_timeout = timeout;1921 y = x;1922 }1923 qty += y;1924 } while (y);1925 1926 if (!qty)1927 return 0;1928 1929 /*1930 * When specifying a sector range to trim, chances are we might cross1931 * an erase-group boundary even if the amount of sectors is less than1932 * one erase-group.1933 * If we can only fit one erase-group in the controller timeout budget,1934 * we have to care that erase-group boundaries are not crossed by a1935 * single trim operation. We flag that special case with "eg_boundary".1936 * In all other cases we can just decrement qty and pretend that we1937 * always touch (qty + 1) erase-groups as a simple optimization.1938 */1939 if (qty == 1)1940 card->eg_boundary = 1;1941 else1942 qty--;1943 1944 /* Convert qty to sectors */1945 if (card->erase_shift)1946 max_discard = qty << card->erase_shift;1947 else if (mmc_card_sd(card))1948 max_discard = qty + 1;1949 else1950 max_discard = qty * card->erase_size;1951 1952 return max_discard;1953}1954 1955unsigned int mmc_calc_max_discard(struct mmc_card *card)1956{1957 struct mmc_host *host = card->host;1958 unsigned int max_discard, max_trim;1959 1960 /*1961 * Without erase_group_def set, MMC erase timeout depends on clock1962 * frequence which can change. In that case, the best choice is1963 * just the preferred erase size.1964 */1965 if (mmc_card_mmc(card) && !(card->ext_csd.erase_group_def & 1))1966 return card->pref_erase;1967 1968 max_discard = mmc_do_calc_max_discard(card, MMC_ERASE_ARG);1969 if (mmc_can_trim(card)) {1970 max_trim = mmc_do_calc_max_discard(card, MMC_TRIM_ARG);1971 if (max_trim < max_discard || max_discard == 0)1972 max_discard = max_trim;1973 } else if (max_discard < card->erase_size) {1974 max_discard = 0;1975 }1976 pr_debug("%s: calculated max. discard sectors %u for timeout %u ms\n",1977 mmc_hostname(host), max_discard, host->max_busy_timeout ?1978 host->max_busy_timeout : MMC_ERASE_TIMEOUT_MS);1979 return max_discard;1980}1981EXPORT_SYMBOL(mmc_calc_max_discard);1982 1983bool mmc_card_is_blockaddr(struct mmc_card *card)1984{1985 return card ? mmc_card_blockaddr(card) : false;1986}1987EXPORT_SYMBOL(mmc_card_is_blockaddr);1988 1989int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen)1990{1991 struct mmc_command cmd = {};1992 1993 if (mmc_card_blockaddr(card) || mmc_card_ddr52(card) ||1994 mmc_card_hs400(card) || mmc_card_hs400es(card))1995 return 0;1996 1997 cmd.opcode = MMC_SET_BLOCKLEN;1998 cmd.arg = blocklen;1999 cmd.flags = MMC_RSP_SPI_R1 | MMC_RSP_R1 | MMC_CMD_AC;2000 return mmc_wait_for_cmd(card->host, &cmd, 5);2001}2002EXPORT_SYMBOL(mmc_set_blocklen);2003 2004static void mmc_hw_reset_for_init(struct mmc_host *host)2005{2006 mmc_pwrseq_reset(host);2007 2008 if (!(host->caps & MMC_CAP_HW_RESET) || !host->ops->card_hw_reset)2009 return;2010 host->ops->card_hw_reset(host);2011}2012 2013/**2014 * mmc_hw_reset - reset the card in hardware2015 * @card: card to be reset2016 *2017 * Hard reset the card. This function is only for upper layers, like the2018 * block layer or card drivers. You cannot use it in host drivers (struct2019 * mmc_card might be gone then).2020 *2021 * Return: 0 on success, -errno on failure2022 */2023int mmc_hw_reset(struct mmc_card *card)2024{2025 struct mmc_host *host = card->host;2026 int ret;2027 2028 ret = host->bus_ops->hw_reset(host);2029 if (ret < 0)2030 pr_warn("%s: tried to HW reset card, got error %d\n",2031 mmc_hostname(host), ret);2032 2033 return ret;2034}2035EXPORT_SYMBOL(mmc_hw_reset);2036 2037int mmc_sw_reset(struct mmc_card *card)2038{2039 struct mmc_host *host = card->host;2040 int ret;2041 2042 if (!host->bus_ops->sw_reset)2043 return -EOPNOTSUPP;2044 2045 ret = host->bus_ops->sw_reset(host);2046 if (ret)2047 pr_warn("%s: tried to SW reset card, got error %d\n",2048 mmc_hostname(host), ret);2049 2050 return ret;2051}2052EXPORT_SYMBOL(mmc_sw_reset);2053 2054static int mmc_rescan_try_freq(struct mmc_host *host, unsigned freq)2055{2056 host->f_init = freq;2057 2058 pr_debug("%s: %s: trying to init card at %u Hz\n",2059 mmc_hostname(host), __func__, host->f_init);2060 2061 mmc_power_up(host, host->ocr_avail);2062 2063 /*2064 * Some eMMCs (with VCCQ always on) may not be reset after power up, so2065 * do a hardware reset if possible.2066 */2067 mmc_hw_reset_for_init(host);2068 2069 /*2070 * sdio_reset sends CMD52 to reset card. Since we do not know2071 * if the card is being re-initialized, just send it. CMD522072 * should be ignored by SD/eMMC cards.2073 * Skip it if we already know that we do not support SDIO commands2074 */2075 if (!(host->caps2 & MMC_CAP2_NO_SDIO))2076 sdio_reset(host);2077 2078 mmc_go_idle(host);2079 2080 if (!(host->caps2 & MMC_CAP2_NO_SD)) {2081 if (mmc_send_if_cond_pcie(host, host->ocr_avail))2082 goto out;2083 if (mmc_card_sd_express(host))2084 return 0;2085 }2086 2087 /* Order's important: probe SDIO, then SD, then MMC */2088 if (!(host->caps2 & MMC_CAP2_NO_SDIO))2089 if (!mmc_attach_sdio(host))2090 return 0;2091 2092 if (!(host->caps2 & MMC_CAP2_NO_SD))2093 if (!mmc_attach_sd(host))2094 return 0;2095 2096 if (!(host->caps2 & MMC_CAP2_NO_MMC))2097 if (!mmc_attach_mmc(host))2098 return 0;2099 2100out:2101 mmc_power_off(host);2102 return -EIO;2103}2104 2105int _mmc_detect_card_removed(struct mmc_host *host)2106{2107 int ret;2108 2109 if (!host->card || mmc_card_removed(host->card))2110 return 1;2111 2112 ret = host->bus_ops->alive(host);2113 2114 /*2115 * Card detect status and alive check may be out of sync if card is2116 * removed slowly, when card detect switch changes while card/slot2117 * pads are still contacted in hardware (refer to "SD Card Mechanical2118 * Addendum, Appendix C: Card Detection Switch"). So reschedule a2119 * detect work 200ms later for this case.2120 */2121 if (!ret && host->ops->get_cd && !host->ops->get_cd(host)) {2122 mmc_detect_change(host, msecs_to_jiffies(200));2123 pr_debug("%s: card removed too slowly\n", mmc_hostname(host));2124 }2125 2126 if (ret) {2127 mmc_card_set_removed(host->card);2128 pr_debug("%s: card remove detected\n", mmc_hostname(host));2129 }2130 2131 return ret;2132}2133 2134int mmc_detect_card_removed(struct mmc_host *host)2135{2136 struct mmc_card *card = host->card;2137 int ret;2138 2139 WARN_ON(!host->claimed);2140 2141 if (!card)2142 return 1;2143 2144 if (!mmc_card_is_removable(host))2145 return 0;2146 2147 ret = mmc_card_removed(card);2148 /*2149 * The card will be considered unchanged unless we have been asked to2150 * detect a change or host requires polling to provide card detection.2151 */2152 if (!host->detect_change && !(host->caps & MMC_CAP_NEEDS_POLL))2153 return ret;2154 2155 host->detect_change = 0;2156 if (!ret) {2157 ret = _mmc_detect_card_removed(host);2158 if (ret && (host->caps & MMC_CAP_NEEDS_POLL)) {2159 /*2160 * Schedule a detect work as soon as possible to let a2161 * rescan handle the card removal.2162 */2163 cancel_delayed_work(&host->detect);2164 _mmc_detect_change(host, 0, false);2165 }2166 }2167 2168 return ret;2169}2170EXPORT_SYMBOL(mmc_detect_card_removed);2171 2172int mmc_card_alternative_gpt_sector(struct mmc_card *card, sector_t *gpt_sector)2173{2174 unsigned int boot_sectors_num;2175 2176 if ((!(card->host->caps2 & MMC_CAP2_ALT_GPT_TEGRA)))2177 return -EOPNOTSUPP;2178 2179 /* filter out unrelated cards */2180 if (card->ext_csd.rev < 3 ||2181 !mmc_card_mmc(card) ||2182 !mmc_card_is_blockaddr(card) ||2183 mmc_card_is_removable(card->host))2184 return -ENOENT;2185 2186 /*2187 * eMMC storage has two special boot partitions in addition to the2188 * main one. NVIDIA's bootloader linearizes eMMC boot0->boot1->main2189 * accesses, this means that the partition table addresses are shifted2190 * by the size of boot partitions. In accordance with the eMMC2191 * specification, the boot partition size is calculated as follows:2192 *2193 * boot partition size = 128K byte x BOOT_SIZE_MULT2194 *2195 * Calculate number of sectors occupied by the both boot partitions.2196 */2197 boot_sectors_num = card->ext_csd.raw_boot_mult * SZ_128K /2198 SZ_512 * MMC_NUM_BOOT_PARTITION;2199 2200 /* Defined by NVIDIA and used by Android devices. */2201 *gpt_sector = card->ext_csd.sectors - boot_sectors_num - 1;2202 2203 return 0;2204}2205EXPORT_SYMBOL(mmc_card_alternative_gpt_sector);2206 2207void mmc_rescan(struct work_struct *work)2208{2209 struct mmc_host *host =2210 container_of(work, struct mmc_host, detect.work);2211 int i;2212 2213 if (host->rescan_disable)2214 return;2215 2216 /* If there is a non-removable card registered, only scan once */2217 if (!mmc_card_is_removable(host) && host->rescan_entered)2218 return;2219 host->rescan_entered = 1;2220 2221 if (host->trigger_card_event && host->ops->card_event) {2222 mmc_claim_host(host);2223 host->ops->card_event(host);2224 mmc_release_host(host);2225 host->trigger_card_event = false;2226 }2227 2228 /* Verify a registered card to be functional, else remove it. */2229 if (host->bus_ops)2230 host->bus_ops->detect(host);2231 2232 host->detect_change = 0;2233 2234 /* if there still is a card present, stop here */2235 if (host->bus_ops != NULL)2236 goto out;2237 2238 mmc_claim_host(host);2239 if (mmc_card_is_removable(host) && host->ops->get_cd &&2240 host->ops->get_cd(host) == 0) {2241 mmc_power_off(host);2242 mmc_release_host(host);2243 goto out;2244 }2245 2246 /* If an SD express card is present, then leave it as is. */2247 if (mmc_card_sd_express(host)) {2248 mmc_release_host(host);2249 goto out;2250 }2251 2252 for (i = 0; i < ARRAY_SIZE(freqs); i++) {2253 unsigned int freq = freqs[i];2254 if (freq > host->f_max) {2255 if (i + 1 < ARRAY_SIZE(freqs))2256 continue;2257 freq = host->f_max;2258 }2259 if (!mmc_rescan_try_freq(host, max(freq, host->f_min)))2260 break;2261 if (freqs[i] <= host->f_min)2262 break;2263 }2264 2265 /* A non-removable card should have been detected by now. */2266 if (!mmc_card_is_removable(host) && !host->bus_ops)2267 pr_info("%s: Failed to initialize a non-removable card",2268 mmc_hostname(host));2269 2270 /*2271 * Ignore the command timeout errors observed during2272 * the card init as those are excepted.2273 */2274 host->err_stats[MMC_ERR_CMD_TIMEOUT] = 0;2275 mmc_release_host(host);2276 2277 out:2278 if (host->caps & MMC_CAP_NEEDS_POLL)2279 mmc_schedule_delayed_work(&host->detect, HZ);2280}2281 2282void mmc_start_host(struct mmc_host *host)2283{2284 host->f_init = max(min(freqs[0], host->f_max), host->f_min);2285 host->rescan_disable = 0;2286 2287 if (!(host->caps2 & MMC_CAP2_NO_PRESCAN_POWERUP)) {2288 mmc_claim_host(host);2289 mmc_power_up(host, host->ocr_avail);2290 mmc_release_host(host);2291 }2292 2293 mmc_gpiod_request_cd_irq(host);2294 _mmc_detect_change(host, 0, false);2295}2296 2297void __mmc_stop_host(struct mmc_host *host)2298{2299 if (host->slot.cd_irq >= 0) {2300 mmc_gpio_set_cd_wake(host, false);2301 disable_irq(host->slot.cd_irq);2302 }2303 2304 host->rescan_disable = 1;2305 cancel_delayed_work_sync(&host->detect);2306}2307 2308void mmc_stop_host(struct mmc_host *host)2309{2310 __mmc_stop_host(host);2311 2312 /* clear pm flags now and let card drivers set them as needed */2313 host->pm_flags = 0;2314 2315 if (host->bus_ops) {2316 /* Calling bus_ops->remove() with a claimed host can deadlock */2317 host->bus_ops->remove(host);2318 mmc_claim_host(host);2319 mmc_detach_bus(host);2320 mmc_power_off(host);2321 mmc_release_host(host);2322 return;2323 }2324 2325 mmc_claim_host(host);2326 mmc_power_off(host);2327 mmc_release_host(host);2328}2329 2330static int __init mmc_init(void)2331{2332 int ret;2333 2334 ret = mmc_register_bus();2335 if (ret)2336 return ret;2337 2338 ret = mmc_register_host_class();2339 if (ret)2340 goto unregister_bus;2341 2342 ret = sdio_register_bus();2343 if (ret)2344 goto unregister_host_class;2345 2346 return 0;2347 2348unregister_host_class:2349 mmc_unregister_host_class();2350unregister_bus:2351 mmc_unregister_bus();2352 return ret;2353}2354 2355static void __exit mmc_exit(void)2356{2357 sdio_unregister_bus();2358 mmc_unregister_host_class();2359 mmc_unregister_bus();2360}2361 2362subsys_initcall(mmc_init);2363module_exit(mmc_exit);2364 2365MODULE_DESCRIPTION("MMC core driver");2366MODULE_LICENSE("GPL");2367