drivers/mmc/core/sd.c

   1 /*
   2  *  linux/drivers/mmc/core/sd.c
   3  *
   4  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
   5  *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
   6  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  */
  12
  13 #include <linux/err.h>
  14 #include <linux/sizes.h>
  15 #include <linux/slab.h>
  16 #include <linux/stat.h>
  17 #include <linux/pm_runtime.h>
  18
  19 #include <linux/mmc/host.h>
  20 #include <linux/mmc/card.h>
  21 #include <linux/mmc/mmc.h>
  22 #include <linux/mmc/sd.h>
  23
  24 #include "core.h"
  25 #include "bus.h"
  26 #include "mmc_ops.h"
  27 #include "sd.h"
  28 #include "sd_ops.h"
  29
  30 #define UHS_SDR104_MIN_DTR      (100 * 1000 * 1000)
  31 #define UHS_DDR50_MIN_DTR       (50 * 1000 * 1000)
  32 #define UHS_SDR50_MIN_DTR       (50 * 1000 * 1000)
  33 #define UHS_SDR25_MIN_DTR       (25 * 1000 * 1000)
  34 #define UHS_SDR12_MIN_DTR       (12.5 * 1000 * 1000)
  35
  36 static const unsigned int tran_exp[] = {
  37         10000,          100000,         1000000,        10000000,
  38         0,              0,              0,              0
  39 };
  40
  41 static const unsigned char tran_mant[] = {
  42         0,      10,     12,     13,     15,     20,     25,     30,
  43         35,     40,     45,     50,     55,     60,     70,     80,
  44 };
  45
  46 static const unsigned int tacc_exp[] = {
  47         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
  48 };
  49
  50 static const unsigned int tacc_mant[] = {
  51         0,      10,     12,     13,     15,     20,     25,     30,
  52         35,     40,     45,     50,     55,     60,     70,     80,
  53 };
  54
  55 static const unsigned int sd_au_size[] = {
  56         0,              SZ_16K / 512,           SZ_32K / 512,   SZ_64K / 512,
  57         SZ_128K / 512,  SZ_256K / 512,          SZ_512K / 512,  SZ_1M / 512,
  58         SZ_2M / 512,    SZ_4M / 512,            SZ_8M / 512,    (SZ_8M + SZ_4M) / 512,
  59         SZ_16M / 512,   (SZ_16M + SZ_8M) / 512, SZ_32M / 512,   SZ_64M / 512,
  60 };
  61
  62 #define UNSTUFF_BITS(resp,start,size)                                   \
  63         ({                                                              \
  64                 const int __size = size;                                \
  65                 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
  66                 const int __off = 3 - ((start) / 32);                   \
  67                 const int __shft = (start) & 31;                        \
  68                 u32 __res;                                              \
  69                                                                         \
  70                 __res = resp[__off] >> __shft;                          \
  71                 if (__size + __shft > 32)                               \
  72                         __res |= resp[__off-1] << ((32 - __shft) % 32); \
  73                 __res & __mask;                                         \
  74         })
  75
  76 /*
  77  * Given the decoded CSD structure, decode the raw CID to our CID structure.
  78  */
  79 void mmc_decode_cid(struct mmc_card *card)
  80 {
  81         u32 *resp = card->raw_cid;
  82
  83         memset(&card->cid, 0, sizeof(struct mmc_cid));
  84
  85         /*
  86          * SD doesn't currently have a version field so we will
  87          * have to assume we can parse this.
  88          */
  89         card->cid.manfid                = UNSTUFF_BITS(resp, 120, 8);
  90         card->cid.oemid                 = UNSTUFF_BITS(resp, 104, 16);
  91         card->cid.prod_name[0]          = UNSTUFF_BITS(resp, 96, 8);
  92         card->cid.prod_name[1]          = UNSTUFF_BITS(resp, 88, 8);
  93         card->cid.prod_name[2]          = UNSTUFF_BITS(resp, 80, 8);
  94         card->cid.prod_name[3]          = UNSTUFF_BITS(resp, 72, 8);
  95         card->cid.prod_name[4]          = UNSTUFF_BITS(resp, 64, 8);
  96         card->cid.hwrev                 = UNSTUFF_BITS(resp, 60, 4);
  97         card->cid.fwrev                 = UNSTUFF_BITS(resp, 56, 4);
  98         card->cid.serial                = UNSTUFF_BITS(resp, 24, 32);
  99         card->cid.year                  = UNSTUFF_BITS(resp, 12, 8);
 100         card->cid.month                 = UNSTUFF_BITS(resp, 8, 4);
 101
 102         card->cid.year += 2000; /* SD cards year offset */
 103 }
 104
 105 /*
 106  * Given a 128-bit response, decode to our card CSD structure.
 107  */
 108 static int mmc_decode_csd(struct mmc_card *card)
 109 {
 110         struct mmc_csd *csd = &card->csd;
 111         unsigned int e, m, csd_struct;
 112         u32 *resp = card->raw_csd;
 113
 114         csd_struct = UNSTUFF_BITS(resp, 126, 2);
 115
 116         switch (csd_struct) {
 117         case 0:
 118                 m = UNSTUFF_BITS(resp, 115, 4);
 119                 e = UNSTUFF_BITS(resp, 112, 3);
 120                 csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
 121                 csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
 122
 123                 m = UNSTUFF_BITS(resp, 99, 4);
 124                 e = UNSTUFF_BITS(resp, 96, 3);
 125                 csd->max_dtr      = tran_exp[e] * tran_mant[m];
 126                 csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
 127
 128                 e = UNSTUFF_BITS(resp, 47, 3);
 129                 m = UNSTUFF_BITS(resp, 62, 12);
 130                 csd->capacity     = (1 + m) << (e + 2);
 131
 132                 csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 133                 csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 134                 csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 135                 csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 136                 csd->dsr_imp = UNSTUFF_BITS(resp, 76, 1);
 137                 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 138                 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 139                 csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 140
 141                 if (UNSTUFF_BITS(resp, 46, 1)) {
 142                         csd->erase_size = 1;
 143                 } else if (csd->write_blkbits >= 9) {
 144                         csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
 145                         csd->erase_size <<= csd->write_blkbits - 9;
 146                 }
 147                 break;
 148         case 1:
 149                 /*
 150                  * This is a block-addressed SDHC or SDXC card. Most
 151                  * interesting fields are unused and have fixed
 152                  * values. To avoid getting tripped by buggy cards,
 153                  * we assume those fixed values ourselves.
 154                  */
 155                 mmc_card_set_blockaddr(card);
 156
 157                 csd->tacc_ns     = 0; /* Unused */
 158                 csd->tacc_clks   = 0; /* Unused */
 159
 160                 m = UNSTUFF_BITS(resp, 99, 4);
 161                 e = UNSTUFF_BITS(resp, 96, 3);
 162                 csd->max_dtr      = tran_exp[e] * tran_mant[m];
 163                 csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
 164                 csd->c_size       = UNSTUFF_BITS(resp, 48, 22);
 165
 166                 /* SDXC cards have a minimum C_SIZE of 0x00FFFF */
 167                 if (csd->c_size >= 0xFFFF)
 168                         mmc_card_set_ext_capacity(card);
 169
 170                 m = UNSTUFF_BITS(resp, 48, 22);
 171                 csd->capacity     = (1 + m) << 10;
 172
 173                 csd->read_blkbits = 9;
 174                 csd->read_partial = 0;
 175                 csd->write_misalign = 0;
 176                 csd->read_misalign = 0;
 177                 csd->r2w_factor = 4; /* Unused */
 178                 csd->write_blkbits = 9;
 179                 csd->write_partial = 0;
 180                 csd->erase_size = 1;
 181                 break;
 182         default:
 183                 pr_err("%s: unrecognised CSD structure version %d\n",
 184                         mmc_hostname(card->host), csd_struct);
 185                 return -EINVAL;
 186         }
 187
 188         card->erase_size = csd->erase_size;
 189
 190         return 0;
 191 }
 192
 193 /*
 194  * Given a 64-bit response, decode to our card SCR structure.
 195  */
 196 static int mmc_decode_scr(struct mmc_card *card)
 197 {
 198         struct sd_scr *scr = &card->scr;
 199         unsigned int scr_struct;
 200         u32 resp[4];
 201
 202         resp[3] = card->raw_scr[1];
 203         resp[2] = card->raw_scr[0];
 204
 205         scr_struct = UNSTUFF_BITS(resp, 60, 4);
 206         if (scr_struct != 0) {
 207                 pr_err("%s: unrecognised SCR structure version %d\n",
 208                         mmc_hostname(card->host), scr_struct);
 209                 return -EINVAL;
 210         }
 211
 212         scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
 213         scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 214         if (scr->sda_vsn == SCR_SPEC_VER_2)
 215                 /* Check if Physical Layer Spec v3.0 is supported */
 216                 scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
 217
 218         if (UNSTUFF_BITS(resp, 55, 1))
 219                 card->erased_byte = 0xFF;
 220         else
 221                 card->erased_byte = 0x0;
 222
 223         if (scr->sda_spec3)
 224                 scr->cmds = UNSTUFF_BITS(resp, 32, 2);
 225         return 0;
 226 }
 227
 228 /*
 229  * Fetch and process SD Status register.
 230  */
 231 static int mmc_read_ssr(struct mmc_card *card)
 232 {
 233         unsigned int au, es, et, eo;
 234         int err, i;
 235         u32 *ssr;
 236
 237         if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
 238                 pr_warn("%s: card lacks mandatory SD Status function\n",
 239                         mmc_hostname(card->host));
 240                 return 0;
 241         }
 242
 243         ssr = kmalloc(64, GFP_KERNEL);
 244         if (!ssr)
 245                 return -ENOMEM;
 246
 247         err = mmc_app_sd_status(card, ssr);
 248         if (err) {
 249                 pr_warn("%s: problem reading SD Status register\n",
 250                         mmc_hostname(card->host));
 251                 err = 0;
 252                 goto out;
 253         }
 254
 255         for (i = 0; i < 16; i++)
 256                 ssr[i] = be32_to_cpu(ssr[i]);
 257
 258         /*
 259          * UNSTUFF_BITS only works with four u32s so we have to offset the
 260          * bitfield positions accordingly.
 261          */
 262         au = UNSTUFF_BITS(ssr, 428 - 384, 4);
 263         if (au) {
 264                 if (au <= 9 || card->scr.sda_spec3) {
 265                         card->ssr.au = sd_au_size[au];
 266                         es = UNSTUFF_BITS(ssr, 408 - 384, 16);
 267                         et = UNSTUFF_BITS(ssr, 402 - 384, 6);
 268                         if (es && et) {
 269                                 eo = UNSTUFF_BITS(ssr, 400 - 384, 2);
 270                                 card->ssr.erase_timeout = (et * 1000) / es;
 271                                 card->ssr.erase_offset = eo * 1000;
 272                         }
 273                 } else {
 274                         pr_warn("%s: SD Status: Invalid Allocation Unit size\n",
 275                                 mmc_hostname(card->host));
 276                 }
 277         }
 278 out:
 279         kfree(ssr);
 280         return err;
 281 }
 282
 283 /*
 284  * Fetches and decodes switch information
 285  */
 286 static int mmc_read_switch(struct mmc_card *card)
 287 {
 288         int err;
 289         u8 *status;
 290
 291         if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 292                 return 0;
 293
 294         if (!(card->csd.cmdclass & CCC_SWITCH)) {
 295                 pr_warn("%s: card lacks mandatory switch function, performance might suffer\n",
 296                         mmc_hostname(card->host));
 297                 return 0;
 298         }
 299
 300         err = -EIO;
 301
 302         status = kmalloc(64, GFP_KERNEL);
 303         if (!status) {
 304                 pr_err("%s: could not allocate a buffer for "
 305                         "switch capabilities.\n",
 306                         mmc_hostname(card->host));
 307                 return -ENOMEM;
 308         }
 309
 310         /*
 311          * Find out the card's support bits with a mode 0 operation.
 312          * The argument does not matter, as the support bits do not
 313          * change with the arguments.
 314          */
 315         err = mmc_sd_switch(card, 0, 0, 0, status);
 316         if (err) {
 317                 /*
 318                  * If the host or the card can't do the switch,
 319                  * fail more gracefully.
 320                  */
 321                 if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 322                         goto out;
 323
 324                 pr_warn("%s: problem reading Bus Speed modes\n",
 325                         mmc_hostname(card->host));
 326                 err = 0;
 327
 328                 goto out;
 329         }
 330
 331         if (status[13] & SD_MODE_HIGH_SPEED)
 332                 card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
 333
 334         if (card->scr.sda_spec3) {
 335                 card->sw_caps.sd3_bus_mode = status[13];
 336                 /* Driver Strengths supported by the card */
 337                 card->sw_caps.sd3_drv_type = status[9];
 338                 card->sw_caps.sd3_curr_limit = status[7] | status[6] << 8;
 339         }
 340
 341 out:
 342         kfree(status);
 343
 344         return err;
 345 }
 346
 347 /*
 348  * Test if the card supports high-speed mode and, if so, switch to it.
 349  */
 350 int mmc_sd_switch_hs(struct mmc_card *card)
 351 {
 352         int err;
 353         u8 *status;
 354
 355         if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 356                 return 0;
 357
 358         if (!(card->csd.cmdclass & CCC_SWITCH))
 359                 return 0;
 360
 361         if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 362                 return 0;
 363
 364         if (card->sw_caps.hs_max_dtr == 0)
 365                 return 0;
 366
 367         status = kmalloc(64, GFP_KERNEL);
 368         if (!status) {
 369                 pr_err("%s: could not allocate a buffer for "
 370                         "switch capabilities.\n", mmc_hostname(card->host));
 371                 return -ENOMEM;
 372         }
 373
 374         err = mmc_sd_switch(card, 1, 0, 1, status);
 375         if (err)
 376                 goto out;
 377
 378         if ((status[16] & 0xF) != 1) {
 379                 pr_warn("%s: Problem switching card into high-speed mode!, status:%x\n",
 380                         mmc_hostname(card->host), (status[16] & 0xF));
 381                 err = -EBUSY;
 382         } else {
 383                 err = 1;
 384         }
 385
 386 out:
 387         kfree(status);
 388
 389         return err;
 390 }
 391
 392 static int sd_select_driver_type(struct mmc_card *card, u8 *status)
 393 {
 394         int card_drv_type, drive_strength, drv_type;
 395         int err;
 396
 397         card->drive_strength = 0;
 398
 399         card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B;
 400
 401         drive_strength = mmc_select_drive_strength(card,
 402                                                    card->sw_caps.uhs_max_dtr,
 403                                                    card_drv_type, &drv_type);
 404
 405         if (drive_strength) {
 406                 err = mmc_sd_switch(card, 1, 2, drive_strength, status);
 407                 if (err)
 408                         return err;
 409                 if ((status[15] & 0xF) != drive_strength) {
 410                         pr_warn("%s: Problem setting drive strength!\n",
 411                                 mmc_hostname(card->host));
 412                         return 0;
 413                 }
 414                 card->drive_strength = drive_strength;
 415         }
 416
 417         if (drv_type)
 418                 mmc_set_driver_type(card->host, drv_type);
 419
 420         return 0;
 421 }
 422
 423 static void sd_update_bus_speed_mode(struct mmc_card *card)
 424 {
 425         /*
 426          * If the host doesn't support any of the UHS-I modes, fallback on
 427          * default speed.
 428          */
 429         if (!mmc_host_uhs(card->host)) {
 430                 card->sd_bus_speed = 0;
 431                 return;
 432         }
 433
 434         if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 435             (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104) &&
 436             (card->host->f_max > UHS_SDR104_MIN_DTR)) {
 437                 card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
 438         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 439                     MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 440                     SD_MODE_UHS_SDR50) &&
 441                     (card->host->f_max > UHS_SDR50_MIN_DTR)) {
 442                 card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
 443         } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 444                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50) &&
 445                     (card->host->f_max > UHS_DDR50_MIN_DTR)) {
 446                 card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
 447         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 448                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 449                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25) &&
 450                  (card->host->f_max > UHS_SDR25_MIN_DTR)) {
 451                 card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
 452         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 453                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 454                     MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 455                     SD_MODE_UHS_SDR12)) {
 456                 card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
 457         }
 458 }
 459
 460 static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
 461 {
 462         int err;
 463         unsigned int timing = 0;
 464
 465         switch (card->sd_bus_speed) {
 466         case UHS_SDR104_BUS_SPEED:
 467                 timing = MMC_TIMING_UHS_SDR104;
 468                 card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 469                 break;
 470         case UHS_DDR50_BUS_SPEED:
 471                 timing = MMC_TIMING_UHS_DDR50;
 472                 card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 473                 break;
 474         case UHS_SDR50_BUS_SPEED:
 475                 timing = MMC_TIMING_UHS_SDR50;
 476                 card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 477                 break;
 478         case UHS_SDR25_BUS_SPEED:
 479                 timing = MMC_TIMING_UHS_SDR25;
 480                 card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 481                 break;
 482         case UHS_SDR12_BUS_SPEED:
 483                 timing = MMC_TIMING_UHS_SDR12;
 484                 card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 485                 break;
 486         default:
 487                 return 0;
 488         }
 489
 490         err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
 491         if (err)
 492                 return err;
 493
 494         if ((status[16] & 0xF) != card->sd_bus_speed) {
 495                 pr_warn("%s: Problem setting bus speed mode(%u)! max_dtr:%u, timing:%u, status:%x\n",
 496                         mmc_hostname(card->host), card->sd_bus_speed,
 497                         card->sw_caps.uhs_max_dtr, timing, (status[16] & 0xF));
 498                 err = -EBUSY;
 499         } else {
 500                 mmc_set_timing(card->host, timing);
 501                 mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
 502         }
 503
 504         return err;
 505 }
 506
 507 /* Get host's max current setting at its current voltage */
 508 static u32 sd_get_host_max_current(struct mmc_host *host)
 509 {
 510         u32 voltage, max_current;
 511
 512         voltage = 1 << host->ios.vdd;
 513         switch (voltage) {
 514         case MMC_VDD_165_195:
 515                 max_current = host->max_current_180;
 516                 break;
 517         case MMC_VDD_29_30:
 518         case MMC_VDD_30_31:
 519                 max_current = host->max_current_300;
 520                 break;
 521         case MMC_VDD_32_33:
 522         case MMC_VDD_33_34:
 523                 max_current = host->max_current_330;
 524                 break;
 525         default:
 526                 max_current = 0;
 527         }
 528
 529         return max_current;
 530 }
 531
 532 static int sd_set_current_limit(struct mmc_card *card, u8 *status)
 533 {
 534         int current_limit = SD_SET_CURRENT_NO_CHANGE;
 535         int err;
 536         u32 max_current;
 537
 538         /*
 539          * Current limit switch is only defined for SDR50, SDR104, and DDR50
 540          * bus speed modes. For other bus speed modes, we do not change the
 541          * current limit.
 542          */
 543         if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
 544             (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
 545             (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
 546                 return 0;
 547
 548         /*
 549          * Host has different current capabilities when operating at
 550          * different voltages, so find out its max current first.
 551          */
 552         max_current = sd_get_host_max_current(card->host);
 553
 554         /*
 555          * We only check host's capability here, if we set a limit that is
 556          * higher than the card's maximum current, the card will be using its
 557          * maximum current, e.g. if the card's maximum current is 300ma, and
 558          * when we set current limit to 200ma, the card will draw 200ma, and
 559          * when we set current limit to 400/600/800ma, the card will draw its
 560          * maximum 300ma from the host.
 561          *
 562          * The above is incorrect: if we try to set a current limit that is
 563          * not supported by the card, the card can rightfully error out the
 564          * attempt, and remain at the default current limit.  This results
 565          * in a 300mA card being limited to 200mA even though the host
 566          * supports 800mA. Failures seen with SanDisk 8GB UHS cards with
 567          * an iMX6 host. --rmk
 568          */
 569         if (max_current >= 800 &&
 570             card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
 571                 current_limit = SD_SET_CURRENT_LIMIT_800;
 572         else if (max_current >= 600 &&
 573                  card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
 574                 current_limit = SD_SET_CURRENT_LIMIT_600;
 575         else if (max_current >= 400 &&
 576                  card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
 577                 current_limit = SD_SET_CURRENT_LIMIT_400;
 578         else if (max_current >= 200 &&
 579                  card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
 580                 current_limit = SD_SET_CURRENT_LIMIT_200;
 581
 582         if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
 583                 err = mmc_sd_switch(card, 1, 3, current_limit, status);
 584                 if (err)
 585                         return err;
 586
 587                 if (((status[15] >> 4) & 0x0F) != current_limit)
 588                         pr_warn("%s: Problem setting current limit!\n",
 589                                 mmc_hostname(card->host));
 590
 591         }
 592
 593         return 0;
 594 }
 595
 596 /**
 597  * mmc_sd_change_bus_speed() - Change SD card bus frequency at runtime
 598  * @host: pointer to mmc host structure
 599  * @freq: pointer to desired frequency to be set
 600  *
 601  * Change the SD card bus frequency at runtime after the card is
 602  * initialized. Callers are expected to make sure of the card's
 603  * state (DATA/RCV/TRANSFER) beforing changing the frequency at runtime.
 604  *
 605  * If the frequency to change is greater than max. supported by card,
 606  * *freq is changed to max. supported by card and if it is less than min.
 607  * supported by host, *freq is changed to min. supported by host.
 608  */
 609 static int mmc_sd_change_bus_speed(struct mmc_host *host, unsigned long *freq)
 610 {
 611         int err = 0;
 612         struct mmc_card *card;
 613
 614         mmc_claim_host(host);
 615         /*
 616          * Assign card pointer after claiming host to avoid race
 617          * conditions that may arise during removal of the card.
 618          */
 619         card = host->card;
 620
 621         /* sanity checks */
 622         if (!card || !freq) {
 623                 err = -EINVAL;
 624                 goto out;
 625         }
 626
 627         mmc_set_clock(host, (unsigned int) (*freq));
 628
 629         if (!mmc_host_is_spi(card->host) && mmc_card_uhs(card)
 630                         && card->host->ops->execute_tuning) {
 631                 /*
 632                  * We try to probe host driver for tuning for any
 633                  * frequency, it is host driver responsibility to
 634                  * perform actual tuning only when required.
 635                  */
 636                 mmc_host_clk_hold(card->host);
 637                 err = card->host->ops->execute_tuning(card->host,
 638                                 MMC_SEND_TUNING_BLOCK);
 639                 mmc_host_clk_release(card->host);
 640
 641                 if (err) {
 642                         pr_warn("%s: %s: tuning execution failed %d. Restoring to previous clock %lu\n",
 643                                    mmc_hostname(card->host), __func__, err,
 644                                    host->clk_scaling.curr_freq);
 645                         mmc_set_clock(host, host->clk_scaling.curr_freq);
 646                 }
 647         }
 648
 649 out:
 650         mmc_release_host(host);
 651         return err;
 652 }
 653
 654 /*
 655  * UHS-I specific initialization procedure
 656  */
 657 static int mmc_sd_init_uhs_card(struct mmc_card *card)
 658 {
 659         int err;
 660         u8 *status;
 661
 662         if (!card->scr.sda_spec3)
 663                 return 0;
 664
 665         if (!(card->csd.cmdclass & CCC_SWITCH))
 666                 return 0;
 667
 668         status = kmalloc(64, GFP_KERNEL);
 669         if (!status) {
 670                 pr_err("%s: could not allocate a buffer for "
 671                         "switch capabilities.\n", mmc_hostname(card->host));
 672                 return -ENOMEM;
 673         }
 674
 675         /* Set 4-bit bus width */
 676         if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
 677             (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
 678                 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 679                 if (err)
 680                         goto out;
 681
 682                 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 683         }
 684
 685         /*
 686          * Select the bus speed mode depending on host
 687          * and card capability.
 688          */
 689         sd_update_bus_speed_mode(card);
 690
 691         /* Set the driver strength for the card */
 692         err = sd_select_driver_type(card, status);
 693         if (err)
 694                 goto out;
 695
 696         /* Set current limit for the card */
 697         err = sd_set_current_limit(card, status);
 698         if (err)
 699                 goto out;
 700
 701         /* Set bus speed mode of the card */
 702         err = sd_set_bus_speed_mode(card, status);
 703         if (err)
 704                 goto out;
 705
 706         /*
 707          * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
 708          * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
 709          */
 710         if (!mmc_host_is_spi(card->host) &&
 711                 (card->host->ios.timing == MMC_TIMING_UHS_SDR50 ||
 712                  card->host->ios.timing == MMC_TIMING_UHS_DDR50 ||
 713                  card->host->ios.timing == MMC_TIMING_UHS_SDR104)) {
 714                 err = mmc_execute_tuning(card);
 715
 716                 /*
 717                  * As SD Specifications Part1 Physical Layer Specification
 718                  * Version 3.01 says, CMD19 tuning is available for unlocked
 719                  * cards in transfer state of 1.8V signaling mode. The small
 720                  * difference between v3.00 and 3.01 spec means that CMD19
 721                  * tuning is also available for DDR50 mode.
 722                  */
 723                 if (err && card->host->ios.timing == MMC_TIMING_UHS_DDR50) {
 724                         pr_warn("%s: ddr50 tuning failed\n",
 725                                 mmc_hostname(card->host));
 726                         err = 0;
 727                 }
 728         }
 729
 730 out:
 731         kfree(status);
 732
 733         return err;
 734 }
 735
 736 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 737         card->raw_cid[2], card->raw_cid[3]);
 738 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 739         card->raw_csd[2], card->raw_csd[3]);
 740 MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 741 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 742 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 743 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 744 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 745 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 746 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 747 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 748 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 749 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 750
 751
 752 static struct attribute *sd_std_attrs[] = {
 753         &dev_attr_cid.attr,
 754         &dev_attr_csd.attr,
 755         &dev_attr_scr.attr,
 756         &dev_attr_date.attr,
 757         &dev_attr_erase_size.attr,
 758         &dev_attr_preferred_erase_size.attr,
 759         &dev_attr_fwrev.attr,
 760         &dev_attr_hwrev.attr,
 761         &dev_attr_manfid.attr,
 762         &dev_attr_name.attr,
 763         &dev_attr_oemid.attr,
 764         &dev_attr_serial.attr,
 765         NULL,
 766 };
 767 ATTRIBUTE_GROUPS(sd_std);
 768
 769 struct device_type sd_type = {
 770         .groups = sd_std_groups,
 771 };
 772
 773 /*
 774  * Fetch CID from card.
 775  */
 776 int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 777 {
 778         int err;
 779         u32 max_current;
 780         int retries = 10;
 781         u32 pocr = ocr;
 782
 783 try_again:
 784         if (!retries) {
 785                 ocr &= ~SD_OCR_S18R;
 786                 pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
 787         }
 788
 789         /*
 790          * Since we're changing the OCR value, we seem to
 791          * need to tell some cards to go back to the idle
 792          * state.  We wait 1ms to give cards time to
 793          * respond.
 794          */
 795         mmc_go_idle(host);
 796
 797         /*
 798          * If SD_SEND_IF_COND indicates an SD 2.0
 799          * compliant card and we should set bit 30
 800          * of the ocr to indicate that we can handle
 801          * block-addressed SDHC cards.
 802          */
 803         err = mmc_send_if_cond(host, ocr);
 804         if (!err)
 805                 ocr |= SD_OCR_CCS;
 806
 807         /*
 808          * If the host supports one of UHS-I modes, request the card
 809          * to switch to 1.8V signaling level. If the card has failed
 810          * repeatedly to switch however, skip this.
 811          */
 812         if (retries && mmc_host_uhs(host))
 813                 ocr |= SD_OCR_S18R;
 814
 815         /*
 816          * If the host can supply more than 150mA at current voltage,
 817          * XPC should be set to 1.
 818          */
 819         max_current = sd_get_host_max_current(host);
 820         if (max_current > 150)
 821                 ocr |= SD_OCR_XPC;
 822
 823         err = mmc_send_app_op_cond(host, ocr, rocr);
 824         if (err)
 825                 return err;
 826
 827         /*
 828          * In case CCS and S18A in the response is set, start Signal Voltage
 829          * Switch procedure. SPI mode doesn't support CMD11.
 830          */
 831         if (!mmc_host_is_spi(host) && rocr &&
 832            ((*rocr & 0x41000000) == 0x41000000)) {
 833                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180,
 834                                         pocr);
 835                 if (err == -EAGAIN) {
 836                         retries--;
 837                         goto try_again;
 838                 } else if (err) {
 839                         retries = 0;
 840                         goto try_again;
 841                 }
 842         }
 843
 844         if (mmc_host_is_spi(host))
 845                 err = mmc_send_cid(host, cid);
 846         else
 847                 err = mmc_all_send_cid(host, cid);
 848
 849         return err;
 850 }
 851
 852 int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
 853 {
 854         int err;
 855
 856         /*
 857          * Fetch CSD from card.
 858          */
 859         err = mmc_send_csd(card, card->raw_csd);
 860         if (err)
 861                 return err;
 862
 863         err = mmc_decode_csd(card);
 864         if (err)
 865                 return err;
 866
 867         return 0;
 868 }
 869
 870 static int mmc_sd_get_ro(struct mmc_host *host)
 871 {
 872         int ro;
 873
 874         /*
 875          * Some systems don't feature a write-protect pin and don't need one.
 876          * E.g. because they only have micro-SD card slot. For those systems
 877          * assume that the SD card is always read-write.
 878          */
 879         if (host->caps2 & MMC_CAP2_NO_WRITE_PROTECT)
 880                 return 0;
 881
 882         if (!host->ops->get_ro)
 883                 return -1;
 884
 885         mmc_host_clk_hold(host);
 886         ro = host->ops->get_ro(host);
 887         mmc_host_clk_release(host);
 888
 889         return ro;
 890 }
 891
 892 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
 893         bool reinit)
 894 {
 895         int err;
 896 #ifdef CONFIG_MMC_PARANOID_SD_INIT
 897         int retries;
 898 #endif
 899
 900         if (!reinit) {
 901                 /*
 902                  * Fetch SCR from card.
 903                  */
 904                 err = mmc_app_send_scr(card, card->raw_scr);
 905                 if (err)
 906                         return err;
 907
 908                 err = mmc_decode_scr(card);
 909                 if (err)
 910                         return err;
 911
 912                 /*
 913                  * Fetch and process SD Status register.
 914                  */
 915                 err = mmc_read_ssr(card);
 916                 if (err)
 917                         return err;
 918
 919                 /* Erase init depends on CSD and SSR */
 920                 mmc_init_erase(card);
 921
 922                 /*
 923                  * Fetch switch information from card.
 924                  */
 925 #ifdef CONFIG_MMC_PARANOID_SD_INIT
 926                 for (retries = 1; retries <= 3; retries++) {
 927                         err = mmc_read_switch(card);
 928                         if (!err) {
 929                                 if (retries > 1) {
 930                                         printk(KERN_WARNING
 931                                                "%s: recovered\n",
 932                                                mmc_hostname(host));
 933                                 }
 934                                 break;
 935                         } else {
 936                                 printk(KERN_WARNING
 937                                        "%s: read switch failed (attempt %d)\n",
 938                                        mmc_hostname(host), retries);
 939                         }
 940                 }
 941 #else
 942                 err = mmc_read_switch(card);
 943 #endif
 944
 945                 if (err)
 946                         return err;
 947         }
 948
 949         /*
 950          * For SPI, enable CRC as appropriate.
 951          * This CRC enable is located AFTER the reading of the
 952          * card registers because some SDHC cards are not able
 953          * to provide valid CRCs for non-512-byte blocks.
 954          */
 955         if (mmc_host_is_spi(host)) {
 956                 err = mmc_spi_set_crc(host, use_spi_crc);
 957                 if (err)
 958                         return err;
 959         }
 960
 961         /*
 962          * Check if read-only switch is active.
 963          */
 964         if (!reinit) {
 965                 int ro = mmc_sd_get_ro(host);
 966
 967                 if (ro < 0) {
 968                         pr_warn("%s: host does not support reading read-only switch, assuming write-enable\n",
 969                                 mmc_hostname(host));
 970                 } else if (ro > 0) {
 971                         mmc_card_set_readonly(card);
 972                 }
 973         }
 974
 975         return 0;
 976 }
 977
 978 unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 979 {
 980         unsigned max_dtr = (unsigned int)-1;
 981
 982         if (mmc_card_uhs(card)) {
 983                 if (max_dtr > card->sw_caps.uhs_max_dtr)
 984                         max_dtr = card->sw_caps.uhs_max_dtr;
 985         } else if (mmc_card_hs(card)) {
 986                 if (max_dtr > card->sw_caps.hs_max_dtr)
 987                         max_dtr = card->sw_caps.hs_max_dtr;
 988         } else if (max_dtr > card->csd.max_dtr) {
 989                 max_dtr = card->csd.max_dtr;
 990         }
 991
 992         return max_dtr;
 993 }
 994
 995 /*
 996  * Handle the detection and initialisation of a card.
 997  *
 998  * In the case of a resume, "oldcard" will contain the card
 999  * we're trying to reinitialise.
1000  */
1001 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
1002         struct mmc_card *oldcard)
1003 {
1004         struct mmc_card *card;
1005         int err;
1006         u32 cid[4];
1007         u32 rocr = 0;
1008
1009         BUG_ON(!host);
1010         WARN_ON(!host->claimed);
1011
1012         err = mmc_sd_get_cid(host, ocr, cid, &rocr);
1013         if (err)
1014                 return err;
1015
1016         if (oldcard) {
1017                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
1018                         return -ENOENT;
1019
1020                 card = oldcard;
1021         } else {
1022                 /*
1023                  * Allocate card structure.
1024                  */
1025                 card = mmc_alloc_card(host, &sd_type);
1026                 if (IS_ERR(card))
1027                         return PTR_ERR(card);
1028
1029                 card->ocr = ocr;
1030                 card->type = MMC_TYPE_SD;
1031                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1032         }
1033
1034         /*
1035          * Call the optional HC's init_card function to handle quirks.
1036          */
1037         if (host->ops->init_card)
1038                 host->ops->init_card(host, card);
1039
1040         /*
1041          * For native busses:  get card RCA and quit open drain mode.
1042          */
1043         if (!mmc_host_is_spi(host)) {
1044                 err = mmc_send_relative_addr(host, &card->rca);
1045                 if (err)
1046                         goto free_card;
1047                 host->card = card;
1048         }
1049
1050         if (!oldcard) {
1051                 err = mmc_sd_get_csd(host, card);
1052                 if (err)
1053                         goto free_card;
1054
1055                 mmc_decode_cid(card);
1056         }
1057
1058         /*
1059          * handling only for cards supporting DSR and hosts requesting
1060          * DSR configuration
1061          */
1062         if (card->csd.dsr_imp && host->dsr_req)
1063                 mmc_set_dsr(host);
1064
1065         /*
1066          * Select card, as all following commands rely on that.
1067          */
1068         if (!mmc_host_is_spi(host)) {
1069                 err = mmc_select_card(card);
1070                 if (err)
1071                         goto free_card;
1072         }
1073
1074         err = mmc_sd_setup_card(host, card, oldcard != NULL);
1075         if (err)
1076                 goto free_card;
1077
1078         /* Initialization sequence for UHS-I cards */
1079         if (rocr & SD_ROCR_S18A) {
1080                 err = mmc_sd_init_uhs_card(card);
1081                 if (err)
1082                         goto free_card;
1083         } else {
1084                 /*
1085                  * Attempt to change to high-speed (if supported)
1086                  */
1087                 err = mmc_sd_switch_hs(card);
1088                 if (err > 0)
1089                         mmc_set_timing(card->host, MMC_TIMING_SD_HS);
1090                 else if (err)
1091                         goto free_card;
1092
1093                 /*
1094                  * Set bus speed.
1095                  */
1096                 mmc_set_clock(host, mmc_sd_get_max_clock(card));
1097
1098                 /*
1099                  * Switch to wider bus (if supported).
1100                  */
1101                 if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1102                         (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1103                         err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1104                         if (err)
1105                                 goto free_card;
1106
1107                         mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1108                 }
1109         }
1110
1111         card->clk_scaling_highest = mmc_sd_get_max_clock(card);
1112         card->clk_scaling_lowest = host->f_min;
1113
1114         return 0;
1115
1116 free_card:
1117         if (!oldcard) {
1118                 host->card = NULL;
1119                 mmc_remove_card(card);
1120         }
1121
1122         return err;
1123 }
1124
1125 /*
1126  * Host is being removed. Free up the current card.
1127  */
1128 static void mmc_sd_remove(struct mmc_host *host)
1129 {
1130         BUG_ON(!host);
1131         BUG_ON(!host->card);
1132
1133         mmc_exit_clk_scaling(host);
1134         mmc_remove_card(host->card);
1135
1136         mmc_claim_host(host);
1137         host->card = NULL;
1138         mmc_release_host(host);
1139 }
1140
1141 /*
1142  * Card detection - card is alive.
1143  */
1144 static int mmc_sd_alive(struct mmc_host *host)
1145 {
1146         if (host->ops->get_cd && !host->ops->get_cd(host))
1147                 return -ENOMEDIUM;
1148
1149         return mmc_send_status(host->card, NULL);
1150 }
1151
1152 /*
1153  * Card detection callback from host.
1154  */
1155 static void mmc_sd_detect(struct mmc_host *host)
1156 {
1157         int err = 0;
1158 #ifdef CONFIG_MMC_PARANOID_SD_INIT
1159         int retries = 5;
1160 #endif
1161
1162         BUG_ON(!host);
1163         BUG_ON(!host->card);
1164
1165         /*
1166          * Try to acquire claim host. If failed to get the lock in 2 sec,
1167          * just return; This is to ensure that when this call is invoked
1168          * due to pm_suspend, not to block suspend for longer duration.
1169          */
1170         pm_runtime_get_sync(&host->card->dev);
1171         if (!mmc_try_claim_host(host, 2000)) {
1172                 pm_runtime_mark_last_busy(&host->card->dev);
1173                 pm_runtime_put_autosuspend(&host->card->dev);
1174                 return;
1175         }
1176
1177         if (mmc_bus_needs_resume(host))
1178                 mmc_resume_bus(host);
1179
1180         if (host->ops->get_cd && !host->ops->get_cd(host)) {
1181                 err = -ENOMEDIUM;
1182                 mmc_card_set_removed(host->card);
1183                 mmc_card_clr_suspended(host->card);
1184                 goto out;
1185         }
1186
1187         /*
1188          * Just check if our card has been removed.
1189          */
1190 #ifdef CONFIG_MMC_PARANOID_SD_INIT
1191         while(retries) {
1192                 err = mmc_send_status(host->card, NULL);
1193                 if (err) {
1194                         retries--;
1195                         udelay(5);
1196                         continue;
1197                 }
1198                 break;
1199         }
1200         if (!retries) {
1201                 printk(KERN_ERR "%s(%s): Unable to re-detect card (%d)\n",
1202                        __func__, mmc_hostname(host), err);
1203                 err = _mmc_detect_card_removed(host);
1204         }
1205 #else
1206         err = _mmc_detect_card_removed(host);
1207 #endif
1208
1209 out:
1210         mmc_put_card(host->card);
1211
1212         if (err) {
1213                 mmc_sd_remove(host);
1214
1215                 mmc_claim_host(host);
1216                 mmc_detach_bus(host);
1217                 mmc_power_off(host);
1218                 mmc_release_host(host);
1219         }
1220 }
1221
1222 static int _mmc_sd_suspend(struct mmc_host *host)
1223 {
1224         int err = 0;
1225
1226         BUG_ON(!host);
1227         BUG_ON(!host->card);
1228
1229         err = mmc_suspend_clk_scaling(host);
1230         if (err) {
1231                 pr_err("%s: %s: fail to suspend clock scaling (%d)\n",
1232                         mmc_hostname(host), __func__,  err);
1233                 return err;
1234         }
1235
1236         mmc_claim_host(host);
1237
1238         if (mmc_card_suspended(host->card))
1239                 goto out;
1240
1241         if (!mmc_host_is_spi(host))
1242                 err = mmc_deselect_cards(host);
1243
1244         if (!err) {
1245                 mmc_power_off(host);
1246                 mmc_card_set_suspended(host->card);
1247         }
1248
1249 out:
1250         mmc_release_host(host);
1251         return err;
1252 }
1253
1254 /*
1255  * Callback for suspend
1256  */
1257 static int mmc_sd_suspend(struct mmc_host *host)
1258 {
1259         int err;
1260
1261         MMC_TRACE(host, "%s: Enter\n", __func__);
1262         err = _mmc_sd_suspend(host);
1263         if (!err) {
1264                 pm_runtime_disable(&host->card->dev);
1265                 pm_runtime_set_suspended(&host->card->dev);
1266         /* if suspend fails, force mmc_detect_change during resume */
1267         } else if (mmc_bus_manual_resume(host))
1268                 host->ignore_bus_resume_flags = true;
1269
1270         MMC_TRACE(host, "%s: Exit err: %d\n", __func__, err);
1271
1272         return err;
1273 }
1274
1275 /*
1276  * This function tries to determine if the same card is still present
1277  * and, if so, restore all state to it.
1278  */
1279 static int _mmc_sd_resume(struct mmc_host *host)
1280 {
1281         int err = 0;
1282 #ifdef CONFIG_MMC_PARANOID_SD_INIT
1283         int retries;
1284 #endif
1285
1286         BUG_ON(!host);
1287         BUG_ON(!host->card);
1288
1289         mmc_claim_host(host);
1290
1291         if (!mmc_card_suspended(host->card))
1292                 goto out;
1293
1294         if (host->ops->get_cd && !host->ops->get_cd(host)) {
1295                 mmc_card_clr_suspended(host->card);
1296                 goto out;
1297         }
1298
1299         mmc_power_up(host, host->card->ocr);
1300 #ifdef CONFIG_MMC_PARANOID_SD_INIT
1301         retries = 5;
1302         while (retries) {
1303                 err = mmc_sd_init_card(host, host->card->ocr, host->card);
1304
1305                 if (err) {
1306                         printk(KERN_ERR "%s: Re-init card rc = %d (retries = %d)\n",
1307                                mmc_hostname(host), err, retries);
1308                         retries--;
1309                         mmc_power_off(host);
1310                         usleep_range(5000, 5500);
1311                         mmc_power_up(host, host->card->ocr);
1312                         mmc_select_voltage(host, host->card->ocr);
1313                         continue;
1314                 }
1315                 break;
1316         }
1317 #else
1318         err = mmc_sd_init_card(host, host->card->ocr, host->card);
1319 #endif
1320         if (err) {
1321                 pr_err("%s: %s: mmc_sd_init_card_failed (%d)\n",
1322                                 mmc_hostname(host), __func__, err);
1323                 mmc_power_off(host);
1324                 goto out;
1325         }
1326         mmc_card_clr_suspended(host->card);
1327
1328         if (host->card->sdr104_blocked)
1329                 goto out;
1330         err = mmc_resume_clk_scaling(host);
1331         if (err) {
1332                 pr_err("%s: %s: fail to resume clock scaling (%d)\n",
1333                         mmc_hostname(host), __func__, err);
1334                 goto out;
1335         }
1336
1337 out:
1338         mmc_release_host(host);
1339         return err;
1340 }
1341
1342 /*
1343  * Callback for resume
1344  */
1345 static int mmc_sd_resume(struct mmc_host *host)
1346 {
1347         int err = 0;
1348
1349         MMC_TRACE(host, "%s: Enter\n", __func__);
1350         if (!(host->caps & MMC_CAP_RUNTIME_RESUME)) {
1351                 err = _mmc_sd_resume(host);
1352                 pm_runtime_set_active(&host->card->dev);
1353                 pm_runtime_mark_last_busy(&host->card->dev);
1354         }
1355         pm_runtime_enable(&host->card->dev);
1356         MMC_TRACE(host, "%s: Exit err: %d\n", __func__, err);
1357
1358         return err;
1359 }
1360
1361 /*
1362  * Callback for runtime_suspend.
1363  */
1364 static int mmc_sd_runtime_suspend(struct mmc_host *host)
1365 {
1366         int err;
1367
1368         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1369                 return 0;
1370
1371         err = _mmc_sd_suspend(host);
1372         if (err)
1373                 pr_err("%s: error %d doing aggressive suspend\n",
1374                         mmc_hostname(host), err);
1375
1376         return err;
1377 }
1378
1379 /*
1380  * Callback for runtime_resume.
1381  */
1382 static int mmc_sd_runtime_resume(struct mmc_host *host)
1383 {
1384         int err;
1385
1386         if (!(host->caps & (MMC_CAP_AGGRESSIVE_PM | MMC_CAP_RUNTIME_RESUME)))
1387                 return 0;
1388
1389         err = _mmc_sd_resume(host);
1390         if (err)
1391                 pr_err("%s: error %d doing aggressive resume\n",
1392                         mmc_hostname(host), err);
1393
1394         return 0;
1395 }
1396
1397 static int mmc_sd_reset(struct mmc_host *host)
1398 {
1399         if (host->ops->get_cd && !host->ops->get_cd(host))
1400                 return -ENOMEDIUM;
1401
1402         mmc_power_cycle(host, host->card->ocr);
1403         return mmc_sd_init_card(host, host->card->ocr, host->card);
1404 }
1405
1406 static const struct mmc_bus_ops mmc_sd_ops = {
1407         .remove = mmc_sd_remove,
1408         .detect = mmc_sd_detect,
1409         .runtime_suspend = mmc_sd_runtime_suspend,
1410         .runtime_resume = mmc_sd_runtime_resume,
1411         .suspend = mmc_sd_suspend,
1412         .resume = mmc_sd_resume,
1413         .alive = mmc_sd_alive,
1414         .change_bus_speed = mmc_sd_change_bus_speed,
1415         .reset = mmc_sd_reset,
1416 };
1417
1418 /*
1419  * Starting point for SD card init.
1420  */
1421 int mmc_attach_sd(struct mmc_host *host)
1422 {
1423         int err;
1424         u32 ocr, rocr;
1425 #ifdef CONFIG_MMC_PARANOID_SD_INIT
1426         int retries;
1427 #endif
1428
1429         BUG_ON(!host);
1430         WARN_ON(!host->claimed);
1431
1432         err = mmc_send_app_op_cond(host, 0, &ocr);
1433         if (err)
1434                 return err;
1435
1436         mmc_attach_bus(host, &mmc_sd_ops);
1437         if (host->ocr_avail_sd)
1438                 host->ocr_avail = host->ocr_avail_sd;
1439
1440         /*
1441          * We need to get OCR a different way for SPI.
1442          */
1443         if (mmc_host_is_spi(host)) {
1444                 mmc_go_idle(host);
1445
1446                 err = mmc_spi_read_ocr(host, 0, &ocr);
1447                 if (err)
1448                         goto err;
1449         }
1450
1451         rocr = mmc_select_voltage(host, ocr);
1452
1453         /*
1454          * Can we support the voltage(s) of the card(s)?
1455          */
1456         if (!rocr) {
1457                 err = -EINVAL;
1458                 goto err;
1459         }
1460
1461         /*
1462          * Detect and init the card.
1463          */
1464 #ifdef CONFIG_MMC_PARANOID_SD_INIT
1465         retries = 5;
1466         while (retries) {
1467                 err = mmc_sd_init_card(host, rocr, NULL);
1468                 if (err) {
1469                         retries--;
1470                         mmc_power_off(host);
1471                         usleep_range(5000, 5500);
1472                         mmc_power_up(host, rocr);
1473                         mmc_select_voltage(host, rocr);
1474                         continue;
1475                 }
1476                 break;
1477         }
1478
1479         if (!retries) {
1480                 printk(KERN_ERR "%s: mmc_sd_init_card() failure (err = %d)\n",
1481                        mmc_hostname(host), err);
1482                 goto err;
1483         }
1484 #else
1485         err = mmc_sd_init_card(host, rocr, NULL);
1486         if (err)
1487                 goto err;
1488 #endif
1489
1490         mmc_release_host(host);
1491         err = mmc_add_card(host->card);
1492         if (err)
1493                 goto remove_card;
1494
1495         mmc_claim_host(host);
1496
1497         err = mmc_init_clk_scaling(host);
1498         if (err) {
1499                 mmc_release_host(host);
1500                 goto remove_card;
1501         }
1502
1503         return 0;
1504
1505 remove_card:
1506         mmc_remove_card(host->card);
1507         host->card = NULL;
1508         mmc_claim_host(host);
1509 err:
1510         mmc_detach_bus(host);
1511
1512         pr_err("%s: error %d whilst initialising SD card\n",
1513                 mmc_hostname(host), err);
1514
1515         return err;
1516 }