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