LCOV - code coverage report
Current view: top level - drivers/mmc/core - core.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 359 823 43.6 %
Date: 2020-09-30 20:25:40 Functions: 40 76 52.6 %
Branches: 187 688 27.2 %

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

Generated by: LCOV version 1.14