LCOV - code coverage report
Current view: top level - drivers/mmc/core - mmc.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 909 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 62 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  *  linux/drivers/mmc/core/mmc.c
       4                 :            :  *
       5                 :            :  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
       6                 :            :  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
       7                 :            :  *  MMCv4 support Copyright (C) 2006 Philip Langdale, All Rights Reserved.
       8                 :            :  */
       9                 :            : 
      10                 :            : #include <linux/err.h>
      11                 :            : #include <linux/of.h>
      12                 :            : #include <linux/slab.h>
      13                 :            : #include <linux/stat.h>
      14                 :            : #include <linux/pm_runtime.h>
      15                 :            : 
      16                 :            : #include <linux/mmc/host.h>
      17                 :            : #include <linux/mmc/card.h>
      18                 :            : #include <linux/mmc/mmc.h>
      19                 :            : 
      20                 :            : #include "core.h"
      21                 :            : #include "card.h"
      22                 :            : #include "host.h"
      23                 :            : #include "bus.h"
      24                 :            : #include "mmc_ops.h"
      25                 :            : #include "quirks.h"
      26                 :            : #include "sd_ops.h"
      27                 :            : #include "pwrseq.h"
      28                 :            : 
      29                 :            : #define DEFAULT_CMD6_TIMEOUT_MS 500
      30                 :            : #define MIN_CACHE_EN_TIMEOUT_MS 1600
      31                 :            : 
      32                 :            : static const unsigned int tran_exp[] = {
      33                 :            :         10000,          100000,         1000000,        10000000,
      34                 :            :         0,              0,              0,              0
      35                 :            : };
      36                 :            : 
      37                 :            : static const unsigned char tran_mant[] = {
      38                 :            :         0,      10,     12,     13,     15,     20,     25,     30,
      39                 :            :         35,     40,     45,     50,     55,     60,     70,     80,
      40                 :            : };
      41                 :            : 
      42                 :            : static const unsigned int taac_exp[] = {
      43                 :            :         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
      44                 :            : };
      45                 :            : 
      46                 :            : static const unsigned int taac_mant[] = {
      47                 :            :         0,      10,     12,     13,     15,     20,     25,     30,
      48                 :            :         35,     40,     45,     50,     55,     60,     70,     80,
      49                 :            : };
      50                 :            : 
      51                 :            : #define UNSTUFF_BITS(resp,start,size)                                   \
      52                 :            :         ({                                                              \
      53                 :            :                 const int __size = size;                                \
      54                 :            :                 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1;        \
      55                 :            :                 const int __off = 3 - ((start) / 32);                   \
      56                 :            :                 const int __shft = (start) & 31;                    \
      57                 :            :                 u32 __res;                                              \
      58                 :            :                                                                         \
      59                 :            :                 __res = resp[__off] >> __shft;                            \
      60                 :            :                 if (__size + __shft > 32)                            \
      61                 :            :                         __res |= resp[__off-1] << ((32 - __shft) % 32);   \
      62                 :            :                 __res & __mask;                                             \
      63                 :            :         })
      64                 :            : 
      65                 :            : /*
      66                 :            :  * Given the decoded CSD structure, decode the raw CID to our CID structure.
      67                 :            :  */
      68                 :          0 : static int mmc_decode_cid(struct mmc_card *card)
      69                 :            : {
      70                 :            :         u32 *resp = card->raw_cid;
      71                 :            : 
      72                 :            :         /*
      73                 :            :          * The selection of the format here is based upon published
      74                 :            :          * specs from sandisk and from what people have reported.
      75                 :            :          */
      76                 :          0 :         switch (card->csd.mmca_vsn) {
      77                 :            :         case 0: /* MMC v1.0 - v1.2 */
      78                 :            :         case 1: /* MMC v1.4 */
      79                 :          0 :                 card->cid.manfid     = UNSTUFF_BITS(resp, 104, 24);
      80                 :          0 :                 card->cid.prod_name[0]       = UNSTUFF_BITS(resp, 96, 8);
      81                 :          0 :                 card->cid.prod_name[1]       = UNSTUFF_BITS(resp, 88, 8);
      82                 :          0 :                 card->cid.prod_name[2]       = UNSTUFF_BITS(resp, 80, 8);
      83                 :          0 :                 card->cid.prod_name[3]       = UNSTUFF_BITS(resp, 72, 8);
      84                 :          0 :                 card->cid.prod_name[4]       = UNSTUFF_BITS(resp, 64, 8);
      85                 :          0 :                 card->cid.prod_name[5]       = UNSTUFF_BITS(resp, 56, 8);
      86                 :          0 :                 card->cid.prod_name[6]       = UNSTUFF_BITS(resp, 48, 8);
      87                 :          0 :                 card->cid.hwrev              = UNSTUFF_BITS(resp, 44, 4);
      88                 :          0 :                 card->cid.fwrev              = UNSTUFF_BITS(resp, 40, 4);
      89                 :          0 :                 card->cid.serial     = UNSTUFF_BITS(resp, 16, 24);
      90                 :          0 :                 card->cid.month              = UNSTUFF_BITS(resp, 12, 4);
      91                 :          0 :                 card->cid.year               = UNSTUFF_BITS(resp, 8, 4) + 1997;
      92                 :          0 :                 break;
      93                 :            : 
      94                 :            :         case 2: /* MMC v2.0 - v2.2 */
      95                 :            :         case 3: /* MMC v3.1 - v3.3 */
      96                 :            :         case 4: /* MMC v4 */
      97                 :          0 :                 card->cid.manfid     = UNSTUFF_BITS(resp, 120, 8);
      98                 :          0 :                 card->cid.oemid              = UNSTUFF_BITS(resp, 104, 16);
      99                 :          0 :                 card->cid.prod_name[0]       = UNSTUFF_BITS(resp, 96, 8);
     100                 :          0 :                 card->cid.prod_name[1]       = UNSTUFF_BITS(resp, 88, 8);
     101                 :          0 :                 card->cid.prod_name[2]       = UNSTUFF_BITS(resp, 80, 8);
     102                 :          0 :                 card->cid.prod_name[3]       = UNSTUFF_BITS(resp, 72, 8);
     103                 :          0 :                 card->cid.prod_name[4]       = UNSTUFF_BITS(resp, 64, 8);
     104                 :          0 :                 card->cid.prod_name[5]       = UNSTUFF_BITS(resp, 56, 8);
     105                 :          0 :                 card->cid.prv                = UNSTUFF_BITS(resp, 48, 8);
     106                 :          0 :                 card->cid.serial     = UNSTUFF_BITS(resp, 16, 32);
     107                 :          0 :                 card->cid.month              = UNSTUFF_BITS(resp, 12, 4);
     108                 :          0 :                 card->cid.year               = UNSTUFF_BITS(resp, 8, 4) + 1997;
     109                 :          0 :                 break;
     110                 :            : 
     111                 :            :         default:
     112                 :          0 :                 pr_err("%s: card has unknown MMCA version %d\n",
     113                 :            :                         mmc_hostname(card->host), card->csd.mmca_vsn);
     114                 :          0 :                 return -EINVAL;
     115                 :            :         }
     116                 :            : 
     117                 :            :         return 0;
     118                 :            : }
     119                 :            : 
     120                 :          0 : static void mmc_set_erase_size(struct mmc_card *card)
     121                 :            : {
     122                 :          0 :         if (card->ext_csd.erase_group_def & 1)
     123                 :          0 :                 card->erase_size = card->ext_csd.hc_erase_size;
     124                 :            :         else
     125                 :          0 :                 card->erase_size = card->csd.erase_size;
     126                 :            : 
     127                 :          0 :         mmc_init_erase(card);
     128                 :          0 : }
     129                 :            : 
     130                 :            : /*
     131                 :            :  * Given a 128-bit response, decode to our card CSD structure.
     132                 :            :  */
     133                 :          0 : static int mmc_decode_csd(struct mmc_card *card)
     134                 :            : {
     135                 :            :         struct mmc_csd *csd = &card->csd;
     136                 :            :         unsigned int e, m, a, b;
     137                 :            :         u32 *resp = card->raw_csd;
     138                 :            : 
     139                 :            :         /*
     140                 :            :          * We only understand CSD structure v1.1 and v1.2.
     141                 :            :          * v1.2 has extra information in bits 15, 11 and 10.
     142                 :            :          * We also support eMMC v4.4 & v4.41.
     143                 :            :          */
     144                 :          0 :         csd->structure = UNSTUFF_BITS(resp, 126, 2);
     145                 :          0 :         if (csd->structure == 0) {
     146                 :          0 :                 pr_err("%s: unrecognised CSD structure version %d\n",
     147                 :            :                         mmc_hostname(card->host), csd->structure);
     148                 :          0 :                 return -EINVAL;
     149                 :            :         }
     150                 :            : 
     151                 :          0 :         csd->mmca_vsn         = UNSTUFF_BITS(resp, 122, 4);
     152                 :          0 :         m = UNSTUFF_BITS(resp, 115, 4);
     153                 :          0 :         e = UNSTUFF_BITS(resp, 112, 3);
     154                 :          0 :         csd->taac_ns  = (taac_exp[e] * taac_mant[m] + 9) / 10;
     155                 :          0 :         csd->taac_clks        = UNSTUFF_BITS(resp, 104, 8) * 100;
     156                 :            : 
     157                 :          0 :         m = UNSTUFF_BITS(resp, 99, 4);
     158                 :          0 :         e = UNSTUFF_BITS(resp, 96, 3);
     159                 :          0 :         csd->max_dtr   = tran_exp[e] * tran_mant[m];
     160                 :          0 :         csd->cmdclass          = UNSTUFF_BITS(resp, 84, 12);
     161                 :            : 
     162                 :          0 :         e = UNSTUFF_BITS(resp, 47, 3);
     163                 :          0 :         m = UNSTUFF_BITS(resp, 62, 12);
     164                 :          0 :         csd->capacity          = (1 + m) << (e + 2);
     165                 :            : 
     166                 :          0 :         csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
     167                 :          0 :         csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
     168                 :          0 :         csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
     169                 :          0 :         csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
     170                 :          0 :         csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
     171                 :          0 :         csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
     172                 :          0 :         csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
     173                 :          0 :         csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
     174                 :            : 
     175                 :          0 :         if (csd->write_blkbits >= 9) {
     176                 :          0 :                 a = UNSTUFF_BITS(resp, 42, 5);
     177                 :          0 :                 b = UNSTUFF_BITS(resp, 37, 5);
     178                 :          0 :                 csd->erase_size = (a + 1) * (b + 1);
     179                 :          0 :                 csd->erase_size <<= csd->write_blkbits - 9;
     180                 :            :         }
     181                 :            : 
     182                 :            :         return 0;
     183                 :            : }
     184                 :            : 
     185                 :          0 : static void mmc_select_card_type(struct mmc_card *card)
     186                 :            : {
     187                 :          0 :         struct mmc_host *host = card->host;
     188                 :          0 :         u8 card_type = card->ext_csd.raw_card_type;
     189                 :          0 :         u32 caps = host->caps, caps2 = host->caps2;
     190                 :            :         unsigned int hs_max_dtr = 0, hs200_max_dtr = 0;
     191                 :            :         unsigned int avail_type = 0;
     192                 :            : 
     193                 :          0 :         if (caps & MMC_CAP_MMC_HIGHSPEED &&
     194                 :          0 :             card_type & EXT_CSD_CARD_TYPE_HS_26) {
     195                 :            :                 hs_max_dtr = MMC_HIGH_26_MAX_DTR;
     196                 :            :                 avail_type |= EXT_CSD_CARD_TYPE_HS_26;
     197                 :            :         }
     198                 :            : 
     199                 :          0 :         if (caps & MMC_CAP_MMC_HIGHSPEED &&
     200                 :          0 :             card_type & EXT_CSD_CARD_TYPE_HS_52) {
     201                 :            :                 hs_max_dtr = MMC_HIGH_52_MAX_DTR;
     202                 :          0 :                 avail_type |= EXT_CSD_CARD_TYPE_HS_52;
     203                 :            :         }
     204                 :            : 
     205                 :          0 :         if (caps & (MMC_CAP_1_8V_DDR | MMC_CAP_3_3V_DDR) &&
     206                 :          0 :             card_type & EXT_CSD_CARD_TYPE_DDR_1_8V) {
     207                 :            :                 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
     208                 :          0 :                 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_8V;
     209                 :            :         }
     210                 :            : 
     211                 :          0 :         if (caps & MMC_CAP_1_2V_DDR &&
     212                 :          0 :             card_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
     213                 :            :                 hs_max_dtr = MMC_HIGH_DDR_MAX_DTR;
     214                 :          0 :                 avail_type |= EXT_CSD_CARD_TYPE_DDR_1_2V;
     215                 :            :         }
     216                 :            : 
     217                 :          0 :         if (caps2 & MMC_CAP2_HS200_1_8V_SDR &&
     218                 :          0 :             card_type & EXT_CSD_CARD_TYPE_HS200_1_8V) {
     219                 :            :                 hs200_max_dtr = MMC_HS200_MAX_DTR;
     220                 :          0 :                 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_8V;
     221                 :            :         }
     222                 :            : 
     223                 :          0 :         if (caps2 & MMC_CAP2_HS200_1_2V_SDR &&
     224                 :          0 :             card_type & EXT_CSD_CARD_TYPE_HS200_1_2V) {
     225                 :            :                 hs200_max_dtr = MMC_HS200_MAX_DTR;
     226                 :          0 :                 avail_type |= EXT_CSD_CARD_TYPE_HS200_1_2V;
     227                 :            :         }
     228                 :            : 
     229                 :          0 :         if (caps2 & MMC_CAP2_HS400_1_8V &&
     230                 :          0 :             card_type & EXT_CSD_CARD_TYPE_HS400_1_8V) {
     231                 :            :                 hs200_max_dtr = MMC_HS200_MAX_DTR;
     232                 :          0 :                 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_8V;
     233                 :            :         }
     234                 :            : 
     235                 :          0 :         if (caps2 & MMC_CAP2_HS400_1_2V &&
     236                 :            :             card_type & EXT_CSD_CARD_TYPE_HS400_1_2V) {
     237                 :            :                 hs200_max_dtr = MMC_HS200_MAX_DTR;
     238                 :          0 :                 avail_type |= EXT_CSD_CARD_TYPE_HS400_1_2V;
     239                 :            :         }
     240                 :            : 
     241                 :          0 :         if ((caps2 & MMC_CAP2_HS400_ES) &&
     242                 :          0 :             card->ext_csd.strobe_support &&
     243                 :          0 :             (avail_type & EXT_CSD_CARD_TYPE_HS400))
     244                 :          0 :                 avail_type |= EXT_CSD_CARD_TYPE_HS400ES;
     245                 :            : 
     246                 :          0 :         card->ext_csd.hs_max_dtr = hs_max_dtr;
     247                 :          0 :         card->ext_csd.hs200_max_dtr = hs200_max_dtr;
     248                 :          0 :         card->mmc_avail_type = avail_type;
     249                 :          0 : }
     250                 :            : 
     251                 :          0 : static void mmc_manage_enhanced_area(struct mmc_card *card, u8 *ext_csd)
     252                 :            : {
     253                 :            :         u8 hc_erase_grp_sz, hc_wp_grp_sz;
     254                 :            : 
     255                 :            :         /*
     256                 :            :          * Disable these attributes by default
     257                 :            :          */
     258                 :          0 :         card->ext_csd.enhanced_area_offset = -EINVAL;
     259                 :          0 :         card->ext_csd.enhanced_area_size = -EINVAL;
     260                 :            : 
     261                 :            :         /*
     262                 :            :          * Enhanced area feature support -- check whether the eMMC
     263                 :            :          * card has the Enhanced area enabled.  If so, export enhanced
     264                 :            :          * area offset and size to user by adding sysfs interface.
     265                 :            :          */
     266                 :          0 :         if ((ext_csd[EXT_CSD_PARTITION_SUPPORT] & 0x2) &&
     267                 :          0 :             (ext_csd[EXT_CSD_PARTITION_ATTRIBUTE] & 0x1)) {
     268                 :          0 :                 if (card->ext_csd.partition_setting_completed) {
     269                 :          0 :                         hc_erase_grp_sz =
     270                 :            :                                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
     271                 :          0 :                         hc_wp_grp_sz =
     272                 :            :                                 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
     273                 :            : 
     274                 :            :                         /*
     275                 :            :                          * calculate the enhanced data area offset, in bytes
     276                 :            :                          */
     277                 :          0 :                         card->ext_csd.enhanced_area_offset =
     278                 :          0 :                                 (((unsigned long long)ext_csd[139]) << 24) +
     279                 :          0 :                                 (((unsigned long long)ext_csd[138]) << 16) +
     280                 :          0 :                                 (((unsigned long long)ext_csd[137]) << 8) +
     281                 :          0 :                                 (((unsigned long long)ext_csd[136]));
     282                 :          0 :                         if (mmc_card_blockaddr(card))
     283                 :          0 :                                 card->ext_csd.enhanced_area_offset <<= 9;
     284                 :            :                         /*
     285                 :            :                          * calculate the enhanced data area size, in kilobytes
     286                 :            :                          */
     287                 :          0 :                         card->ext_csd.enhanced_area_size =
     288                 :          0 :                                 (ext_csd[142] << 16) + (ext_csd[141] << 8) +
     289                 :          0 :                                 ext_csd[140];
     290                 :          0 :                         card->ext_csd.enhanced_area_size *=
     291                 :          0 :                                 (size_t)(hc_erase_grp_sz * hc_wp_grp_sz);
     292                 :          0 :                         card->ext_csd.enhanced_area_size <<= 9;
     293                 :            :                 } else {
     294                 :          0 :                         pr_warn("%s: defines enhanced area without partition setting complete\n",
     295                 :            :                                 mmc_hostname(card->host));
     296                 :            :                 }
     297                 :            :         }
     298                 :          0 : }
     299                 :            : 
     300                 :            : static void mmc_part_add(struct mmc_card *card, unsigned int size,
     301                 :            :                          unsigned int part_cfg, char *name, int idx, bool ro,
     302                 :            :                          int area_type)
     303                 :            : {
     304                 :          0 :         card->part[card->nr_parts].size = size;
     305                 :          0 :         card->part[card->nr_parts].part_cfg = part_cfg;
     306                 :          0 :         sprintf(card->part[card->nr_parts].name, name, idx);
     307                 :          0 :         card->part[card->nr_parts].force_ro = ro;
     308                 :          0 :         card->part[card->nr_parts].area_type = area_type;
     309                 :          0 :         card->nr_parts++;
     310                 :            : }
     311                 :            : 
     312                 :          0 : static void mmc_manage_gp_partitions(struct mmc_card *card, u8 *ext_csd)
     313                 :            : {
     314                 :            :         int idx;
     315                 :            :         u8 hc_erase_grp_sz, hc_wp_grp_sz;
     316                 :            :         unsigned int part_size;
     317                 :            : 
     318                 :            :         /*
     319                 :            :          * General purpose partition feature support --
     320                 :            :          * If ext_csd has the size of general purpose partitions,
     321                 :            :          * set size, part_cfg, partition name in mmc_part.
     322                 :            :          */
     323                 :          0 :         if (ext_csd[EXT_CSD_PARTITION_SUPPORT] &
     324                 :            :             EXT_CSD_PART_SUPPORT_PART_EN) {
     325                 :          0 :                 hc_erase_grp_sz =
     326                 :            :                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
     327                 :          0 :                 hc_wp_grp_sz =
     328                 :            :                         ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
     329                 :            : 
     330                 :          0 :                 for (idx = 0; idx < MMC_NUM_GP_PARTITION; idx++) {
     331                 :          0 :                         if (!ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3] &&
     332                 :          0 :                             !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1] &&
     333                 :          0 :                             !ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2])
     334                 :          0 :                                 continue;
     335                 :          0 :                         if (card->ext_csd.partition_setting_completed == 0) {
     336                 :          0 :                                 pr_warn("%s: has partition size defined without partition complete\n",
     337                 :            :                                         mmc_hostname(card->host));
     338                 :          0 :                                 break;
     339                 :            :                         }
     340                 :          0 :                         part_size =
     341                 :          0 :                                 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 2]
     342                 :          0 :                                 << 16) +
     343                 :          0 :                                 (ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3 + 1]
     344                 :          0 :                                 << 8) +
     345                 :            :                                 ext_csd[EXT_CSD_GP_SIZE_MULT + idx * 3];
     346                 :          0 :                         part_size *= (size_t)(hc_erase_grp_sz *
     347                 :            :                                 hc_wp_grp_sz);
     348                 :          0 :                         mmc_part_add(card, part_size << 19,
     349                 :          0 :                                 EXT_CSD_PART_CONFIG_ACC_GP0 + idx,
     350                 :            :                                 "gp%d", idx, false,
     351                 :            :                                 MMC_BLK_DATA_AREA_GP);
     352                 :            :                 }
     353                 :            :         }
     354                 :          0 : }
     355                 :            : 
     356                 :            : /* Minimum partition switch timeout in milliseconds */
     357                 :            : #define MMC_MIN_PART_SWITCH_TIME        300
     358                 :            : 
     359                 :            : /*
     360                 :            :  * Decode extended CSD.
     361                 :            :  */
     362                 :          0 : static int mmc_decode_ext_csd(struct mmc_card *card, u8 *ext_csd)
     363                 :            : {
     364                 :            :         int err = 0, idx;
     365                 :            :         unsigned int part_size;
     366                 :            :         struct device_node *np;
     367                 :            :         bool broken_hpi = false;
     368                 :            : 
     369                 :            :         /* Version is coded in the CSD_STRUCTURE byte in the EXT_CSD register */
     370                 :          0 :         card->ext_csd.raw_ext_csd_structure = ext_csd[EXT_CSD_STRUCTURE];
     371                 :          0 :         if (card->csd.structure == 3) {
     372                 :          0 :                 if (card->ext_csd.raw_ext_csd_structure > 2) {
     373                 :          0 :                         pr_err("%s: unrecognised EXT_CSD structure "
     374                 :            :                                 "version %d\n", mmc_hostname(card->host),
     375                 :            :                                         card->ext_csd.raw_ext_csd_structure);
     376                 :            :                         err = -EINVAL;
     377                 :          0 :                         goto out;
     378                 :            :                 }
     379                 :            :         }
     380                 :            : 
     381                 :          0 :         np = mmc_of_find_child_device(card->host, 0);
     382                 :          0 :         if (np && of_device_is_compatible(np, "mmc-card"))
     383                 :            :                 broken_hpi = of_property_read_bool(np, "broken-hpi");
     384                 :          0 :         of_node_put(np);
     385                 :            : 
     386                 :            :         /*
     387                 :            :          * The EXT_CSD format is meant to be forward compatible. As long
     388                 :            :          * as CSD_STRUCTURE does not change, all values for EXT_CSD_REV
     389                 :            :          * are authorized, see JEDEC JESD84-B50 section B.8.
     390                 :            :          */
     391                 :          0 :         card->ext_csd.rev = ext_csd[EXT_CSD_REV];
     392                 :            : 
     393                 :            :         /* fixup device after ext_csd revision field is updated */
     394                 :          0 :         mmc_fixup_device(card, mmc_ext_csd_fixups);
     395                 :            : 
     396                 :          0 :         card->ext_csd.raw_sectors[0] = ext_csd[EXT_CSD_SEC_CNT + 0];
     397                 :          0 :         card->ext_csd.raw_sectors[1] = ext_csd[EXT_CSD_SEC_CNT + 1];
     398                 :          0 :         card->ext_csd.raw_sectors[2] = ext_csd[EXT_CSD_SEC_CNT + 2];
     399                 :          0 :         card->ext_csd.raw_sectors[3] = ext_csd[EXT_CSD_SEC_CNT + 3];
     400                 :          0 :         if (card->ext_csd.rev >= 2) {
     401                 :          0 :                 card->ext_csd.sectors =
     402                 :          0 :                         ext_csd[EXT_CSD_SEC_CNT + 0] << 0 |
     403                 :          0 :                         ext_csd[EXT_CSD_SEC_CNT + 1] << 8 |
     404                 :          0 :                         ext_csd[EXT_CSD_SEC_CNT + 2] << 16 |
     405                 :          0 :                         ext_csd[EXT_CSD_SEC_CNT + 3] << 24;
     406                 :            : 
     407                 :            :                 /* Cards with density > 2GiB are sector addressed */
     408                 :          0 :                 if (card->ext_csd.sectors > (2u * 1024 * 1024 * 1024) / 512)
     409                 :          0 :                         mmc_card_set_blockaddr(card);
     410                 :            :         }
     411                 :            : 
     412                 :          0 :         card->ext_csd.strobe_support = ext_csd[EXT_CSD_STROBE_SUPPORT];
     413                 :          0 :         card->ext_csd.raw_card_type = ext_csd[EXT_CSD_CARD_TYPE];
     414                 :          0 :         mmc_select_card_type(card);
     415                 :            : 
     416                 :          0 :         card->ext_csd.raw_s_a_timeout = ext_csd[EXT_CSD_S_A_TIMEOUT];
     417                 :          0 :         card->ext_csd.raw_erase_timeout_mult =
     418                 :            :                 ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
     419                 :          0 :         card->ext_csd.raw_hc_erase_grp_size =
     420                 :            :                 ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE];
     421                 :          0 :         if (card->ext_csd.rev >= 3) {
     422                 :          0 :                 u8 sa_shift = ext_csd[EXT_CSD_S_A_TIMEOUT];
     423                 :          0 :                 card->ext_csd.part_config = ext_csd[EXT_CSD_PART_CONFIG];
     424                 :            : 
     425                 :            :                 /* EXT_CSD value is in units of 10ms, but we store in ms */
     426                 :          0 :                 card->ext_csd.part_time = 10 * ext_csd[EXT_CSD_PART_SWITCH_TIME];
     427                 :            :                 /* Some eMMC set the value too low so set a minimum */
     428                 :          0 :                 if (card->ext_csd.part_time &&
     429                 :            :                     card->ext_csd.part_time < MMC_MIN_PART_SWITCH_TIME)
     430                 :          0 :                         card->ext_csd.part_time = MMC_MIN_PART_SWITCH_TIME;
     431                 :            : 
     432                 :            :                 /* Sleep / awake timeout in 100ns units */
     433                 :          0 :                 if (sa_shift > 0 && sa_shift <= 0x17)
     434                 :          0 :                         card->ext_csd.sa_timeout =
     435                 :          0 :                                         1 << ext_csd[EXT_CSD_S_A_TIMEOUT];
     436                 :          0 :                 card->ext_csd.erase_group_def =
     437                 :            :                         ext_csd[EXT_CSD_ERASE_GROUP_DEF];
     438                 :          0 :                 card->ext_csd.hc_erase_timeout = 300 *
     439                 :          0 :                         ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT];
     440                 :          0 :                 card->ext_csd.hc_erase_size =
     441                 :          0 :                         ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE] << 10;
     442                 :            : 
     443                 :          0 :                 card->ext_csd.rel_sectors = ext_csd[EXT_CSD_REL_WR_SEC_C];
     444                 :            : 
     445                 :            :                 /*
     446                 :            :                  * There are two boot regions of equal size, defined in
     447                 :            :                  * multiples of 128K.
     448                 :            :                  */
     449                 :          0 :                 if (ext_csd[EXT_CSD_BOOT_MULT] && mmc_boot_partition_access(card->host)) {
     450                 :          0 :                         for (idx = 0; idx < MMC_NUM_BOOT_PARTITION; idx++) {
     451                 :          0 :                                 part_size = ext_csd[EXT_CSD_BOOT_MULT] << 17;
     452                 :          0 :                                 mmc_part_add(card, part_size,
     453                 :          0 :                                         EXT_CSD_PART_CONFIG_ACC_BOOT0 + idx,
     454                 :            :                                         "boot%d", idx, true,
     455                 :            :                                         MMC_BLK_DATA_AREA_BOOT);
     456                 :            :                         }
     457                 :            :                 }
     458                 :            :         }
     459                 :            : 
     460                 :          0 :         card->ext_csd.raw_hc_erase_gap_size =
     461                 :            :                 ext_csd[EXT_CSD_HC_WP_GRP_SIZE];
     462                 :          0 :         card->ext_csd.raw_sec_trim_mult =
     463                 :            :                 ext_csd[EXT_CSD_SEC_TRIM_MULT];
     464                 :          0 :         card->ext_csd.raw_sec_erase_mult =
     465                 :            :                 ext_csd[EXT_CSD_SEC_ERASE_MULT];
     466                 :          0 :         card->ext_csd.raw_sec_feature_support =
     467                 :            :                 ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
     468                 :          0 :         card->ext_csd.raw_trim_mult =
     469                 :            :                 ext_csd[EXT_CSD_TRIM_MULT];
     470                 :          0 :         card->ext_csd.raw_partition_support = ext_csd[EXT_CSD_PARTITION_SUPPORT];
     471                 :          0 :         card->ext_csd.raw_driver_strength = ext_csd[EXT_CSD_DRIVER_STRENGTH];
     472                 :          0 :         if (card->ext_csd.rev >= 4) {
     473                 :          0 :                 if (ext_csd[EXT_CSD_PARTITION_SETTING_COMPLETED] &
     474                 :            :                     EXT_CSD_PART_SETTING_COMPLETED)
     475                 :          0 :                         card->ext_csd.partition_setting_completed = 1;
     476                 :            :                 else
     477                 :          0 :                         card->ext_csd.partition_setting_completed = 0;
     478                 :            : 
     479                 :          0 :                 mmc_manage_enhanced_area(card, ext_csd);
     480                 :            : 
     481                 :          0 :                 mmc_manage_gp_partitions(card, ext_csd);
     482                 :            : 
     483                 :          0 :                 card->ext_csd.sec_trim_mult =
     484                 :          0 :                         ext_csd[EXT_CSD_SEC_TRIM_MULT];
     485                 :          0 :                 card->ext_csd.sec_erase_mult =
     486                 :          0 :                         ext_csd[EXT_CSD_SEC_ERASE_MULT];
     487                 :          0 :                 card->ext_csd.sec_feature_support =
     488                 :            :                         ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT];
     489                 :          0 :                 card->ext_csd.trim_timeout = 300 *
     490                 :          0 :                         ext_csd[EXT_CSD_TRIM_MULT];
     491                 :            : 
     492                 :            :                 /*
     493                 :            :                  * Note that the call to mmc_part_add above defaults to read
     494                 :            :                  * only. If this default assumption is changed, the call must
     495                 :            :                  * take into account the value of boot_locked below.
     496                 :            :                  */
     497                 :          0 :                 card->ext_csd.boot_ro_lock = ext_csd[EXT_CSD_BOOT_WP];
     498                 :          0 :                 card->ext_csd.boot_ro_lockable = true;
     499                 :            : 
     500                 :            :                 /* Save power class values */
     501                 :          0 :                 card->ext_csd.raw_pwr_cl_52_195 =
     502                 :            :                         ext_csd[EXT_CSD_PWR_CL_52_195];
     503                 :          0 :                 card->ext_csd.raw_pwr_cl_26_195 =
     504                 :            :                         ext_csd[EXT_CSD_PWR_CL_26_195];
     505                 :          0 :                 card->ext_csd.raw_pwr_cl_52_360 =
     506                 :            :                         ext_csd[EXT_CSD_PWR_CL_52_360];
     507                 :          0 :                 card->ext_csd.raw_pwr_cl_26_360 =
     508                 :            :                         ext_csd[EXT_CSD_PWR_CL_26_360];
     509                 :          0 :                 card->ext_csd.raw_pwr_cl_200_195 =
     510                 :            :                         ext_csd[EXT_CSD_PWR_CL_200_195];
     511                 :          0 :                 card->ext_csd.raw_pwr_cl_200_360 =
     512                 :            :                         ext_csd[EXT_CSD_PWR_CL_200_360];
     513                 :          0 :                 card->ext_csd.raw_pwr_cl_ddr_52_195 =
     514                 :            :                         ext_csd[EXT_CSD_PWR_CL_DDR_52_195];
     515                 :          0 :                 card->ext_csd.raw_pwr_cl_ddr_52_360 =
     516                 :            :                         ext_csd[EXT_CSD_PWR_CL_DDR_52_360];
     517                 :          0 :                 card->ext_csd.raw_pwr_cl_ddr_200_360 =
     518                 :            :                         ext_csd[EXT_CSD_PWR_CL_DDR_200_360];
     519                 :            :         }
     520                 :            : 
     521                 :          0 :         if (card->ext_csd.rev >= 5) {
     522                 :            :                 /* Adjust production date as per JEDEC JESD84-B451 */
     523                 :          0 :                 if (card->cid.year < 2010)
     524                 :          0 :                         card->cid.year += 16;
     525                 :            : 
     526                 :            :                 /* check whether the eMMC card supports BKOPS */
     527                 :          0 :                 if (ext_csd[EXT_CSD_BKOPS_SUPPORT] & 0x1) {
     528                 :          0 :                         card->ext_csd.bkops = 1;
     529                 :          0 :                         card->ext_csd.man_bkops_en =
     530                 :          0 :                                         (ext_csd[EXT_CSD_BKOPS_EN] &
     531                 :            :                                                 EXT_CSD_MANUAL_BKOPS_MASK);
     532                 :          0 :                         card->ext_csd.raw_bkops_status =
     533                 :            :                                 ext_csd[EXT_CSD_BKOPS_STATUS];
     534                 :            :                         if (card->ext_csd.man_bkops_en)
     535                 :            :                                 pr_debug("%s: MAN_BKOPS_EN bit is set\n",
     536                 :            :                                         mmc_hostname(card->host));
     537                 :          0 :                         card->ext_csd.auto_bkops_en =
     538                 :          0 :                                         (ext_csd[EXT_CSD_BKOPS_EN] &
     539                 :            :                                                 EXT_CSD_AUTO_BKOPS_MASK);
     540                 :            :                         if (card->ext_csd.auto_bkops_en)
     541                 :            :                                 pr_debug("%s: AUTO_BKOPS_EN bit is set\n",
     542                 :            :                                         mmc_hostname(card->host));
     543                 :            :                 }
     544                 :            : 
     545                 :            :                 /* check whether the eMMC card supports HPI */
     546                 :          0 :                 if (!mmc_card_broken_hpi(card) &&
     547                 :          0 :                     !broken_hpi && (ext_csd[EXT_CSD_HPI_FEATURES] & 0x1)) {
     548                 :          0 :                         card->ext_csd.hpi = 1;
     549                 :          0 :                         if (ext_csd[EXT_CSD_HPI_FEATURES] & 0x2)
     550                 :          0 :                                 card->ext_csd.hpi_cmd =      MMC_STOP_TRANSMISSION;
     551                 :            :                         else
     552                 :          0 :                                 card->ext_csd.hpi_cmd = MMC_SEND_STATUS;
     553                 :            :                         /*
     554                 :            :                          * Indicate the maximum timeout to close
     555                 :            :                          * a command interrupted by HPI
     556                 :            :                          */
     557                 :          0 :                         card->ext_csd.out_of_int_time =
     558                 :          0 :                                 ext_csd[EXT_CSD_OUT_OF_INTERRUPT_TIME] * 10;
     559                 :            :                 }
     560                 :            : 
     561                 :          0 :                 card->ext_csd.rel_param = ext_csd[EXT_CSD_WR_REL_PARAM];
     562                 :          0 :                 card->ext_csd.rst_n_function = ext_csd[EXT_CSD_RST_N_FUNCTION];
     563                 :            : 
     564                 :            :                 /*
     565                 :            :                  * RPMB regions are defined in multiples of 128K.
     566                 :            :                  */
     567                 :          0 :                 card->ext_csd.raw_rpmb_size_mult = ext_csd[EXT_CSD_RPMB_MULT];
     568                 :          0 :                 if (ext_csd[EXT_CSD_RPMB_MULT] && mmc_host_cmd23(card->host)) {
     569                 :          0 :                         mmc_part_add(card, ext_csd[EXT_CSD_RPMB_MULT] << 17,
     570                 :            :                                 EXT_CSD_PART_CONFIG_ACC_RPMB,
     571                 :            :                                 "rpmb", 0, false,
     572                 :            :                                 MMC_BLK_DATA_AREA_RPMB);
     573                 :            :                 }
     574                 :            :         }
     575                 :            : 
     576                 :          0 :         card->ext_csd.raw_erased_mem_count = ext_csd[EXT_CSD_ERASED_MEM_CONT];
     577                 :          0 :         if (ext_csd[EXT_CSD_ERASED_MEM_CONT])
     578                 :          0 :                 card->erased_byte = 0xFF;
     579                 :            :         else
     580                 :          0 :                 card->erased_byte = 0x0;
     581                 :            : 
     582                 :            :         /* eMMC v4.5 or later */
     583                 :          0 :         card->ext_csd.generic_cmd6_time = DEFAULT_CMD6_TIMEOUT_MS;
     584                 :          0 :         if (card->ext_csd.rev >= 6) {
     585                 :          0 :                 card->ext_csd.feature_support |= MMC_DISCARD_FEATURE;
     586                 :            : 
     587                 :          0 :                 card->ext_csd.generic_cmd6_time = 10 *
     588                 :          0 :                         ext_csd[EXT_CSD_GENERIC_CMD6_TIME];
     589                 :          0 :                 card->ext_csd.power_off_longtime = 10 *
     590                 :          0 :                         ext_csd[EXT_CSD_POWER_OFF_LONG_TIME];
     591                 :            : 
     592                 :          0 :                 card->ext_csd.cache_size =
     593                 :          0 :                         ext_csd[EXT_CSD_CACHE_SIZE + 0] << 0 |
     594                 :          0 :                         ext_csd[EXT_CSD_CACHE_SIZE + 1] << 8 |
     595                 :          0 :                         ext_csd[EXT_CSD_CACHE_SIZE + 2] << 16 |
     596                 :          0 :                         ext_csd[EXT_CSD_CACHE_SIZE + 3] << 24;
     597                 :            : 
     598                 :          0 :                 if (ext_csd[EXT_CSD_DATA_SECTOR_SIZE] == 1)
     599                 :          0 :                         card->ext_csd.data_sector_size = 4096;
     600                 :            :                 else
     601                 :          0 :                         card->ext_csd.data_sector_size = 512;
     602                 :            : 
     603                 :          0 :                 if ((ext_csd[EXT_CSD_DATA_TAG_SUPPORT] & 1) &&
     604                 :          0 :                     (ext_csd[EXT_CSD_TAG_UNIT_SIZE] <= 8)) {
     605                 :          0 :                         card->ext_csd.data_tag_unit_size =
     606                 :          0 :                         ((unsigned int) 1 << ext_csd[EXT_CSD_TAG_UNIT_SIZE]) *
     607                 :          0 :                         (card->ext_csd.data_sector_size);
     608                 :            :                 } else {
     609                 :          0 :                         card->ext_csd.data_tag_unit_size = 0;
     610                 :            :                 }
     611                 :            : 
     612                 :          0 :                 card->ext_csd.max_packed_writes =
     613                 :            :                         ext_csd[EXT_CSD_MAX_PACKED_WRITES];
     614                 :          0 :                 card->ext_csd.max_packed_reads =
     615                 :            :                         ext_csd[EXT_CSD_MAX_PACKED_READS];
     616                 :            :         } else {
     617                 :          0 :                 card->ext_csd.data_sector_size = 512;
     618                 :            :         }
     619                 :            : 
     620                 :            :         /* eMMC v5 or later */
     621                 :          0 :         if (card->ext_csd.rev >= 7) {
     622                 :          0 :                 memcpy(card->ext_csd.fwrev, &ext_csd[EXT_CSD_FIRMWARE_VERSION],
     623                 :            :                        MMC_FIRMWARE_LEN);
     624                 :          0 :                 card->ext_csd.ffu_capable =
     625                 :          0 :                         (ext_csd[EXT_CSD_SUPPORTED_MODE] & 0x1) &&
     626                 :          0 :                         !(ext_csd[EXT_CSD_FW_CONFIG] & 0x1);
     627                 :            : 
     628                 :          0 :                 card->ext_csd.pre_eol_info = ext_csd[EXT_CSD_PRE_EOL_INFO];
     629                 :          0 :                 card->ext_csd.device_life_time_est_typ_a =
     630                 :            :                         ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_A];
     631                 :          0 :                 card->ext_csd.device_life_time_est_typ_b =
     632                 :            :                         ext_csd[EXT_CSD_DEVICE_LIFE_TIME_EST_TYP_B];
     633                 :            :         }
     634                 :            : 
     635                 :            :         /* eMMC v5.1 or later */
     636                 :          0 :         if (card->ext_csd.rev >= 8) {
     637                 :          0 :                 card->ext_csd.cmdq_support = ext_csd[EXT_CSD_CMDQ_SUPPORT] &
     638                 :            :                                              EXT_CSD_CMDQ_SUPPORTED;
     639                 :          0 :                 card->ext_csd.cmdq_depth = (ext_csd[EXT_CSD_CMDQ_DEPTH] &
     640                 :          0 :                                             EXT_CSD_CMDQ_DEPTH_MASK) + 1;
     641                 :            :                 /* Exclude inefficiently small queue depths */
     642                 :          0 :                 if (card->ext_csd.cmdq_depth <= 2) {
     643                 :          0 :                         card->ext_csd.cmdq_support = false;
     644                 :          0 :                         card->ext_csd.cmdq_depth = 0;
     645                 :            :                 }
     646                 :            :                 if (card->ext_csd.cmdq_support) {
     647                 :            :                         pr_debug("%s: Command Queue supported depth %u\n",
     648                 :            :                                  mmc_hostname(card->host),
     649                 :            :                                  card->ext_csd.cmdq_depth);
     650                 :            :                 }
     651                 :            :         }
     652                 :            : out:
     653                 :          0 :         return err;
     654                 :            : }
     655                 :            : 
     656                 :          0 : static int mmc_read_ext_csd(struct mmc_card *card)
     657                 :            : {
     658                 :            :         u8 *ext_csd;
     659                 :            :         int err;
     660                 :            : 
     661                 :          0 :         if (!mmc_can_ext_csd(card))
     662                 :            :                 return 0;
     663                 :            : 
     664                 :          0 :         err = mmc_get_ext_csd(card, &ext_csd);
     665                 :          0 :         if (err) {
     666                 :            :                 /* If the host or the card can't do the switch,
     667                 :            :                  * fail more gracefully. */
     668                 :          0 :                 if ((err != -EINVAL)
     669                 :          0 :                  && (err != -ENOSYS)
     670                 :          0 :                  && (err != -EFAULT))
     671                 :            :                         return err;
     672                 :            : 
     673                 :            :                 /*
     674                 :            :                  * High capacity cards should have this "magic" size
     675                 :            :                  * stored in their CSD.
     676                 :            :                  */
     677                 :          0 :                 if (card->csd.capacity == (4096 * 512)) {
     678                 :          0 :                         pr_err("%s: unable to read EXT_CSD on a possible high capacity card. Card will be ignored.\n",
     679                 :            :                                 mmc_hostname(card->host));
     680                 :            :                 } else {
     681                 :          0 :                         pr_warn("%s: unable to read EXT_CSD, performance might suffer\n",
     682                 :            :                                 mmc_hostname(card->host));
     683                 :            :                         err = 0;
     684                 :            :                 }
     685                 :            : 
     686                 :          0 :                 return err;
     687                 :            :         }
     688                 :            : 
     689                 :          0 :         err = mmc_decode_ext_csd(card, ext_csd);
     690                 :          0 :         kfree(ext_csd);
     691                 :          0 :         return err;
     692                 :            : }
     693                 :            : 
     694                 :          0 : static int mmc_compare_ext_csds(struct mmc_card *card, unsigned bus_width)
     695                 :            : {
     696                 :            :         u8 *bw_ext_csd;
     697                 :            :         int err;
     698                 :            : 
     699                 :          0 :         if (bus_width == MMC_BUS_WIDTH_1)
     700                 :            :                 return 0;
     701                 :            : 
     702                 :          0 :         err = mmc_get_ext_csd(card, &bw_ext_csd);
     703                 :          0 :         if (err)
     704                 :            :                 return err;
     705                 :            : 
     706                 :            :         /* only compare read only fields */
     707                 :          0 :         err = !((card->ext_csd.raw_partition_support ==
     708                 :          0 :                         bw_ext_csd[EXT_CSD_PARTITION_SUPPORT]) &&
     709                 :          0 :                 (card->ext_csd.raw_erased_mem_count ==
     710                 :          0 :                         bw_ext_csd[EXT_CSD_ERASED_MEM_CONT]) &&
     711                 :          0 :                 (card->ext_csd.rev ==
     712                 :          0 :                         bw_ext_csd[EXT_CSD_REV]) &&
     713                 :          0 :                 (card->ext_csd.raw_ext_csd_structure ==
     714                 :          0 :                         bw_ext_csd[EXT_CSD_STRUCTURE]) &&
     715                 :          0 :                 (card->ext_csd.raw_card_type ==
     716                 :          0 :                         bw_ext_csd[EXT_CSD_CARD_TYPE]) &&
     717                 :          0 :                 (card->ext_csd.raw_s_a_timeout ==
     718                 :          0 :                         bw_ext_csd[EXT_CSD_S_A_TIMEOUT]) &&
     719                 :          0 :                 (card->ext_csd.raw_hc_erase_gap_size ==
     720                 :          0 :                         bw_ext_csd[EXT_CSD_HC_WP_GRP_SIZE]) &&
     721                 :          0 :                 (card->ext_csd.raw_erase_timeout_mult ==
     722                 :          0 :                         bw_ext_csd[EXT_CSD_ERASE_TIMEOUT_MULT]) &&
     723                 :          0 :                 (card->ext_csd.raw_hc_erase_grp_size ==
     724                 :          0 :                         bw_ext_csd[EXT_CSD_HC_ERASE_GRP_SIZE]) &&
     725                 :          0 :                 (card->ext_csd.raw_sec_trim_mult ==
     726                 :          0 :                         bw_ext_csd[EXT_CSD_SEC_TRIM_MULT]) &&
     727                 :          0 :                 (card->ext_csd.raw_sec_erase_mult ==
     728                 :          0 :                         bw_ext_csd[EXT_CSD_SEC_ERASE_MULT]) &&
     729                 :          0 :                 (card->ext_csd.raw_sec_feature_support ==
     730                 :          0 :                         bw_ext_csd[EXT_CSD_SEC_FEATURE_SUPPORT]) &&
     731                 :          0 :                 (card->ext_csd.raw_trim_mult ==
     732                 :          0 :                         bw_ext_csd[EXT_CSD_TRIM_MULT]) &&
     733                 :          0 :                 (card->ext_csd.raw_sectors[0] ==
     734                 :          0 :                         bw_ext_csd[EXT_CSD_SEC_CNT + 0]) &&
     735                 :          0 :                 (card->ext_csd.raw_sectors[1] ==
     736                 :          0 :                         bw_ext_csd[EXT_CSD_SEC_CNT + 1]) &&
     737                 :          0 :                 (card->ext_csd.raw_sectors[2] ==
     738                 :          0 :                         bw_ext_csd[EXT_CSD_SEC_CNT + 2]) &&
     739                 :          0 :                 (card->ext_csd.raw_sectors[3] ==
     740                 :          0 :                         bw_ext_csd[EXT_CSD_SEC_CNT + 3]) &&
     741                 :          0 :                 (card->ext_csd.raw_pwr_cl_52_195 ==
     742                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_52_195]) &&
     743                 :          0 :                 (card->ext_csd.raw_pwr_cl_26_195 ==
     744                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_26_195]) &&
     745                 :          0 :                 (card->ext_csd.raw_pwr_cl_52_360 ==
     746                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_52_360]) &&
     747                 :          0 :                 (card->ext_csd.raw_pwr_cl_26_360 ==
     748                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_26_360]) &&
     749                 :          0 :                 (card->ext_csd.raw_pwr_cl_200_195 ==
     750                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_200_195]) &&
     751                 :          0 :                 (card->ext_csd.raw_pwr_cl_200_360 ==
     752                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_200_360]) &&
     753                 :          0 :                 (card->ext_csd.raw_pwr_cl_ddr_52_195 ==
     754                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_195]) &&
     755                 :          0 :                 (card->ext_csd.raw_pwr_cl_ddr_52_360 ==
     756                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_52_360]) &&
     757                 :          0 :                 (card->ext_csd.raw_pwr_cl_ddr_200_360 ==
     758                 :          0 :                         bw_ext_csd[EXT_CSD_PWR_CL_DDR_200_360]));
     759                 :            : 
     760                 :          0 :         if (err)
     761                 :            :                 err = -EINVAL;
     762                 :            : 
     763                 :          0 :         kfree(bw_ext_csd);
     764                 :          0 :         return err;
     765                 :            : }
     766                 :            : 
     767                 :          0 : MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
     768                 :            :         card->raw_cid[2], card->raw_cid[3]);
     769                 :          0 : MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
     770                 :            :         card->raw_csd[2], card->raw_csd[3]);
     771                 :          0 : MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
     772                 :          0 : MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
     773                 :          0 : MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
     774                 :          0 : MMC_DEV_ATTR(ffu_capable, "%d\n", card->ext_csd.ffu_capable);
     775                 :          0 : MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
     776                 :          0 : MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
     777                 :          0 : MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
     778                 :          0 : MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
     779                 :          0 : MMC_DEV_ATTR(prv, "0x%x\n", card->cid.prv);
     780                 :          0 : MMC_DEV_ATTR(rev, "0x%x\n", card->ext_csd.rev);
     781                 :          0 : MMC_DEV_ATTR(pre_eol_info, "0x%02x\n", card->ext_csd.pre_eol_info);
     782                 :          0 : MMC_DEV_ATTR(life_time, "0x%02x 0x%02x\n",
     783                 :            :         card->ext_csd.device_life_time_est_typ_a,
     784                 :            :         card->ext_csd.device_life_time_est_typ_b);
     785                 :          0 : MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
     786                 :          0 : MMC_DEV_ATTR(enhanced_area_offset, "%llu\n",
     787                 :            :                 card->ext_csd.enhanced_area_offset);
     788                 :          0 : MMC_DEV_ATTR(enhanced_area_size, "%u\n", card->ext_csd.enhanced_area_size);
     789                 :          0 : MMC_DEV_ATTR(raw_rpmb_size_mult, "%#x\n", card->ext_csd.raw_rpmb_size_mult);
     790                 :          0 : MMC_DEV_ATTR(rel_sectors, "%#x\n", card->ext_csd.rel_sectors);
     791                 :          0 : MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
     792                 :          0 : MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
     793                 :          0 : MMC_DEV_ATTR(cmdq_en, "%d\n", card->ext_csd.cmdq_en);
     794                 :            : 
     795                 :          0 : static ssize_t mmc_fwrev_show(struct device *dev,
     796                 :            :                               struct device_attribute *attr,
     797                 :            :                               char *buf)
     798                 :            : {
     799                 :            :         struct mmc_card *card = mmc_dev_to_card(dev);
     800                 :            : 
     801                 :          0 :         if (card->ext_csd.rev < 7) {
     802                 :          0 :                 return sprintf(buf, "0x%x\n", card->cid.fwrev);
     803                 :            :         } else {
     804                 :          0 :                 return sprintf(buf, "0x%*phN\n", MMC_FIRMWARE_LEN,
     805                 :          0 :                                card->ext_csd.fwrev);
     806                 :            :         }
     807                 :            : }
     808                 :            : 
     809                 :            : static DEVICE_ATTR(fwrev, S_IRUGO, mmc_fwrev_show, NULL);
     810                 :            : 
     811                 :          0 : static ssize_t mmc_dsr_show(struct device *dev,
     812                 :            :                             struct device_attribute *attr,
     813                 :            :                             char *buf)
     814                 :            : {
     815                 :            :         struct mmc_card *card = mmc_dev_to_card(dev);
     816                 :          0 :         struct mmc_host *host = card->host;
     817                 :            : 
     818                 :          0 :         if (card->csd.dsr_imp && host->dsr_req)
     819                 :          0 :                 return sprintf(buf, "0x%x\n", host->dsr);
     820                 :            :         else
     821                 :            :                 /* return default DSR value */
     822                 :          0 :                 return sprintf(buf, "0x%x\n", 0x404);
     823                 :            : }
     824                 :            : 
     825                 :            : static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
     826                 :            : 
     827                 :            : static struct attribute *mmc_std_attrs[] = {
     828                 :            :         &dev_attr_cid.attr,
     829                 :            :         &dev_attr_csd.attr,
     830                 :            :         &dev_attr_date.attr,
     831                 :            :         &dev_attr_erase_size.attr,
     832                 :            :         &dev_attr_preferred_erase_size.attr,
     833                 :            :         &dev_attr_fwrev.attr,
     834                 :            :         &dev_attr_ffu_capable.attr,
     835                 :            :         &dev_attr_hwrev.attr,
     836                 :            :         &dev_attr_manfid.attr,
     837                 :            :         &dev_attr_name.attr,
     838                 :            :         &dev_attr_oemid.attr,
     839                 :            :         &dev_attr_prv.attr,
     840                 :            :         &dev_attr_rev.attr,
     841                 :            :         &dev_attr_pre_eol_info.attr,
     842                 :            :         &dev_attr_life_time.attr,
     843                 :            :         &dev_attr_serial.attr,
     844                 :            :         &dev_attr_enhanced_area_offset.attr,
     845                 :            :         &dev_attr_enhanced_area_size.attr,
     846                 :            :         &dev_attr_raw_rpmb_size_mult.attr,
     847                 :            :         &dev_attr_rel_sectors.attr,
     848                 :            :         &dev_attr_ocr.attr,
     849                 :            :         &dev_attr_rca.attr,
     850                 :            :         &dev_attr_dsr.attr,
     851                 :            :         &dev_attr_cmdq_en.attr,
     852                 :            :         NULL,
     853                 :            : };
     854                 :            : ATTRIBUTE_GROUPS(mmc_std);
     855                 :            : 
     856                 :            : static struct device_type mmc_type = {
     857                 :            :         .groups = mmc_std_groups,
     858                 :            : };
     859                 :            : 
     860                 :            : /*
     861                 :            :  * Select the PowerClass for the current bus width
     862                 :            :  * If power class is defined for 4/8 bit bus in the
     863                 :            :  * extended CSD register, select it by executing the
     864                 :            :  * mmc_switch command.
     865                 :            :  */
     866                 :          0 : static int __mmc_select_powerclass(struct mmc_card *card,
     867                 :            :                                    unsigned int bus_width)
     868                 :            : {
     869                 :          0 :         struct mmc_host *host = card->host;
     870                 :            :         struct mmc_ext_csd *ext_csd = &card->ext_csd;
     871                 :            :         unsigned int pwrclass_val = 0;
     872                 :            :         int err = 0;
     873                 :            : 
     874                 :          0 :         switch (1 << host->ios.vdd) {
     875                 :            :         case MMC_VDD_165_195:
     876                 :          0 :                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
     877                 :          0 :                         pwrclass_val = ext_csd->raw_pwr_cl_26_195;
     878                 :          0 :                 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
     879                 :          0 :                         pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
     880                 :          0 :                                 ext_csd->raw_pwr_cl_52_195 :
     881                 :          0 :                                 ext_csd->raw_pwr_cl_ddr_52_195;
     882                 :          0 :                 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
     883                 :          0 :                         pwrclass_val = ext_csd->raw_pwr_cl_200_195;
     884                 :            :                 break;
     885                 :            :         case MMC_VDD_27_28:
     886                 :            :         case MMC_VDD_28_29:
     887                 :            :         case MMC_VDD_29_30:
     888                 :            :         case MMC_VDD_30_31:
     889                 :            :         case MMC_VDD_31_32:
     890                 :            :         case MMC_VDD_32_33:
     891                 :            :         case MMC_VDD_33_34:
     892                 :            :         case MMC_VDD_34_35:
     893                 :            :         case MMC_VDD_35_36:
     894                 :          0 :                 if (host->ios.clock <= MMC_HIGH_26_MAX_DTR)
     895                 :          0 :                         pwrclass_val = ext_csd->raw_pwr_cl_26_360;
     896                 :          0 :                 else if (host->ios.clock <= MMC_HIGH_52_MAX_DTR)
     897                 :          0 :                         pwrclass_val = (bus_width <= EXT_CSD_BUS_WIDTH_8) ?
     898                 :          0 :                                 ext_csd->raw_pwr_cl_52_360 :
     899                 :          0 :                                 ext_csd->raw_pwr_cl_ddr_52_360;
     900                 :          0 :                 else if (host->ios.clock <= MMC_HS200_MAX_DTR)
     901                 :          0 :                         pwrclass_val = (bus_width == EXT_CSD_DDR_BUS_WIDTH_8) ?
     902                 :          0 :                                 ext_csd->raw_pwr_cl_ddr_200_360 :
     903                 :          0 :                                 ext_csd->raw_pwr_cl_200_360;
     904                 :            :                 break;
     905                 :            :         default:
     906                 :          0 :                 pr_warn("%s: Voltage range not supported for power class\n",
     907                 :            :                         mmc_hostname(host));
     908                 :          0 :                 return -EINVAL;
     909                 :            :         }
     910                 :            : 
     911                 :          0 :         if (bus_width & (EXT_CSD_BUS_WIDTH_8 | EXT_CSD_DDR_BUS_WIDTH_8))
     912                 :          0 :                 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_8BIT_MASK) >>
     913                 :            :                                 EXT_CSD_PWR_CL_8BIT_SHIFT;
     914                 :            :         else
     915                 :          0 :                 pwrclass_val = (pwrclass_val & EXT_CSD_PWR_CL_4BIT_MASK) >>
     916                 :            :                                 EXT_CSD_PWR_CL_4BIT_SHIFT;
     917                 :            : 
     918                 :            :         /* If the power class is different from the default value */
     919                 :          0 :         if (pwrclass_val > 0) {
     920                 :          0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
     921                 :            :                                  EXT_CSD_POWER_CLASS,
     922                 :            :                                  pwrclass_val,
     923                 :            :                                  card->ext_csd.generic_cmd6_time);
     924                 :            :         }
     925                 :            : 
     926                 :          0 :         return err;
     927                 :            : }
     928                 :            : 
     929                 :          0 : static int mmc_select_powerclass(struct mmc_card *card)
     930                 :            : {
     931                 :          0 :         struct mmc_host *host = card->host;
     932                 :            :         u32 bus_width, ext_csd_bits;
     933                 :            :         int err, ddr;
     934                 :            : 
     935                 :            :         /* Power class selection is supported for versions >= 4.0 */
     936                 :          0 :         if (!mmc_can_ext_csd(card))
     937                 :            :                 return 0;
     938                 :            : 
     939                 :          0 :         bus_width = host->ios.bus_width;
     940                 :            :         /* Power class values are defined only for 4/8 bit bus */
     941                 :          0 :         if (bus_width == MMC_BUS_WIDTH_1)
     942                 :            :                 return 0;
     943                 :            : 
     944                 :          0 :         ddr = card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52;
     945                 :          0 :         if (ddr)
     946                 :          0 :                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
     947                 :            :                         EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
     948                 :            :         else
     949                 :          0 :                 ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
     950                 :            :                         EXT_CSD_BUS_WIDTH_8 :  EXT_CSD_BUS_WIDTH_4;
     951                 :            : 
     952                 :          0 :         err = __mmc_select_powerclass(card, ext_csd_bits);
     953                 :          0 :         if (err)
     954                 :          0 :                 pr_warn("%s: power class selection to bus width %d ddr %d failed\n",
     955                 :            :                         mmc_hostname(host), 1 << bus_width, ddr);
     956                 :            : 
     957                 :          0 :         return err;
     958                 :            : }
     959                 :            : 
     960                 :            : /*
     961                 :            :  * Set the bus speed for the selected speed mode.
     962                 :            :  */
     963                 :          0 : static void mmc_set_bus_speed(struct mmc_card *card)
     964                 :            : {
     965                 :            :         unsigned int max_dtr = (unsigned int)-1;
     966                 :            : 
     967                 :          0 :         if ((mmc_card_hs200(card) || mmc_card_hs400(card)) &&
     968                 :          0 :              max_dtr > card->ext_csd.hs200_max_dtr)
     969                 :            :                 max_dtr = card->ext_csd.hs200_max_dtr;
     970                 :          0 :         else if (mmc_card_hs(card) && max_dtr > card->ext_csd.hs_max_dtr)
     971                 :            :                 max_dtr = card->ext_csd.hs_max_dtr;
     972                 :          0 :         else if (max_dtr > card->csd.max_dtr)
     973                 :            :                 max_dtr = card->csd.max_dtr;
     974                 :            : 
     975                 :          0 :         mmc_set_clock(card->host, max_dtr);
     976                 :          0 : }
     977                 :            : 
     978                 :            : /*
     979                 :            :  * Select the bus width amoung 4-bit and 8-bit(SDR).
     980                 :            :  * If the bus width is changed successfully, return the selected width value.
     981                 :            :  * Zero is returned instead of error value if the wide width is not supported.
     982                 :            :  */
     983                 :          0 : static int mmc_select_bus_width(struct mmc_card *card)
     984                 :            : {
     985                 :            :         static unsigned ext_csd_bits[] = {
     986                 :            :                 EXT_CSD_BUS_WIDTH_8,
     987                 :            :                 EXT_CSD_BUS_WIDTH_4,
     988                 :            :         };
     989                 :            :         static unsigned bus_widths[] = {
     990                 :            :                 MMC_BUS_WIDTH_8,
     991                 :            :                 MMC_BUS_WIDTH_4,
     992                 :            :         };
     993                 :          0 :         struct mmc_host *host = card->host;
     994                 :            :         unsigned idx, bus_width = 0;
     995                 :            :         int err = 0;
     996                 :            : 
     997                 :          0 :         if (!mmc_can_ext_csd(card) ||
     998                 :          0 :             !(host->caps & (MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA)))
     999                 :            :                 return 0;
    1000                 :            : 
    1001                 :          0 :         idx = (host->caps & MMC_CAP_8_BIT_DATA) ? 0 : 1;
    1002                 :            : 
    1003                 :            :         /*
    1004                 :            :          * Unlike SD, MMC cards dont have a configuration register to notify
    1005                 :            :          * supported bus width. So bus test command should be run to identify
    1006                 :            :          * the supported bus width or compare the ext csd values of current
    1007                 :            :          * bus width and ext csd values of 1 bit mode read earlier.
    1008                 :            :          */
    1009                 :          0 :         for (; idx < ARRAY_SIZE(bus_widths); idx++) {
    1010                 :            :                 /*
    1011                 :            :                  * Host is capable of 8bit transfer, then switch
    1012                 :            :                  * the device to work in 8bit transfer mode. If the
    1013                 :            :                  * mmc switch command returns error then switch to
    1014                 :            :                  * 4bit transfer mode. On success set the corresponding
    1015                 :            :                  * bus width on the host.
    1016                 :            :                  */
    1017                 :          0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1018                 :            :                                  EXT_CSD_BUS_WIDTH,
    1019                 :          0 :                                  ext_csd_bits[idx],
    1020                 :            :                                  card->ext_csd.generic_cmd6_time);
    1021                 :          0 :                 if (err)
    1022                 :          0 :                         continue;
    1023                 :            : 
    1024                 :          0 :                 bus_width = bus_widths[idx];
    1025                 :          0 :                 mmc_set_bus_width(host, bus_width);
    1026                 :            : 
    1027                 :            :                 /*
    1028                 :            :                  * If controller can't handle bus width test,
    1029                 :            :                  * compare ext_csd previously read in 1 bit mode
    1030                 :            :                  * against ext_csd at new bus width
    1031                 :            :                  */
    1032                 :          0 :                 if (!(host->caps & MMC_CAP_BUS_WIDTH_TEST))
    1033                 :          0 :                         err = mmc_compare_ext_csds(card, bus_width);
    1034                 :            :                 else
    1035                 :          0 :                         err = mmc_bus_test(card, bus_width);
    1036                 :            : 
    1037                 :          0 :                 if (!err) {
    1038                 :          0 :                         err = bus_width;
    1039                 :          0 :                         break;
    1040                 :            :                 } else {
    1041                 :          0 :                         pr_warn("%s: switch to bus width %d failed\n",
    1042                 :            :                                 mmc_hostname(host), 1 << bus_width);
    1043                 :            :                 }
    1044                 :            :         }
    1045                 :            : 
    1046                 :          0 :         return err;
    1047                 :            : }
    1048                 :            : 
    1049                 :            : /*
    1050                 :            :  * Switch to the high-speed mode
    1051                 :            :  */
    1052                 :          0 : static int mmc_select_hs(struct mmc_card *card)
    1053                 :            : {
    1054                 :            :         int err;
    1055                 :            : 
    1056                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1057                 :            :                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
    1058                 :            :                            card->ext_csd.generic_cmd6_time, MMC_TIMING_MMC_HS,
    1059                 :            :                            true, true, true);
    1060                 :          0 :         if (err)
    1061                 :          0 :                 pr_warn("%s: switch to high-speed failed, err:%d\n",
    1062                 :            :                         mmc_hostname(card->host), err);
    1063                 :            : 
    1064                 :          0 :         return err;
    1065                 :            : }
    1066                 :            : 
    1067                 :            : /*
    1068                 :            :  * Activate wide bus and DDR if supported.
    1069                 :            :  */
    1070                 :          0 : static int mmc_select_hs_ddr(struct mmc_card *card)
    1071                 :            : {
    1072                 :          0 :         struct mmc_host *host = card->host;
    1073                 :            :         u32 bus_width, ext_csd_bits;
    1074                 :            :         int err = 0;
    1075                 :            : 
    1076                 :          0 :         if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
    1077                 :            :                 return 0;
    1078                 :            : 
    1079                 :          0 :         bus_width = host->ios.bus_width;
    1080                 :          0 :         if (bus_width == MMC_BUS_WIDTH_1)
    1081                 :            :                 return 0;
    1082                 :            : 
    1083                 :          0 :         ext_csd_bits = (bus_width == MMC_BUS_WIDTH_8) ?
    1084                 :            :                 EXT_CSD_DDR_BUS_WIDTH_8 : EXT_CSD_DDR_BUS_WIDTH_4;
    1085                 :            : 
    1086                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1087                 :            :                            EXT_CSD_BUS_WIDTH,
    1088                 :            :                            ext_csd_bits,
    1089                 :            :                            card->ext_csd.generic_cmd6_time,
    1090                 :            :                            MMC_TIMING_MMC_DDR52,
    1091                 :            :                            true, true, true);
    1092                 :          0 :         if (err) {
    1093                 :          0 :                 pr_err("%s: switch to bus width %d ddr failed\n",
    1094                 :            :                         mmc_hostname(host), 1 << bus_width);
    1095                 :          0 :                 return err;
    1096                 :            :         }
    1097                 :            : 
    1098                 :            :         /*
    1099                 :            :          * eMMC cards can support 3.3V to 1.2V i/o (vccq)
    1100                 :            :          * signaling.
    1101                 :            :          *
    1102                 :            :          * EXT_CSD_CARD_TYPE_DDR_1_8V means 3.3V or 1.8V vccq.
    1103                 :            :          *
    1104                 :            :          * 1.8V vccq at 3.3V core voltage (vcc) is not required
    1105                 :            :          * in the JEDEC spec for DDR.
    1106                 :            :          *
    1107                 :            :          * Even (e)MMC card can support 3.3v to 1.2v vccq, but not all
    1108                 :            :          * host controller can support this, like some of the SDHCI
    1109                 :            :          * controller which connect to an eMMC device. Some of these
    1110                 :            :          * host controller still needs to use 1.8v vccq for supporting
    1111                 :            :          * DDR mode.
    1112                 :            :          *
    1113                 :            :          * So the sequence will be:
    1114                 :            :          * if (host and device can both support 1.2v IO)
    1115                 :            :          *      use 1.2v IO;
    1116                 :            :          * else if (host and device can both support 1.8v IO)
    1117                 :            :          *      use 1.8v IO;
    1118                 :            :          * so if host and device can only support 3.3v IO, this is the
    1119                 :            :          * last choice.
    1120                 :            :          *
    1121                 :            :          * WARNING: eMMC rules are NOT the same as SD DDR
    1122                 :            :          */
    1123                 :          0 :         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_2V) {
    1124                 :          0 :                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
    1125                 :          0 :                 if (!err)
    1126                 :            :                         return 0;
    1127                 :            :         }
    1128                 :            : 
    1129                 :          0 :         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_1_8V &&
    1130                 :          0 :             host->caps & MMC_CAP_1_8V_DDR)
    1131                 :          0 :                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
    1132                 :            : 
    1133                 :            :         /* make sure vccq is 3.3v after switching disaster */
    1134                 :          0 :         if (err)
    1135                 :          0 :                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_330);
    1136                 :            : 
    1137                 :          0 :         return err;
    1138                 :            : }
    1139                 :            : 
    1140                 :          0 : static int mmc_select_hs400(struct mmc_card *card)
    1141                 :            : {
    1142                 :          0 :         struct mmc_host *host = card->host;
    1143                 :            :         unsigned int max_dtr;
    1144                 :            :         int err = 0;
    1145                 :            :         u8 val;
    1146                 :            : 
    1147                 :            :         /*
    1148                 :            :          * HS400 mode requires 8-bit bus width
    1149                 :            :          */
    1150                 :          0 :         if (!(card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
    1151                 :          0 :               host->ios.bus_width == MMC_BUS_WIDTH_8))
    1152                 :            :                 return 0;
    1153                 :            : 
    1154                 :            :         /* Switch card to HS mode */
    1155                 :            :         val = EXT_CSD_TIMING_HS;
    1156                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1157                 :            :                            EXT_CSD_HS_TIMING, val,
    1158                 :            :                            card->ext_csd.generic_cmd6_time, 0,
    1159                 :            :                            true, false, true);
    1160                 :          0 :         if (err) {
    1161                 :          0 :                 pr_err("%s: switch to high-speed from hs200 failed, err:%d\n",
    1162                 :            :                         mmc_hostname(host), err);
    1163                 :          0 :                 return err;
    1164                 :            :         }
    1165                 :            : 
    1166                 :            :         /* Set host controller to HS timing */
    1167                 :          0 :         mmc_set_timing(card->host, MMC_TIMING_MMC_HS);
    1168                 :            : 
    1169                 :            :         /* Prepare host to downgrade to HS timing */
    1170                 :          0 :         if (host->ops->hs400_downgrade)
    1171                 :          0 :                 host->ops->hs400_downgrade(host);
    1172                 :            : 
    1173                 :            :         /* Reduce frequency to HS frequency */
    1174                 :          0 :         max_dtr = card->ext_csd.hs_max_dtr;
    1175                 :          0 :         mmc_set_clock(host, max_dtr);
    1176                 :            : 
    1177                 :          0 :         err = mmc_switch_status(card);
    1178                 :          0 :         if (err)
    1179                 :            :                 goto out_err;
    1180                 :            : 
    1181                 :          0 :         if (host->ops->hs400_prepare_ddr)
    1182                 :          0 :                 host->ops->hs400_prepare_ddr(host);
    1183                 :            : 
    1184                 :            :         /* Switch card to DDR */
    1185                 :          0 :         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1186                 :            :                          EXT_CSD_BUS_WIDTH,
    1187                 :            :                          EXT_CSD_DDR_BUS_WIDTH_8,
    1188                 :            :                          card->ext_csd.generic_cmd6_time);
    1189                 :          0 :         if (err) {
    1190                 :          0 :                 pr_err("%s: switch to bus width for hs400 failed, err:%d\n",
    1191                 :            :                         mmc_hostname(host), err);
    1192                 :          0 :                 return err;
    1193                 :            :         }
    1194                 :            : 
    1195                 :            :         /* Switch card to HS400 */
    1196                 :          0 :         val = EXT_CSD_TIMING_HS400 |
    1197                 :          0 :               card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
    1198                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1199                 :            :                            EXT_CSD_HS_TIMING, val,
    1200                 :            :                            card->ext_csd.generic_cmd6_time, 0,
    1201                 :            :                            true, false, true);
    1202                 :          0 :         if (err) {
    1203                 :          0 :                 pr_err("%s: switch to hs400 failed, err:%d\n",
    1204                 :            :                          mmc_hostname(host), err);
    1205                 :          0 :                 return err;
    1206                 :            :         }
    1207                 :            : 
    1208                 :            :         /* Set host controller to HS400 timing and frequency */
    1209                 :          0 :         mmc_set_timing(host, MMC_TIMING_MMC_HS400);
    1210                 :          0 :         mmc_set_bus_speed(card);
    1211                 :            : 
    1212                 :          0 :         if (host->ops->hs400_complete)
    1213                 :          0 :                 host->ops->hs400_complete(host);
    1214                 :            : 
    1215                 :          0 :         err = mmc_switch_status(card);
    1216                 :          0 :         if (err)
    1217                 :            :                 goto out_err;
    1218                 :            : 
    1219                 :            :         return 0;
    1220                 :            : 
    1221                 :            : out_err:
    1222                 :          0 :         pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
    1223                 :            :                __func__, err);
    1224                 :          0 :         return err;
    1225                 :            : }
    1226                 :            : 
    1227                 :          0 : int mmc_hs200_to_hs400(struct mmc_card *card)
    1228                 :            : {
    1229                 :          0 :         return mmc_select_hs400(card);
    1230                 :            : }
    1231                 :            : 
    1232                 :          0 : int mmc_hs400_to_hs200(struct mmc_card *card)
    1233                 :            : {
    1234                 :          0 :         struct mmc_host *host = card->host;
    1235                 :            :         unsigned int max_dtr;
    1236                 :            :         int err;
    1237                 :            :         u8 val;
    1238                 :            : 
    1239                 :            :         /* Reduce frequency to HS */
    1240                 :          0 :         max_dtr = card->ext_csd.hs_max_dtr;
    1241                 :          0 :         mmc_set_clock(host, max_dtr);
    1242                 :            : 
    1243                 :            :         /* Switch HS400 to HS DDR */
    1244                 :            :         val = EXT_CSD_TIMING_HS;
    1245                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
    1246                 :            :                            val, card->ext_csd.generic_cmd6_time, 0,
    1247                 :            :                            true, false, true);
    1248                 :          0 :         if (err)
    1249                 :            :                 goto out_err;
    1250                 :            : 
    1251                 :          0 :         mmc_set_timing(host, MMC_TIMING_MMC_DDR52);
    1252                 :            : 
    1253                 :          0 :         err = mmc_switch_status(card);
    1254                 :          0 :         if (err)
    1255                 :            :                 goto out_err;
    1256                 :            : 
    1257                 :            :         /* Switch HS DDR to HS */
    1258                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_BUS_WIDTH,
    1259                 :            :                            EXT_CSD_BUS_WIDTH_8, card->ext_csd.generic_cmd6_time,
    1260                 :            :                            0, true, false, true);
    1261                 :          0 :         if (err)
    1262                 :            :                 goto out_err;
    1263                 :            : 
    1264                 :          0 :         mmc_set_timing(host, MMC_TIMING_MMC_HS);
    1265                 :            : 
    1266                 :          0 :         if (host->ops->hs400_downgrade)
    1267                 :          0 :                 host->ops->hs400_downgrade(host);
    1268                 :            : 
    1269                 :          0 :         err = mmc_switch_status(card);
    1270                 :          0 :         if (err)
    1271                 :            :                 goto out_err;
    1272                 :            : 
    1273                 :            :         /* Switch HS to HS200 */
    1274                 :          0 :         val = EXT_CSD_TIMING_HS200 |
    1275                 :          0 :               card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
    1276                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_HS_TIMING,
    1277                 :            :                            val, card->ext_csd.generic_cmd6_time, 0,
    1278                 :            :                            true, false, true);
    1279                 :          0 :         if (err)
    1280                 :            :                 goto out_err;
    1281                 :            : 
    1282                 :          0 :         mmc_set_timing(host, MMC_TIMING_MMC_HS200);
    1283                 :            : 
    1284                 :            :         /*
    1285                 :            :          * For HS200, CRC errors are not a reliable way to know the switch
    1286                 :            :          * failed. If there really is a problem, we would expect tuning will
    1287                 :            :          * fail and the result ends up the same.
    1288                 :            :          */
    1289                 :          0 :         err = __mmc_switch_status(card, false);
    1290                 :          0 :         if (err)
    1291                 :            :                 goto out_err;
    1292                 :            : 
    1293                 :          0 :         mmc_set_bus_speed(card);
    1294                 :            : 
    1295                 :            :         /* Prepare tuning for HS400 mode. */
    1296                 :          0 :         if (host->ops->prepare_hs400_tuning)
    1297                 :          0 :                 host->ops->prepare_hs400_tuning(host, &host->ios);
    1298                 :            : 
    1299                 :            :         return 0;
    1300                 :            : 
    1301                 :            : out_err:
    1302                 :          0 :         pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
    1303                 :            :                __func__, err);
    1304                 :          0 :         return err;
    1305                 :            : }
    1306                 :            : 
    1307                 :          0 : static void mmc_select_driver_type(struct mmc_card *card)
    1308                 :            : {
    1309                 :          0 :         int card_drv_type, drive_strength, drv_type = 0;
    1310                 :          0 :         int fixed_drv_type = card->host->fixed_drv_type;
    1311                 :            : 
    1312                 :          0 :         card_drv_type = card->ext_csd.raw_driver_strength |
    1313                 :            :                         mmc_driver_type_mask(0);
    1314                 :            : 
    1315                 :          0 :         if (fixed_drv_type >= 0)
    1316                 :            :                 drive_strength = card_drv_type & mmc_driver_type_mask(fixed_drv_type)
    1317                 :          0 :                                  ? fixed_drv_type : 0;
    1318                 :            :         else
    1319                 :          0 :                 drive_strength = mmc_select_drive_strength(card,
    1320                 :            :                                                            card->ext_csd.hs200_max_dtr,
    1321                 :            :                                                            card_drv_type, &drv_type);
    1322                 :            : 
    1323                 :          0 :         card->drive_strength = drive_strength;
    1324                 :            : 
    1325                 :          0 :         if (drv_type)
    1326                 :          0 :                 mmc_set_driver_type(card->host, drv_type);
    1327                 :          0 : }
    1328                 :            : 
    1329                 :          0 : static int mmc_select_hs400es(struct mmc_card *card)
    1330                 :            : {
    1331                 :          0 :         struct mmc_host *host = card->host;
    1332                 :            :         int err = -EINVAL;
    1333                 :            :         u8 val;
    1334                 :            : 
    1335                 :          0 :         if (!(host->caps & MMC_CAP_8_BIT_DATA)) {
    1336                 :            :                 err = -ENOTSUPP;
    1337                 :            :                 goto out_err;
    1338                 :            :         }
    1339                 :            : 
    1340                 :          0 :         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_2V)
    1341                 :          0 :                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
    1342                 :            : 
    1343                 :          0 :         if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400_1_8V)
    1344                 :          0 :                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
    1345                 :            : 
    1346                 :            :         /* If fails try again during next card power cycle */
    1347                 :          0 :         if (err)
    1348                 :            :                 goto out_err;
    1349                 :            : 
    1350                 :          0 :         err = mmc_select_bus_width(card);
    1351                 :          0 :         if (err != MMC_BUS_WIDTH_8) {
    1352                 :          0 :                 pr_err("%s: switch to 8bit bus width failed, err:%d\n",
    1353                 :            :                         mmc_hostname(host), err);
    1354                 :          0 :                 err = err < 0 ? err : -ENOTSUPP;
    1355                 :          0 :                 goto out_err;
    1356                 :            :         }
    1357                 :            : 
    1358                 :            :         /* Switch card to HS mode */
    1359                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1360                 :            :                            EXT_CSD_HS_TIMING, EXT_CSD_TIMING_HS,
    1361                 :            :                            card->ext_csd.generic_cmd6_time, 0,
    1362                 :            :                            true, false, true);
    1363                 :          0 :         if (err) {
    1364                 :          0 :                 pr_err("%s: switch to hs for hs400es failed, err:%d\n",
    1365                 :            :                         mmc_hostname(host), err);
    1366                 :          0 :                 goto out_err;
    1367                 :            :         }
    1368                 :            : 
    1369                 :          0 :         mmc_set_timing(host, MMC_TIMING_MMC_HS);
    1370                 :          0 :         err = mmc_switch_status(card);
    1371                 :          0 :         if (err)
    1372                 :            :                 goto out_err;
    1373                 :            : 
    1374                 :          0 :         mmc_set_clock(host, card->ext_csd.hs_max_dtr);
    1375                 :            : 
    1376                 :            :         /* Switch card to DDR with strobe bit */
    1377                 :            :         val = EXT_CSD_DDR_BUS_WIDTH_8 | EXT_CSD_BUS_WIDTH_STROBE;
    1378                 :          0 :         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1379                 :            :                          EXT_CSD_BUS_WIDTH,
    1380                 :            :                          val,
    1381                 :            :                          card->ext_csd.generic_cmd6_time);
    1382                 :          0 :         if (err) {
    1383                 :          0 :                 pr_err("%s: switch to bus width for hs400es failed, err:%d\n",
    1384                 :            :                         mmc_hostname(host), err);
    1385                 :          0 :                 goto out_err;
    1386                 :            :         }
    1387                 :            : 
    1388                 :          0 :         mmc_select_driver_type(card);
    1389                 :            : 
    1390                 :            :         /* Switch card to HS400 */
    1391                 :          0 :         val = EXT_CSD_TIMING_HS400 |
    1392                 :          0 :               card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
    1393                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1394                 :            :                            EXT_CSD_HS_TIMING, val,
    1395                 :            :                            card->ext_csd.generic_cmd6_time, 0,
    1396                 :            :                            true, false, true);
    1397                 :          0 :         if (err) {
    1398                 :          0 :                 pr_err("%s: switch to hs400es failed, err:%d\n",
    1399                 :            :                         mmc_hostname(host), err);
    1400                 :          0 :                 goto out_err;
    1401                 :            :         }
    1402                 :            : 
    1403                 :            :         /* Set host controller to HS400 timing and frequency */
    1404                 :          0 :         mmc_set_timing(host, MMC_TIMING_MMC_HS400);
    1405                 :            : 
    1406                 :            :         /* Controller enable enhanced strobe function */
    1407                 :          0 :         host->ios.enhanced_strobe = true;
    1408                 :          0 :         if (host->ops->hs400_enhanced_strobe)
    1409                 :          0 :                 host->ops->hs400_enhanced_strobe(host, &host->ios);
    1410                 :            : 
    1411                 :          0 :         err = mmc_switch_status(card);
    1412                 :          0 :         if (err)
    1413                 :            :                 goto out_err;
    1414                 :            : 
    1415                 :            :         return 0;
    1416                 :            : 
    1417                 :            : out_err:
    1418                 :          0 :         pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
    1419                 :            :                __func__, err);
    1420                 :          0 :         return err;
    1421                 :            : }
    1422                 :            : 
    1423                 :            : /*
    1424                 :            :  * For device supporting HS200 mode, the following sequence
    1425                 :            :  * should be done before executing the tuning process.
    1426                 :            :  * 1. set the desired bus width(4-bit or 8-bit, 1-bit is not supported)
    1427                 :            :  * 2. switch to HS200 mode
    1428                 :            :  * 3. set the clock to > 52Mhz and <=200MHz
    1429                 :            :  */
    1430                 :          0 : static int mmc_select_hs200(struct mmc_card *card)
    1431                 :            : {
    1432                 :          0 :         struct mmc_host *host = card->host;
    1433                 :            :         unsigned int old_timing, old_signal_voltage;
    1434                 :            :         int err = -EINVAL;
    1435                 :            :         u8 val;
    1436                 :            : 
    1437                 :          0 :         old_signal_voltage = host->ios.signal_voltage;
    1438                 :          0 :         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_2V)
    1439                 :          0 :                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_120);
    1440                 :            : 
    1441                 :          0 :         if (err && card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200_1_8V)
    1442                 :          0 :                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
    1443                 :            : 
    1444                 :            :         /* If fails try again during next card power cycle */
    1445                 :          0 :         if (err)
    1446                 :            :                 return err;
    1447                 :            : 
    1448                 :          0 :         mmc_select_driver_type(card);
    1449                 :            : 
    1450                 :            :         /*
    1451                 :            :          * Set the bus width(4 or 8) with host's support and
    1452                 :            :          * switch to HS200 mode if bus width is set successfully.
    1453                 :            :          */
    1454                 :          0 :         err = mmc_select_bus_width(card);
    1455                 :          0 :         if (err > 0) {
    1456                 :          0 :                 val = EXT_CSD_TIMING_HS200 |
    1457                 :          0 :                       card->drive_strength << EXT_CSD_DRV_STR_SHIFT;
    1458                 :          0 :                 err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1459                 :            :                                    EXT_CSD_HS_TIMING, val,
    1460                 :            :                                    card->ext_csd.generic_cmd6_time, 0,
    1461                 :            :                                    true, false, true);
    1462                 :          0 :                 if (err)
    1463                 :            :                         goto err;
    1464                 :          0 :                 old_timing = host->ios.timing;
    1465                 :          0 :                 mmc_set_timing(host, MMC_TIMING_MMC_HS200);
    1466                 :            : 
    1467                 :            :                 /*
    1468                 :            :                  * For HS200, CRC errors are not a reliable way to know the
    1469                 :            :                  * switch failed. If there really is a problem, we would expect
    1470                 :            :                  * tuning will fail and the result ends up the same.
    1471                 :            :                  */
    1472                 :          0 :                 err = __mmc_switch_status(card, false);
    1473                 :            : 
    1474                 :            :                 /*
    1475                 :            :                  * mmc_select_timing() assumes timing has not changed if
    1476                 :            :                  * it is a switch error.
    1477                 :            :                  */
    1478                 :          0 :                 if (err == -EBADMSG)
    1479                 :          0 :                         mmc_set_timing(host, old_timing);
    1480                 :            :         }
    1481                 :            : err:
    1482                 :          0 :         if (err) {
    1483                 :            :                 /* fall back to the old signal voltage, if fails report error */
    1484                 :          0 :                 if (mmc_set_signal_voltage(host, old_signal_voltage))
    1485                 :            :                         err = -EIO;
    1486                 :            : 
    1487                 :          0 :                 pr_err("%s: %s failed, error %d\n", mmc_hostname(card->host),
    1488                 :            :                        __func__, err);
    1489                 :            :         }
    1490                 :          0 :         return err;
    1491                 :            : }
    1492                 :            : 
    1493                 :            : /*
    1494                 :            :  * Activate High Speed, HS200 or HS400ES mode if supported.
    1495                 :            :  */
    1496                 :          0 : static int mmc_select_timing(struct mmc_card *card)
    1497                 :            : {
    1498                 :            :         int err = 0;
    1499                 :            : 
    1500                 :          0 :         if (!mmc_can_ext_csd(card))
    1501                 :            :                 goto bus_speed;
    1502                 :            : 
    1503                 :          0 :         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400ES)
    1504                 :          0 :                 err = mmc_select_hs400es(card);
    1505                 :          0 :         else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)
    1506                 :          0 :                 err = mmc_select_hs200(card);
    1507                 :          0 :         else if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS)
    1508                 :          0 :                 err = mmc_select_hs(card);
    1509                 :            : 
    1510                 :          0 :         if (err && err != -EBADMSG)
    1511                 :            :                 return err;
    1512                 :            : 
    1513                 :            : bus_speed:
    1514                 :            :         /*
    1515                 :            :          * Set the bus speed to the selected bus timing.
    1516                 :            :          * If timing is not selected, backward compatible is the default.
    1517                 :            :          */
    1518                 :          0 :         mmc_set_bus_speed(card);
    1519                 :          0 :         return 0;
    1520                 :            : }
    1521                 :            : 
    1522                 :            : /*
    1523                 :            :  * Execute tuning sequence to seek the proper bus operating
    1524                 :            :  * conditions for HS200 and HS400, which sends CMD21 to the device.
    1525                 :            :  */
    1526                 :          0 : static int mmc_hs200_tuning(struct mmc_card *card)
    1527                 :            : {
    1528                 :          0 :         struct mmc_host *host = card->host;
    1529                 :            : 
    1530                 :            :         /*
    1531                 :            :          * Timing should be adjusted to the HS400 target
    1532                 :            :          * operation frequency for tuning process
    1533                 :            :          */
    1534                 :          0 :         if (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 &&
    1535                 :          0 :             host->ios.bus_width == MMC_BUS_WIDTH_8)
    1536                 :          0 :                 if (host->ops->prepare_hs400_tuning)
    1537                 :          0 :                         host->ops->prepare_hs400_tuning(host, &host->ios);
    1538                 :            : 
    1539                 :          0 :         return mmc_execute_tuning(card);
    1540                 :            : }
    1541                 :            : 
    1542                 :            : /*
    1543                 :            :  * Handle the detection and initialisation of a card.
    1544                 :            :  *
    1545                 :            :  * In the case of a resume, "oldcard" will contain the card
    1546                 :            :  * we're trying to reinitialise.
    1547                 :            :  */
    1548                 :          0 : static int mmc_init_card(struct mmc_host *host, u32 ocr,
    1549                 :            :         struct mmc_card *oldcard)
    1550                 :            : {
    1551                 :            :         struct mmc_card *card;
    1552                 :            :         int err;
    1553                 :            :         u32 cid[4];
    1554                 :            :         u32 rocr;
    1555                 :            : 
    1556                 :          0 :         WARN_ON(!host->claimed);
    1557                 :            : 
    1558                 :            :         /* Set correct bus mode for MMC before attempting init */
    1559                 :          0 :         if (!mmc_host_is_spi(host))
    1560                 :          0 :                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
    1561                 :            : 
    1562                 :            :         /*
    1563                 :            :          * Since we're changing the OCR value, we seem to
    1564                 :            :          * need to tell some cards to go back to the idle
    1565                 :            :          * state.  We wait 1ms to give cards time to
    1566                 :            :          * respond.
    1567                 :            :          * mmc_go_idle is needed for eMMC that are asleep
    1568                 :            :          */
    1569                 :          0 :         mmc_go_idle(host);
    1570                 :            : 
    1571                 :            :         /* The extra bit indicates that we support high capacity */
    1572                 :          0 :         err = mmc_send_op_cond(host, ocr | (1 << 30), &rocr);
    1573                 :          0 :         if (err)
    1574                 :            :                 goto err;
    1575                 :            : 
    1576                 :            :         /*
    1577                 :            :          * For SPI, enable CRC as appropriate.
    1578                 :            :          */
    1579                 :          0 :         if (mmc_host_is_spi(host)) {
    1580                 :          0 :                 err = mmc_spi_set_crc(host, use_spi_crc);
    1581                 :          0 :                 if (err)
    1582                 :            :                         goto err;
    1583                 :            :         }
    1584                 :            : 
    1585                 :            :         /*
    1586                 :            :          * Fetch CID from card.
    1587                 :            :          */
    1588                 :          0 :         err = mmc_send_cid(host, cid);
    1589                 :          0 :         if (err)
    1590                 :            :                 goto err;
    1591                 :            : 
    1592                 :          0 :         if (oldcard) {
    1593                 :          0 :                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
    1594                 :            :                         pr_debug("%s: Perhaps the card was replaced\n",
    1595                 :            :                                 mmc_hostname(host));
    1596                 :            :                         err = -ENOENT;
    1597                 :            :                         goto err;
    1598                 :            :                 }
    1599                 :            : 
    1600                 :            :                 card = oldcard;
    1601                 :            :         } else {
    1602                 :            :                 /*
    1603                 :            :                  * Allocate card structure.
    1604                 :            :                  */
    1605                 :          0 :                 card = mmc_alloc_card(host, &mmc_type);
    1606                 :          0 :                 if (IS_ERR(card)) {
    1607                 :            :                         err = PTR_ERR(card);
    1608                 :          0 :                         goto err;
    1609                 :            :                 }
    1610                 :            : 
    1611                 :          0 :                 card->ocr = ocr;
    1612                 :          0 :                 card->type = MMC_TYPE_MMC;
    1613                 :          0 :                 card->rca = 1;
    1614                 :          0 :                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
    1615                 :            :         }
    1616                 :            : 
    1617                 :            :         /*
    1618                 :            :          * Call the optional HC's init_card function to handle quirks.
    1619                 :            :          */
    1620                 :          0 :         if (host->ops->init_card)
    1621                 :          0 :                 host->ops->init_card(host, card);
    1622                 :            : 
    1623                 :            :         /*
    1624                 :            :          * For native busses:  set card RCA and quit open drain mode.
    1625                 :            :          */
    1626                 :          0 :         if (!mmc_host_is_spi(host)) {
    1627                 :          0 :                 err = mmc_set_relative_addr(card);
    1628                 :          0 :                 if (err)
    1629                 :            :                         goto free_card;
    1630                 :            : 
    1631                 :          0 :                 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL);
    1632                 :            :         }
    1633                 :            : 
    1634                 :          0 :         if (!oldcard) {
    1635                 :            :                 /*
    1636                 :            :                  * Fetch CSD from card.
    1637                 :            :                  */
    1638                 :          0 :                 err = mmc_send_csd(card, card->raw_csd);
    1639                 :          0 :                 if (err)
    1640                 :            :                         goto free_card;
    1641                 :            : 
    1642                 :          0 :                 err = mmc_decode_csd(card);
    1643                 :          0 :                 if (err)
    1644                 :            :                         goto free_card;
    1645                 :          0 :                 err = mmc_decode_cid(card);
    1646                 :          0 :                 if (err)
    1647                 :            :                         goto free_card;
    1648                 :            :         }
    1649                 :            : 
    1650                 :            :         /*
    1651                 :            :          * handling only for cards supporting DSR and hosts requesting
    1652                 :            :          * DSR configuration
    1653                 :            :          */
    1654                 :          0 :         if (card->csd.dsr_imp && host->dsr_req)
    1655                 :          0 :                 mmc_set_dsr(host);
    1656                 :            : 
    1657                 :            :         /*
    1658                 :            :          * Select card, as all following commands rely on that.
    1659                 :            :          */
    1660                 :          0 :         if (!mmc_host_is_spi(host)) {
    1661                 :          0 :                 err = mmc_select_card(card);
    1662                 :          0 :                 if (err)
    1663                 :            :                         goto free_card;
    1664                 :            :         }
    1665                 :            : 
    1666                 :          0 :         if (!oldcard) {
    1667                 :            :                 /* Read extended CSD. */
    1668                 :          0 :                 err = mmc_read_ext_csd(card);
    1669                 :          0 :                 if (err)
    1670                 :            :                         goto free_card;
    1671                 :            : 
    1672                 :            :                 /*
    1673                 :            :                  * If doing byte addressing, check if required to do sector
    1674                 :            :                  * addressing.  Handle the case of <2GB cards needing sector
    1675                 :            :                  * addressing.  See section 8.1 JEDEC Standard JED84-A441;
    1676                 :            :                  * ocr register has bit 30 set for sector addressing.
    1677                 :            :                  */
    1678                 :          0 :                 if (rocr & BIT(30))
    1679                 :          0 :                         mmc_card_set_blockaddr(card);
    1680                 :            : 
    1681                 :            :                 /* Erase size depends on CSD and Extended CSD */
    1682                 :          0 :                 mmc_set_erase_size(card);
    1683                 :            :         }
    1684                 :            : 
    1685                 :            :         /* Enable ERASE_GRP_DEF. This bit is lost after a reset or power off. */
    1686                 :          0 :         if (card->ext_csd.rev >= 3) {
    1687                 :          0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1688                 :            :                                  EXT_CSD_ERASE_GROUP_DEF, 1,
    1689                 :            :                                  card->ext_csd.generic_cmd6_time);
    1690                 :            : 
    1691                 :          0 :                 if (err && err != -EBADMSG)
    1692                 :            :                         goto free_card;
    1693                 :            : 
    1694                 :          0 :                 if (err) {
    1695                 :            :                         err = 0;
    1696                 :            :                         /*
    1697                 :            :                          * Just disable enhanced area off & sz
    1698                 :            :                          * will try to enable ERASE_GROUP_DEF
    1699                 :            :                          * during next time reinit
    1700                 :            :                          */
    1701                 :          0 :                         card->ext_csd.enhanced_area_offset = -EINVAL;
    1702                 :          0 :                         card->ext_csd.enhanced_area_size = -EINVAL;
    1703                 :            :                 } else {
    1704                 :          0 :                         card->ext_csd.erase_group_def = 1;
    1705                 :            :                         /*
    1706                 :            :                          * enable ERASE_GRP_DEF successfully.
    1707                 :            :                          * This will affect the erase size, so
    1708                 :            :                          * here need to reset erase size
    1709                 :            :                          */
    1710                 :          0 :                         mmc_set_erase_size(card);
    1711                 :            :                 }
    1712                 :            :         }
    1713                 :            : 
    1714                 :            :         /*
    1715                 :            :          * Ensure eMMC user default partition is enabled
    1716                 :            :          */
    1717                 :          0 :         if (card->ext_csd.part_config & EXT_CSD_PART_CONFIG_ACC_MASK) {
    1718                 :          0 :                 card->ext_csd.part_config &= ~EXT_CSD_PART_CONFIG_ACC_MASK;
    1719                 :          0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL, EXT_CSD_PART_CONFIG,
    1720                 :            :                                  card->ext_csd.part_config,
    1721                 :            :                                  card->ext_csd.part_time);
    1722                 :          0 :                 if (err && err != -EBADMSG)
    1723                 :            :                         goto free_card;
    1724                 :            :         }
    1725                 :            : 
    1726                 :            :         /*
    1727                 :            :          * Enable power_off_notification byte in the ext_csd register
    1728                 :            :          */
    1729                 :          0 :         if (card->ext_csd.rev >= 6) {
    1730                 :          0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1731                 :            :                                  EXT_CSD_POWER_OFF_NOTIFICATION,
    1732                 :            :                                  EXT_CSD_POWER_ON,
    1733                 :            :                                  card->ext_csd.generic_cmd6_time);
    1734                 :          0 :                 if (err && err != -EBADMSG)
    1735                 :            :                         goto free_card;
    1736                 :            : 
    1737                 :            :                 /*
    1738                 :            :                  * The err can be -EBADMSG or 0,
    1739                 :            :                  * so check for success and update the flag
    1740                 :            :                  */
    1741                 :          0 :                 if (!err)
    1742                 :          0 :                         card->ext_csd.power_off_notification = EXT_CSD_POWER_ON;
    1743                 :            :         }
    1744                 :            : 
    1745                 :            :         /* set erase_arg */
    1746                 :          0 :         if (mmc_can_discard(card))
    1747                 :          0 :                 card->erase_arg = MMC_DISCARD_ARG;
    1748                 :          0 :         else if (mmc_can_trim(card))
    1749                 :          0 :                 card->erase_arg = MMC_TRIM_ARG;
    1750                 :            :         else
    1751                 :          0 :                 card->erase_arg = MMC_ERASE_ARG;
    1752                 :            : 
    1753                 :            :         /*
    1754                 :            :          * Select timing interface
    1755                 :            :          */
    1756                 :          0 :         err = mmc_select_timing(card);
    1757                 :          0 :         if (err)
    1758                 :            :                 goto free_card;
    1759                 :            : 
    1760                 :          0 :         if (mmc_card_hs200(card)) {
    1761                 :          0 :                 err = mmc_hs200_tuning(card);
    1762                 :          0 :                 if (err)
    1763                 :            :                         goto free_card;
    1764                 :            : 
    1765                 :          0 :                 err = mmc_select_hs400(card);
    1766                 :          0 :                 if (err)
    1767                 :            :                         goto free_card;
    1768                 :          0 :         } else if (!mmc_card_hs400es(card)) {
    1769                 :            :                 /* Select the desired bus width optionally */
    1770                 :          0 :                 err = mmc_select_bus_width(card);
    1771                 :          0 :                 if (err > 0 && mmc_card_hs(card)) {
    1772                 :          0 :                         err = mmc_select_hs_ddr(card);
    1773                 :          0 :                         if (err)
    1774                 :            :                                 goto free_card;
    1775                 :            :                 }
    1776                 :            :         }
    1777                 :            : 
    1778                 :            :         /*
    1779                 :            :          * Choose the power class with selected bus interface
    1780                 :            :          */
    1781                 :          0 :         mmc_select_powerclass(card);
    1782                 :            : 
    1783                 :            :         /*
    1784                 :            :          * Enable HPI feature (if supported)
    1785                 :            :          */
    1786                 :          0 :         if (card->ext_csd.hpi) {
    1787                 :          0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1788                 :            :                                 EXT_CSD_HPI_MGMT, 1,
    1789                 :            :                                 card->ext_csd.generic_cmd6_time);
    1790                 :          0 :                 if (err && err != -EBADMSG)
    1791                 :            :                         goto free_card;
    1792                 :          0 :                 if (err) {
    1793                 :          0 :                         pr_warn("%s: Enabling HPI failed\n",
    1794                 :            :                                 mmc_hostname(card->host));
    1795                 :          0 :                         card->ext_csd.hpi_en = 0;
    1796                 :            :                         err = 0;
    1797                 :            :                 } else {
    1798                 :          0 :                         card->ext_csd.hpi_en = 1;
    1799                 :            :                 }
    1800                 :            :         }
    1801                 :            : 
    1802                 :            :         /*
    1803                 :            :          * If cache size is higher than 0, this indicates the existence of cache
    1804                 :            :          * and it can be turned on. Note that some eMMCs from Micron has been
    1805                 :            :          * reported to need ~800 ms timeout, while enabling the cache after
    1806                 :            :          * sudden power failure tests. Let's extend the timeout to a minimum of
    1807                 :            :          * DEFAULT_CACHE_EN_TIMEOUT_MS and do it for all cards.
    1808                 :            :          */
    1809                 :          0 :         if (card->ext_csd.cache_size > 0) {
    1810                 :            :                 unsigned int timeout_ms = MIN_CACHE_EN_TIMEOUT_MS;
    1811                 :            : 
    1812                 :          0 :                 timeout_ms = max(card->ext_csd.generic_cmd6_time, timeout_ms);
    1813                 :          0 :                 err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1814                 :            :                                 EXT_CSD_CACHE_CTRL, 1, timeout_ms);
    1815                 :          0 :                 if (err && err != -EBADMSG)
    1816                 :            :                         goto free_card;
    1817                 :            : 
    1818                 :            :                 /*
    1819                 :            :                  * Only if no error, cache is turned on successfully.
    1820                 :            :                  */
    1821                 :          0 :                 if (err) {
    1822                 :          0 :                         pr_warn("%s: Cache is supported, but failed to turn on (%d)\n",
    1823                 :            :                                 mmc_hostname(card->host), err);
    1824                 :          0 :                         card->ext_csd.cache_ctrl = 0;
    1825                 :            :                         err = 0;
    1826                 :            :                 } else {
    1827                 :          0 :                         card->ext_csd.cache_ctrl = 1;
    1828                 :            :                 }
    1829                 :            :         }
    1830                 :            : 
    1831                 :            :         /*
    1832                 :            :          * Enable Command Queue if supported. Note that Packed Commands cannot
    1833                 :            :          * be used with Command Queue.
    1834                 :            :          */
    1835                 :          0 :         card->ext_csd.cmdq_en = false;
    1836                 :          0 :         if (card->ext_csd.cmdq_support && host->caps2 & MMC_CAP2_CQE) {
    1837                 :          0 :                 err = mmc_cmdq_enable(card);
    1838                 :          0 :                 if (err && err != -EBADMSG)
    1839                 :            :                         goto free_card;
    1840                 :          0 :                 if (err) {
    1841                 :          0 :                         pr_warn("%s: Enabling CMDQ failed\n",
    1842                 :            :                                 mmc_hostname(card->host));
    1843                 :          0 :                         card->ext_csd.cmdq_support = false;
    1844                 :          0 :                         card->ext_csd.cmdq_depth = 0;
    1845                 :            :                         err = 0;
    1846                 :            :                 }
    1847                 :            :         }
    1848                 :            :         /*
    1849                 :            :          * In some cases (e.g. RPMB or mmc_test), the Command Queue must be
    1850                 :            :          * disabled for a time, so a flag is needed to indicate to re-enable the
    1851                 :            :          * Command Queue.
    1852                 :            :          */
    1853                 :          0 :         card->reenable_cmdq = card->ext_csd.cmdq_en;
    1854                 :            : 
    1855                 :          0 :         if (card->ext_csd.cmdq_en && !host->cqe_enabled) {
    1856                 :          0 :                 err = host->cqe_ops->cqe_enable(host, card);
    1857                 :          0 :                 if (err) {
    1858                 :          0 :                         pr_err("%s: Failed to enable CQE, error %d\n",
    1859                 :            :                                 mmc_hostname(host), err);
    1860                 :            :                 } else {
    1861                 :          0 :                         host->cqe_enabled = true;
    1862                 :          0 :                         pr_info("%s: Command Queue Engine enabled\n",
    1863                 :            :                                 mmc_hostname(host));
    1864                 :            :                 }
    1865                 :            :         }
    1866                 :            : 
    1867                 :          0 :         if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
    1868                 :          0 :             host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
    1869                 :          0 :                 pr_err("%s: Host failed to negotiate down from 3.3V\n",
    1870                 :            :                         mmc_hostname(host));
    1871                 :            :                 err = -EINVAL;
    1872                 :          0 :                 goto free_card;
    1873                 :            :         }
    1874                 :            : 
    1875                 :          0 :         if (!oldcard)
    1876                 :          0 :                 host->card = card;
    1877                 :            : 
    1878                 :            :         return 0;
    1879                 :            : 
    1880                 :            : free_card:
    1881                 :          0 :         if (!oldcard)
    1882                 :          0 :                 mmc_remove_card(card);
    1883                 :            : err:
    1884                 :          0 :         return err;
    1885                 :            : }
    1886                 :            : 
    1887                 :            : static int mmc_can_sleep(struct mmc_card *card)
    1888                 :            : {
    1889                 :          0 :         return (card && card->ext_csd.rev >= 3);
    1890                 :            : }
    1891                 :            : 
    1892                 :          0 : static int mmc_sleep(struct mmc_host *host)
    1893                 :            : {
    1894                 :          0 :         struct mmc_command cmd = {};
    1895                 :          0 :         struct mmc_card *card = host->card;
    1896                 :          0 :         unsigned int timeout_ms = DIV_ROUND_UP(card->ext_csd.sa_timeout, 10000);
    1897                 :            :         int err;
    1898                 :            : 
    1899                 :            :         /* Re-tuning can't be done once the card is deselected */
    1900                 :          0 :         mmc_retune_hold(host);
    1901                 :            : 
    1902                 :          0 :         err = mmc_deselect_cards(host);
    1903                 :          0 :         if (err)
    1904                 :            :                 goto out_release;
    1905                 :            : 
    1906                 :          0 :         cmd.opcode = MMC_SLEEP_AWAKE;
    1907                 :          0 :         cmd.arg = card->rca << 16;
    1908                 :          0 :         cmd.arg |= 1 << 15;
    1909                 :            : 
    1910                 :            :         /*
    1911                 :            :          * If the max_busy_timeout of the host is specified, validate it against
    1912                 :            :          * the sleep cmd timeout. A failure means we need to prevent the host
    1913                 :            :          * from doing hw busy detection, which is done by converting to a R1
    1914                 :            :          * response instead of a R1B. Note, some hosts requires R1B, which also
    1915                 :            :          * means they are on their own when it comes to deal with the busy
    1916                 :            :          * timeout.
    1917                 :            :          */
    1918                 :          0 :         if (!(host->caps & MMC_CAP_NEED_RSP_BUSY) && host->max_busy_timeout &&
    1919                 :            :             (timeout_ms > host->max_busy_timeout)) {
    1920                 :          0 :                 cmd.flags = MMC_RSP_R1 | MMC_CMD_AC;
    1921                 :            :         } else {
    1922                 :          0 :                 cmd.flags = MMC_RSP_R1B | MMC_CMD_AC;
    1923                 :          0 :                 cmd.busy_timeout = timeout_ms;
    1924                 :            :         }
    1925                 :            : 
    1926                 :          0 :         err = mmc_wait_for_cmd(host, &cmd, 0);
    1927                 :          0 :         if (err)
    1928                 :            :                 goto out_release;
    1929                 :            : 
    1930                 :            :         /*
    1931                 :            :          * If the host does not wait while the card signals busy, then we will
    1932                 :            :          * will have to wait the sleep/awake timeout.  Note, we cannot use the
    1933                 :            :          * SEND_STATUS command to poll the status because that command (and most
    1934                 :            :          * others) is invalid while the card sleeps.
    1935                 :            :          */
    1936                 :          0 :         if (!cmd.busy_timeout || !(host->caps & MMC_CAP_WAIT_WHILE_BUSY))
    1937                 :          0 :                 mmc_delay(timeout_ms);
    1938                 :            : 
    1939                 :            : out_release:
    1940                 :          0 :         mmc_retune_release(host);
    1941                 :          0 :         return err;
    1942                 :            : }
    1943                 :            : 
    1944                 :            : static int mmc_can_poweroff_notify(const struct mmc_card *card)
    1945                 :            : {
    1946                 :          0 :         return card &&
    1947                 :          0 :                 mmc_card_mmc(card) &&
    1948                 :          0 :                 (card->ext_csd.power_off_notification == EXT_CSD_POWER_ON);
    1949                 :            : }
    1950                 :            : 
    1951                 :          0 : static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
    1952                 :            : {
    1953                 :          0 :         unsigned int timeout = card->ext_csd.generic_cmd6_time;
    1954                 :            :         int err;
    1955                 :            : 
    1956                 :            :         /* Use EXT_CSD_POWER_OFF_SHORT as default notification type. */
    1957                 :          0 :         if (notify_type == EXT_CSD_POWER_OFF_LONG)
    1958                 :          0 :                 timeout = card->ext_csd.power_off_longtime;
    1959                 :            : 
    1960                 :          0 :         err = __mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
    1961                 :            :                         EXT_CSD_POWER_OFF_NOTIFICATION,
    1962                 :            :                         notify_type, timeout, 0, true, false, false);
    1963                 :          0 :         if (err)
    1964                 :          0 :                 pr_err("%s: Power Off Notification timed out, %u\n",
    1965                 :            :                        mmc_hostname(card->host), timeout);
    1966                 :            : 
    1967                 :            :         /* Disable the power off notification after the switch operation. */
    1968                 :          0 :         card->ext_csd.power_off_notification = EXT_CSD_NO_POWER_NOTIFICATION;
    1969                 :            : 
    1970                 :          0 :         return err;
    1971                 :            : }
    1972                 :            : 
    1973                 :            : /*
    1974                 :            :  * Host is being removed. Free up the current card.
    1975                 :            :  */
    1976                 :          0 : static void mmc_remove(struct mmc_host *host)
    1977                 :            : {
    1978                 :          0 :         mmc_remove_card(host->card);
    1979                 :          0 :         host->card = NULL;
    1980                 :          0 : }
    1981                 :            : 
    1982                 :            : /*
    1983                 :            :  * Card detection - card is alive.
    1984                 :            :  */
    1985                 :          0 : static int mmc_alive(struct mmc_host *host)
    1986                 :            : {
    1987                 :          0 :         return mmc_send_status(host->card, NULL);
    1988                 :            : }
    1989                 :            : 
    1990                 :            : /*
    1991                 :            :  * Card detection callback from host.
    1992                 :            :  */
    1993                 :          0 : static void mmc_detect(struct mmc_host *host)
    1994                 :            : {
    1995                 :            :         int err;
    1996                 :            : 
    1997                 :          0 :         mmc_get_card(host->card, NULL);
    1998                 :            : 
    1999                 :            :         /*
    2000                 :            :          * Just check if our card has been removed.
    2001                 :            :          */
    2002                 :          0 :         err = _mmc_detect_card_removed(host);
    2003                 :            : 
    2004                 :          0 :         mmc_put_card(host->card, NULL);
    2005                 :            : 
    2006                 :          0 :         if (err) {
    2007                 :            :                 mmc_remove(host);
    2008                 :            : 
    2009                 :            :                 mmc_claim_host(host);
    2010                 :          0 :                 mmc_detach_bus(host);
    2011                 :          0 :                 mmc_power_off(host);
    2012                 :          0 :                 mmc_release_host(host);
    2013                 :            :         }
    2014                 :          0 : }
    2015                 :            : 
    2016                 :          0 : static int _mmc_suspend(struct mmc_host *host, bool is_suspend)
    2017                 :            : {
    2018                 :            :         int err = 0;
    2019                 :          0 :         unsigned int notify_type = is_suspend ? EXT_CSD_POWER_OFF_SHORT :
    2020                 :            :                                         EXT_CSD_POWER_OFF_LONG;
    2021                 :            : 
    2022                 :            :         mmc_claim_host(host);
    2023                 :            : 
    2024                 :          0 :         if (mmc_card_suspended(host->card))
    2025                 :            :                 goto out;
    2026                 :            : 
    2027                 :          0 :         err = mmc_flush_cache(host->card);
    2028                 :          0 :         if (err)
    2029                 :            :                 goto out;
    2030                 :            : 
    2031                 :          0 :         if (mmc_can_poweroff_notify(host->card) &&
    2032                 :          0 :                 ((host->caps2 & MMC_CAP2_FULL_PWR_CYCLE) || !is_suspend))
    2033                 :          0 :                 err = mmc_poweroff_notify(host->card, notify_type);
    2034                 :          0 :         else if (mmc_can_sleep(host->card))
    2035                 :          0 :                 err = mmc_sleep(host);
    2036                 :          0 :         else if (!mmc_host_is_spi(host))
    2037                 :          0 :                 err = mmc_deselect_cards(host);
    2038                 :            : 
    2039                 :          0 :         if (!err) {
    2040                 :          0 :                 mmc_power_off(host);
    2041                 :          0 :                 mmc_card_set_suspended(host->card);
    2042                 :            :         }
    2043                 :            : out:
    2044                 :          0 :         mmc_release_host(host);
    2045                 :          0 :         return err;
    2046                 :            : }
    2047                 :            : 
    2048                 :            : /*
    2049                 :            :  * Suspend callback
    2050                 :            :  */
    2051                 :          0 : static int mmc_suspend(struct mmc_host *host)
    2052                 :            : {
    2053                 :            :         int err;
    2054                 :            : 
    2055                 :          0 :         err = _mmc_suspend(host, true);
    2056                 :          0 :         if (!err) {
    2057                 :          0 :                 pm_runtime_disable(&host->card->dev);
    2058                 :          0 :                 pm_runtime_set_suspended(&host->card->dev);
    2059                 :            :         }
    2060                 :            : 
    2061                 :          0 :         return err;
    2062                 :            : }
    2063                 :            : 
    2064                 :            : /*
    2065                 :            :  * This function tries to determine if the same card is still present
    2066                 :            :  * and, if so, restore all state to it.
    2067                 :            :  */
    2068                 :          0 : static int _mmc_resume(struct mmc_host *host)
    2069                 :            : {
    2070                 :            :         int err = 0;
    2071                 :            : 
    2072                 :            :         mmc_claim_host(host);
    2073                 :            : 
    2074                 :          0 :         if (!mmc_card_suspended(host->card))
    2075                 :            :                 goto out;
    2076                 :            : 
    2077                 :          0 :         mmc_power_up(host, host->card->ocr);
    2078                 :          0 :         err = mmc_init_card(host, host->card->ocr, host->card);
    2079                 :          0 :         mmc_card_clr_suspended(host->card);
    2080                 :            : 
    2081                 :            : out:
    2082                 :          0 :         mmc_release_host(host);
    2083                 :          0 :         return err;
    2084                 :            : }
    2085                 :            : 
    2086                 :            : /*
    2087                 :            :  * Shutdown callback
    2088                 :            :  */
    2089                 :          0 : static int mmc_shutdown(struct mmc_host *host)
    2090                 :            : {
    2091                 :            :         int err = 0;
    2092                 :            : 
    2093                 :            :         /*
    2094                 :            :          * In a specific case for poweroff notify, we need to resume the card
    2095                 :            :          * before we can shutdown it properly.
    2096                 :            :          */
    2097                 :          0 :         if (mmc_can_poweroff_notify(host->card) &&
    2098                 :          0 :                 !(host->caps2 & MMC_CAP2_FULL_PWR_CYCLE))
    2099                 :          0 :                 err = _mmc_resume(host);
    2100                 :            : 
    2101                 :          0 :         if (!err)
    2102                 :          0 :                 err = _mmc_suspend(host, false);
    2103                 :            : 
    2104                 :          0 :         return err;
    2105                 :            : }
    2106                 :            : 
    2107                 :            : /*
    2108                 :            :  * Callback for resume.
    2109                 :            :  */
    2110                 :          0 : static int mmc_resume(struct mmc_host *host)
    2111                 :            : {
    2112                 :          0 :         pm_runtime_enable(&host->card->dev);
    2113                 :          0 :         return 0;
    2114                 :            : }
    2115                 :            : 
    2116                 :            : /*
    2117                 :            :  * Callback for runtime_suspend.
    2118                 :            :  */
    2119                 :          0 : static int mmc_runtime_suspend(struct mmc_host *host)
    2120                 :            : {
    2121                 :            :         int err;
    2122                 :            : 
    2123                 :          0 :         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
    2124                 :            :                 return 0;
    2125                 :            : 
    2126                 :          0 :         err = _mmc_suspend(host, true);
    2127                 :          0 :         if (err)
    2128                 :          0 :                 pr_err("%s: error %d doing aggressive suspend\n",
    2129                 :            :                         mmc_hostname(host), err);
    2130                 :            : 
    2131                 :          0 :         return err;
    2132                 :            : }
    2133                 :            : 
    2134                 :            : /*
    2135                 :            :  * Callback for runtime_resume.
    2136                 :            :  */
    2137                 :          0 : static int mmc_runtime_resume(struct mmc_host *host)
    2138                 :            : {
    2139                 :            :         int err;
    2140                 :            : 
    2141                 :          0 :         err = _mmc_resume(host);
    2142                 :          0 :         if (err && err != -ENOMEDIUM)
    2143                 :          0 :                 pr_err("%s: error %d doing runtime resume\n",
    2144                 :            :                         mmc_hostname(host), err);
    2145                 :            : 
    2146                 :          0 :         return 0;
    2147                 :            : }
    2148                 :            : 
    2149                 :            : static int mmc_can_reset(struct mmc_card *card)
    2150                 :            : {
    2151                 :            :         u8 rst_n_function;
    2152                 :            : 
    2153                 :          0 :         rst_n_function = card->ext_csd.rst_n_function;
    2154                 :          0 :         if ((rst_n_function & EXT_CSD_RST_N_EN_MASK) != EXT_CSD_RST_N_ENABLED)
    2155                 :            :                 return 0;
    2156                 :            :         return 1;
    2157                 :            : }
    2158                 :            : 
    2159                 :          0 : static int _mmc_hw_reset(struct mmc_host *host)
    2160                 :            : {
    2161                 :          0 :         struct mmc_card *card = host->card;
    2162                 :            : 
    2163                 :            :         /*
    2164                 :            :          * In the case of recovery, we can't expect flushing the cache to work
    2165                 :            :          * always, but we have a go and ignore errors.
    2166                 :            :          */
    2167                 :          0 :         mmc_flush_cache(host->card);
    2168                 :            : 
    2169                 :          0 :         if ((host->caps & MMC_CAP_HW_RESET) && host->ops->hw_reset &&
    2170                 :            :              mmc_can_reset(card)) {
    2171                 :            :                 /* If the card accept RST_n signal, send it. */
    2172                 :          0 :                 mmc_set_clock(host, host->f_init);
    2173                 :          0 :                 host->ops->hw_reset(host);
    2174                 :            :                 /* Set initial state and call mmc_set_ios */
    2175                 :          0 :                 mmc_set_initial_state(host);
    2176                 :            :         } else {
    2177                 :            :                 /* Do a brute force power cycle */
    2178                 :          0 :                 mmc_power_cycle(host, card->ocr);
    2179                 :          0 :                 mmc_pwrseq_reset(host);
    2180                 :            :         }
    2181                 :          0 :         return mmc_init_card(host, card->ocr, card);
    2182                 :            : }
    2183                 :            : 
    2184                 :            : static const struct mmc_bus_ops mmc_ops = {
    2185                 :            :         .remove = mmc_remove,
    2186                 :            :         .detect = mmc_detect,
    2187                 :            :         .suspend = mmc_suspend,
    2188                 :            :         .resume = mmc_resume,
    2189                 :            :         .runtime_suspend = mmc_runtime_suspend,
    2190                 :            :         .runtime_resume = mmc_runtime_resume,
    2191                 :            :         .alive = mmc_alive,
    2192                 :            :         .shutdown = mmc_shutdown,
    2193                 :            :         .hw_reset = _mmc_hw_reset,
    2194                 :            : };
    2195                 :            : 
    2196                 :            : /*
    2197                 :            :  * Starting point for MMC card init.
    2198                 :            :  */
    2199                 :          0 : int mmc_attach_mmc(struct mmc_host *host)
    2200                 :            : {
    2201                 :            :         int err;
    2202                 :            :         u32 ocr, rocr;
    2203                 :            : 
    2204                 :          0 :         WARN_ON(!host->claimed);
    2205                 :            : 
    2206                 :            :         /* Set correct bus mode for MMC before attempting attach */
    2207                 :          0 :         if (!mmc_host_is_spi(host))
    2208                 :          0 :                 mmc_set_bus_mode(host, MMC_BUSMODE_OPENDRAIN);
    2209                 :            : 
    2210                 :          0 :         err = mmc_send_op_cond(host, 0, &ocr);
    2211                 :          0 :         if (err)
    2212                 :            :                 return err;
    2213                 :            : 
    2214                 :          0 :         mmc_attach_bus(host, &mmc_ops);
    2215                 :          0 :         if (host->ocr_avail_mmc)
    2216                 :          0 :                 host->ocr_avail = host->ocr_avail_mmc;
    2217                 :            : 
    2218                 :            :         /*
    2219                 :            :          * We need to get OCR a different way for SPI.
    2220                 :            :          */
    2221                 :          0 :         if (mmc_host_is_spi(host)) {
    2222                 :          0 :                 err = mmc_spi_read_ocr(host, 1, &ocr);
    2223                 :          0 :                 if (err)
    2224                 :            :                         goto err;
    2225                 :            :         }
    2226                 :            : 
    2227                 :          0 :         rocr = mmc_select_voltage(host, ocr);
    2228                 :            : 
    2229                 :            :         /*
    2230                 :            :          * Can we support the voltage of the card?
    2231                 :            :          */
    2232                 :          0 :         if (!rocr) {
    2233                 :            :                 err = -EINVAL;
    2234                 :            :                 goto err;
    2235                 :            :         }
    2236                 :            : 
    2237                 :            :         /*
    2238                 :            :          * Detect and init the card.
    2239                 :            :          */
    2240                 :          0 :         err = mmc_init_card(host, rocr, NULL);
    2241                 :          0 :         if (err)
    2242                 :            :                 goto err;
    2243                 :            : 
    2244                 :          0 :         mmc_release_host(host);
    2245                 :          0 :         err = mmc_add_card(host->card);
    2246                 :          0 :         if (err)
    2247                 :            :                 goto remove_card;
    2248                 :            : 
    2249                 :            :         mmc_claim_host(host);
    2250                 :          0 :         return 0;
    2251                 :            : 
    2252                 :            : remove_card:
    2253                 :          0 :         mmc_remove_card(host->card);
    2254                 :            :         mmc_claim_host(host);
    2255                 :          0 :         host->card = NULL;
    2256                 :            : err:
    2257                 :          0 :         mmc_detach_bus(host);
    2258                 :            : 
    2259                 :          0 :         pr_err("%s: error %d whilst initialising MMC card\n",
    2260                 :            :                 mmc_hostname(host), err);
    2261                 :            : 
    2262                 :          0 :         return err;
    2263                 :            : }
    

Generated by: LCOV version 1.14