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/slab.h>
  15 #include <linux/stat.h>
  16
  17 #include <linux/mmc/host.h>
  18 #include <linux/mmc/card.h>
  19 #include <linux/mmc/mmc.h>
  20 #include <linux/mmc/sd.h>
  21
  22 #include "core.h"
  23 #include "bus.h"
  24 #include "mmc_ops.h"
  25 #include "sd.h"
  26 #include "sd_ops.h"
  27
  28 static const unsigned int tran_exp[] = {
  29         10000,          100000,         1000000,        10000000,
  30         0,              0,              0,              0
  31 };
  32
  33 static const unsigned char tran_mant[] = {
  34         0,      10,     12,     13,     15,     20,     25,     30,
  35         35,     40,     45,     50,     55,     60,     70,     80,
  36 };
  37
  38 static const unsigned int tacc_exp[] = {
  39         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
  40 };
  41
  42 static const unsigned int tacc_mant[] = {
  43         0,      10,     12,     13,     15,     20,     25,     30,
  44         35,     40,     45,     50,     55,     60,     70,     80,
  45 };
  46
  47 #define UNSTUFF_BITS(resp,start,size)                                   \
  48         ({                                                              \
  49                 const int __size = size;                                \
  50                 const u32 __mask = (__size < 32 ? 1 << __size : 0) - 1; \
  51                 const int __off = 3 - ((start) / 32);                   \
  52                 const int __shft = (start) & 31;                        \
  53                 u32 __res;                                              \
  54                                                                         \
  55                 __res = resp[__off] >> __shft;                          \
  56                 if (__size + __shft > 32)                               \
  57                         __res |= resp[__off-1] << ((32 - __shft) % 32); \
  58                 __res & __mask;                                         \
  59         })
  60
  61 /*
  62  * Given the decoded CSD structure, decode the raw CID to our CID structure.
  63  */
  64 void mmc_decode_cid(struct mmc_card *card)
  65 {
  66         u32 *resp = card->raw_cid;
  67
  68         memset(&card->cid, 0, sizeof(struct mmc_cid));
  69
  70         /*
  71          * SD doesn't currently have a version field so we will
  72          * have to assume we can parse this.
  73          */
  74         card->cid.manfid                = UNSTUFF_BITS(resp, 120, 8);
  75         card->cid.oemid                 = UNSTUFF_BITS(resp, 104, 16);
  76         card->cid.prod_name[0]          = UNSTUFF_BITS(resp, 96, 8);
  77         card->cid.prod_name[1]          = UNSTUFF_BITS(resp, 88, 8);
  78         card->cid.prod_name[2]          = UNSTUFF_BITS(resp, 80, 8);
  79         card->cid.prod_name[3]          = UNSTUFF_BITS(resp, 72, 8);
  80         card->cid.prod_name[4]          = UNSTUFF_BITS(resp, 64, 8);
  81         card->cid.hwrev                 = UNSTUFF_BITS(resp, 60, 4);
  82         card->cid.fwrev                 = UNSTUFF_BITS(resp, 56, 4);
  83         card->cid.serial                = UNSTUFF_BITS(resp, 24, 32);
  84         card->cid.year                  = UNSTUFF_BITS(resp, 12, 8);
  85         card->cid.month                 = UNSTUFF_BITS(resp, 8, 4);
  86
  87         card->cid.year += 2000; /* SD cards year offset */
  88 }
  89
  90 /*
  91  * Given a 128-bit response, decode to our card CSD structure.
  92  */
  93 static int mmc_decode_csd(struct mmc_card *card)
  94 {
  95         struct mmc_csd *csd = &card->csd;
  96         unsigned int e, m, csd_struct;
  97         u32 *resp = card->raw_csd;
  98
  99         csd_struct = UNSTUFF_BITS(resp, 126, 2);
 100
 101         switch (csd_struct) {
 102         case 0:
 103                 m = UNSTUFF_BITS(resp, 115, 4);
 104                 e = UNSTUFF_BITS(resp, 112, 3);
 105                 csd->tacc_ns     = (tacc_exp[e] * tacc_mant[m] + 9) / 10;
 106                 csd->tacc_clks   = UNSTUFF_BITS(resp, 104, 8) * 100;
 107
 108                 m = UNSTUFF_BITS(resp, 99, 4);
 109                 e = UNSTUFF_BITS(resp, 96, 3);
 110                 csd->max_dtr      = tran_exp[e] * tran_mant[m];
 111                 csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
 112
 113                 e = UNSTUFF_BITS(resp, 47, 3);
 114                 m = UNSTUFF_BITS(resp, 62, 12);
 115                 csd->capacity     = (1 + m) << (e + 2);
 116
 117                 csd->read_blkbits = UNSTUFF_BITS(resp, 80, 4);
 118                 csd->read_partial = UNSTUFF_BITS(resp, 79, 1);
 119                 csd->write_misalign = UNSTUFF_BITS(resp, 78, 1);
 120                 csd->read_misalign = UNSTUFF_BITS(resp, 77, 1);
 121                 csd->r2w_factor = UNSTUFF_BITS(resp, 26, 3);
 122                 csd->write_blkbits = UNSTUFF_BITS(resp, 22, 4);
 123                 csd->write_partial = UNSTUFF_BITS(resp, 21, 1);
 124
 125                 if (UNSTUFF_BITS(resp, 46, 1)) {
 126                         csd->erase_size = 1;
 127                 } else if (csd->write_blkbits >= 9) {
 128                         csd->erase_size = UNSTUFF_BITS(resp, 39, 7) + 1;
 129                         csd->erase_size <<= csd->write_blkbits - 9;
 130                 }
 131                 break;
 132         case 1:
 133                 /*
 134                  * This is a block-addressed SDHC or SDXC card. Most
 135                  * interesting fields are unused and have fixed
 136                  * values. To avoid getting tripped by buggy cards,
 137                  * we assume those fixed values ourselves.
 138                  */
 139                 mmc_card_set_blockaddr(card);
 140
 141                 csd->tacc_ns     = 0; /* Unused */
 142                 csd->tacc_clks   = 0; /* Unused */
 143
 144                 m = UNSTUFF_BITS(resp, 99, 4);
 145                 e = UNSTUFF_BITS(resp, 96, 3);
 146                 csd->max_dtr      = tran_exp[e] * tran_mant[m];
 147                 csd->cmdclass     = UNSTUFF_BITS(resp, 84, 12);
 148                 csd->c_size       = UNSTUFF_BITS(resp, 48, 22);
 149
 150                 /* SDXC cards have a minimum C_SIZE of 0x00FFFF */
 151                 if (csd->c_size >= 0xFFFF)
 152                         mmc_card_set_ext_capacity(card);
 153
 154                 m = UNSTUFF_BITS(resp, 48, 22);
 155                 csd->capacity     = (1 + m) << 10;
 156
 157                 csd->read_blkbits = 9;
 158                 csd->read_partial = 0;
 159                 csd->write_misalign = 0;
 160                 csd->read_misalign = 0;
 161                 csd->r2w_factor = 4; /* Unused */
 162                 csd->write_blkbits = 9;
 163                 csd->write_partial = 0;
 164                 csd->erase_size = 1;
 165                 break;
 166         default:
 167                 pr_err("%s: unrecognised CSD structure version %d\n",
 168                         mmc_hostname(card->host), csd_struct);
 169                 return -EINVAL;
 170         }
 171
 172         card->erase_size = csd->erase_size;
 173
 174         return 0;
 175 }
 176
 177 /*
 178  * Given a 64-bit response, decode to our card SCR structure.
 179  */
 180 static int mmc_decode_scr(struct mmc_card *card)
 181 {
 182         struct sd_scr *scr = &card->scr;
 183         unsigned int scr_struct;
 184         u32 resp[4];
 185
 186         resp[3] = card->raw_scr[1];
 187         resp[2] = card->raw_scr[0];
 188
 189         scr_struct = UNSTUFF_BITS(resp, 60, 4);
 190         if (scr_struct != 0) {
 191                 pr_err("%s: unrecognised SCR structure version %d\n",
 192                         mmc_hostname(card->host), scr_struct);
 193                 return -EINVAL;
 194         }
 195
 196         scr->sda_vsn = UNSTUFF_BITS(resp, 56, 4);
 197         scr->bus_widths = UNSTUFF_BITS(resp, 48, 4);
 198         if (scr->sda_vsn == SCR_SPEC_VER_2)
 199                 /* Check if Physical Layer Spec v3.0 is supported */
 200                 scr->sda_spec3 = UNSTUFF_BITS(resp, 47, 1);
 201
 202         if (UNSTUFF_BITS(resp, 55, 1))
 203                 card->erased_byte = 0xFF;
 204         else
 205                 card->erased_byte = 0x0;
 206
 207         if (scr->sda_spec3)
 208                 scr->cmds = UNSTUFF_BITS(resp, 32, 2);
 209         return 0;
 210 }
 211
 212 /*
 213  * Fetch and process SD Status register.
 214  */
 215 static int mmc_read_ssr(struct mmc_card *card)
 216 {
 217         unsigned int au, es, et, eo;
 218         int err, i, max_au;
 219         u32 *ssr;
 220
 221         if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
 222                 pr_warning("%s: card lacks mandatory SD Status "
 223                         "function.\n", mmc_hostname(card->host));
 224                 return 0;
 225         }
 226
 227         ssr = kmalloc(64, GFP_KERNEL);
 228         if (!ssr)
 229                 return -ENOMEM;
 230
 231         err = mmc_app_sd_status(card, ssr);
 232         if (err) {
 233                 pr_warning("%s: problem reading SD Status "
 234                         "register.\n", mmc_hostname(card->host));
 235                 err = 0;
 236                 goto out;
 237         }
 238
 239         for (i = 0; i < 16; i++)
 240                 ssr[i] = be32_to_cpu(ssr[i]);
 241
 242         /* SD3.0 increases max AU size to 64MB (0xF) from 4MB (0x9) */
 243         max_au = card->scr.sda_spec3 ? 0xF : 0x9;
 244
 245         /*
 246          * UNSTUFF_BITS only works with four u32s so we have to offset the
 247          * bitfield positions accordingly.
 248          */
 249         au = UNSTUFF_BITS(ssr, 428 - 384, 4);
 250         if (au > 0 && au <= max_au) {
 251                 card->ssr.au = 1 << (au + 4);
 252                 es = UNSTUFF_BITS(ssr, 408 - 384, 16);
 253                 et = UNSTUFF_BITS(ssr, 402 - 384, 6);
 254                 eo = UNSTUFF_BITS(ssr, 400 - 384, 2);
 255                 if (es && et) {
 256                         card->ssr.erase_timeout = (et * 1000) / es;
 257                         card->ssr.erase_offset = eo * 1000;
 258                 }
 259         } else {
 260                 pr_warning("%s: SD Status: Invalid Allocation Unit "
 261                         "size.\n", mmc_hostname(card->host));
 262         }
 263 out:
 264         kfree(ssr);
 265         return err;
 266 }
 267
 268 /*
 269  * Fetches and decodes switch information
 270  */
 271 static int mmc_read_switch(struct mmc_card *card)
 272 {
 273         int err;
 274         u8 *status;
 275
 276         if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 277                 return 0;
 278
 279         if (!(card->csd.cmdclass & CCC_SWITCH)) {
 280                 pr_warning("%s: card lacks mandatory switch "
 281                         "function, performance might suffer.\n",
 282                         mmc_hostname(card->host));
 283                 return 0;
 284         }
 285
 286         err = -EIO;
 287
 288         status = kmalloc(64, GFP_KERNEL);
 289         if (!status) {
 290                 pr_err("%s: could not allocate a buffer for "
 291                         "switch capabilities.\n",
 292                         mmc_hostname(card->host));
 293                 return -ENOMEM;
 294         }
 295
 296         /*
 297          * Find out the card's support bits with a mode 0 operation.
 298          * The argument does not matter, as the support bits do not
 299          * change with the arguments.
 300          */
 301         err = mmc_sd_switch(card, 0, 0, 0, status);
 302         if (err) {
 303                 /*
 304                  * If the host or the card can't do the switch,
 305                  * fail more gracefully.
 306                  */
 307                 if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 308                         goto out;
 309
 310                 pr_warning("%s: problem reading Bus Speed modes.\n",
 311                         mmc_hostname(card->host));
 312                 err = 0;
 313
 314                 goto out;
 315         }
 316
 317         if (status[13] & SD_MODE_HIGH_SPEED)
 318                 card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
 319
 320         if (card->scr.sda_spec3) {
 321                 card->sw_caps.sd3_bus_mode = status[13];
 322                 /* Driver Strengths supported by the card */
 323                 card->sw_caps.sd3_drv_type = status[9];
 324         }
 325
 326 out:
 327         kfree(status);
 328
 329         return err;
 330 }
 331
 332 /*
 333  * Test if the card supports high-speed mode and, if so, switch to it.
 334  */
 335 int mmc_sd_switch_hs(struct mmc_card *card)
 336 {
 337         int err;
 338         u8 *status;
 339
 340         if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 341                 return 0;
 342
 343         if (!(card->csd.cmdclass & CCC_SWITCH))
 344                 return 0;
 345
 346         if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 347                 return 0;
 348
 349         if (card->sw_caps.hs_max_dtr == 0)
 350                 return 0;
 351
 352         err = -EIO;
 353
 354         status = kmalloc(64, GFP_KERNEL);
 355         if (!status) {
 356                 pr_err("%s: could not allocate a buffer for "
 357                         "switch capabilities.\n", mmc_hostname(card->host));
 358                 return -ENOMEM;
 359         }
 360
 361         err = mmc_sd_switch(card, 1, 0, 1, status);
 362         if (err)
 363                 goto out;
 364
 365         if ((status[16] & 0xF) != 1) {
 366                 pr_warning("%s: Problem switching card "
 367                         "into high-speed mode!\n",
 368                         mmc_hostname(card->host));
 369                 err = 0;
 370         } else {
 371                 err = 1;
 372         }
 373
 374 out:
 375         kfree(status);
 376
 377         return err;
 378 }
 379
 380 static int sd_select_driver_type(struct mmc_card *card, u8 *status)
 381 {
 382         int host_drv_type = SD_DRIVER_TYPE_B;
 383         int card_drv_type = SD_DRIVER_TYPE_B;
 384         int drive_strength;
 385         int err;
 386
 387         /*
 388          * If the host doesn't support any of the Driver Types A,C or D,
 389          * or there is no board specific handler then default Driver
 390          * Type B is used.
 391          */
 392         if (!(card->host->caps & (MMC_CAP_DRIVER_TYPE_A | MMC_CAP_DRIVER_TYPE_C
 393             | MMC_CAP_DRIVER_TYPE_D)))
 394                 return 0;
 395
 396         if (!card->host->ops->select_drive_strength)
 397                 return 0;
 398
 399         if (card->host->caps & MMC_CAP_DRIVER_TYPE_A)
 400                 host_drv_type |= SD_DRIVER_TYPE_A;
 401
 402         if (card->host->caps & MMC_CAP_DRIVER_TYPE_C)
 403                 host_drv_type |= SD_DRIVER_TYPE_C;
 404
 405         if (card->host->caps & MMC_CAP_DRIVER_TYPE_D)
 406                 host_drv_type |= SD_DRIVER_TYPE_D;
 407
 408         if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_A)
 409                 card_drv_type |= SD_DRIVER_TYPE_A;
 410
 411         if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_C)
 412                 card_drv_type |= SD_DRIVER_TYPE_C;
 413
 414         if (card->sw_caps.sd3_drv_type & SD_DRIVER_TYPE_D)
 415                 card_drv_type |= SD_DRIVER_TYPE_D;
 416
 417         /*
 418          * The drive strength that the hardware can support
 419          * depends on the board design.  Pass the appropriate
 420          * information and let the hardware specific code
 421          * return what is possible given the options
 422          */
 423         mmc_host_clk_hold(card->host);
 424         drive_strength = card->host->ops->select_drive_strength(
 425                 card->sw_caps.uhs_max_dtr,
 426                 host_drv_type, card_drv_type);
 427         mmc_host_clk_release(card->host);
 428
 429         err = mmc_sd_switch(card, 1, 2, drive_strength, status);
 430         if (err)
 431                 return err;
 432
 433         if ((status[15] & 0xF) != drive_strength) {
 434                 pr_warning("%s: Problem setting drive strength!\n",
 435                         mmc_hostname(card->host));
 436                 return 0;
 437         }
 438
 439         mmc_set_driver_type(card->host, drive_strength);
 440
 441         return 0;
 442 }
 443
 444 static void sd_update_bus_speed_mode(struct mmc_card *card)
 445 {
 446         /*
 447          * If the host doesn't support any of the UHS-I modes, fallback on
 448          * default speed.
 449          */
 450         if (!mmc_host_uhs(card->host)) {
 451                 card->sd_bus_speed = 0;
 452                 return;
 453         }
 454
 455         if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 456             (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
 457                         card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
 458         } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 459                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
 460                         card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
 461         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 462                     MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 463                     SD_MODE_UHS_SDR50)) {
 464                         card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
 465         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 466                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 467                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
 468                         card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
 469         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 470                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 471                     MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 472                     SD_MODE_UHS_SDR12)) {
 473                         card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
 474         }
 475 }
 476
 477 static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
 478 {
 479         int err;
 480         unsigned int timing = 0;
 481
 482         switch (card->sd_bus_speed) {
 483         case UHS_SDR104_BUS_SPEED:
 484                 timing = MMC_TIMING_UHS_SDR104;
 485                 card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 486                 break;
 487         case UHS_DDR50_BUS_SPEED:
 488                 timing = MMC_TIMING_UHS_DDR50;
 489                 card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 490                 break;
 491         case UHS_SDR50_BUS_SPEED:
 492                 timing = MMC_TIMING_UHS_SDR50;
 493                 card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 494                 break;
 495         case UHS_SDR25_BUS_SPEED:
 496                 timing = MMC_TIMING_UHS_SDR25;
 497                 card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 498                 break;
 499         case UHS_SDR12_BUS_SPEED:
 500                 timing = MMC_TIMING_UHS_SDR12;
 501                 card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 502                 break;
 503         default:
 504                 return 0;
 505         }
 506
 507         err = mmc_sd_switch(card, 1, 0, card->sd_bus_speed, status);
 508         if (err)
 509                 return err;
 510
 511         if ((status[16] & 0xF) != card->sd_bus_speed)
 512                 pr_warning("%s: Problem setting bus speed mode!\n",
 513                         mmc_hostname(card->host));
 514         else {
 515                 mmc_set_timing(card->host, timing);
 516                 mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
 517         }
 518
 519         return 0;
 520 }
 521
 522 /* Get host's max current setting at its current voltage */
 523 static u32 sd_get_host_max_current(struct mmc_host *host)
 524 {
 525         u32 voltage, max_current;
 526
 527         voltage = 1 << host->ios.vdd;
 528         switch (voltage) {
 529         case MMC_VDD_165_195:
 530                 max_current = host->max_current_180;
 531                 break;
 532         case MMC_VDD_29_30:
 533         case MMC_VDD_30_31:
 534                 max_current = host->max_current_300;
 535                 break;
 536         case MMC_VDD_32_33:
 537         case MMC_VDD_33_34:
 538                 max_current = host->max_current_330;
 539                 break;
 540         default:
 541                 max_current = 0;
 542         }
 543
 544         return max_current;
 545 }
 546
 547 static int sd_set_current_limit(struct mmc_card *card, u8 *status)
 548 {
 549         int current_limit = SD_SET_CURRENT_NO_CHANGE;
 550         int err;
 551         u32 max_current;
 552
 553         /*
 554          * Current limit switch is only defined for SDR50, SDR104, and DDR50
 555          * bus speed modes. For other bus speed modes, we do not change the
 556          * current limit.
 557          */
 558         if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
 559             (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
 560             (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
 561                 return 0;
 562
 563         /*
 564          * Host has different current capabilities when operating at
 565          * different voltages, so find out its max current first.
 566          */
 567         max_current = sd_get_host_max_current(card->host);
 568
 569         /*
 570          * We only check host's capability here, if we set a limit that is
 571          * higher than the card's maximum current, the card will be using its
 572          * maximum current, e.g. if the card's maximum current is 300ma, and
 573          * when we set current limit to 200ma, the card will draw 200ma, and
 574          * when we set current limit to 400/600/800ma, the card will draw its
 575          * maximum 300ma from the host.
 576          */
 577         if (max_current >= 800)
 578                 current_limit = SD_SET_CURRENT_LIMIT_800;
 579         else if (max_current >= 600)
 580                 current_limit = SD_SET_CURRENT_LIMIT_600;
 581         else if (max_current >= 400)
 582                 current_limit = SD_SET_CURRENT_LIMIT_400;
 583         else if (max_current >= 200)
 584                 current_limit = SD_SET_CURRENT_LIMIT_200;
 585
 586         if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
 587                 err = mmc_sd_switch(card, 1, 3, current_limit, status);
 588                 if (err)
 589                         return err;
 590
 591                 if (((status[15] >> 4) & 0x0F) != current_limit)
 592                         pr_warning("%s: Problem setting current limit!\n",
 593                                 mmc_hostname(card->host));
 594
 595         }
 596
 597         return 0;
 598 }
 599
 600 /*
 601  * UHS-I specific initialization procedure
 602  */
 603 static int mmc_sd_init_uhs_card(struct mmc_card *card)
 604 {
 605         int err;
 606         u8 *status;
 607
 608         if (!card->scr.sda_spec3)
 609                 return 0;
 610
 611         if (!(card->csd.cmdclass & CCC_SWITCH))
 612                 return 0;
 613
 614         status = kmalloc(64, GFP_KERNEL);
 615         if (!status) {
 616                 pr_err("%s: could not allocate a buffer for "
 617                         "switch capabilities.\n", mmc_hostname(card->host));
 618                 return -ENOMEM;
 619         }
 620
 621         /* Set 4-bit bus width */
 622         if ((card->host->caps & MMC_CAP_4_BIT_DATA) &&
 623             (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
 624                 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 625                 if (err)
 626                         goto out;
 627
 628                 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 629         }
 630
 631         /*
 632          * Select the bus speed mode depending on host
 633          * and card capability.
 634          */
 635         sd_update_bus_speed_mode(card);
 636
 637         /* Set the driver strength for the card */
 638         err = sd_select_driver_type(card, status);
 639         if (err)
 640                 goto out;
 641
 642         /* Set current limit for the card */
 643         err = sd_set_current_limit(card, status);
 644         if (err)
 645                 goto out;
 646
 647         /* Set bus speed mode of the card */
 648         err = sd_set_bus_speed_mode(card, status);
 649         if (err)
 650                 goto out;
 651
 652         /*
 653          * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
 654          * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
 655          */
 656         if (!mmc_host_is_spi(card->host) && card->host->ops->execute_tuning &&
 657                         (card->sd_bus_speed == UHS_SDR50_BUS_SPEED ||
 658                          card->sd_bus_speed == UHS_SDR104_BUS_SPEED)) {
 659                 mmc_host_clk_hold(card->host);
 660                 err = card->host->ops->execute_tuning(card->host,
 661                                                       MMC_SEND_TUNING_BLOCK);
 662                 mmc_host_clk_release(card->host);
 663         }
 664
 665 out:
 666         kfree(status);
 667
 668         return err;
 669 }
 670
 671 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 672         card->raw_cid[2], card->raw_cid[3]);
 673 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 674         card->raw_csd[2], card->raw_csd[3]);
 675 MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 676 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 677 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 678 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 679 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 680 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 681 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 682 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 683 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 684 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 685
 686
 687 static struct attribute *sd_std_attrs[] = {
 688         &dev_attr_cid.attr,
 689         &dev_attr_csd.attr,
 690         &dev_attr_scr.attr,
 691         &dev_attr_date.attr,
 692         &dev_attr_erase_size.attr,
 693         &dev_attr_preferred_erase_size.attr,
 694         &dev_attr_fwrev.attr,
 695         &dev_attr_hwrev.attr,
 696         &dev_attr_manfid.attr,
 697         &dev_attr_name.attr,
 698         &dev_attr_oemid.attr,
 699         &dev_attr_serial.attr,
 700         NULL,
 701 };
 702
 703 static struct attribute_group sd_std_attr_group = {
 704         .attrs = sd_std_attrs,
 705 };
 706
 707 static const struct attribute_group *sd_attr_groups[] = {
 708         &sd_std_attr_group,
 709         NULL,
 710 };
 711
 712 struct device_type sd_type = {
 713         .groups = sd_attr_groups,
 714 };
 715
 716 /*
 717  * Fetch CID from card.
 718  */
 719 int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 720 {
 721         int err;
 722         u32 max_current;
 723         int retries = 10;
 724
 725 try_again:
 726         if (!retries) {
 727                 ocr &= ~SD_OCR_S18R;
 728                 pr_warning("%s: Skipping voltage switch\n",
 729                         mmc_hostname(host));
 730         }
 731
 732         /*
 733          * Since we're changing the OCR value, we seem to
 734          * need to tell some cards to go back to the idle
 735          * state.  We wait 1ms to give cards time to
 736          * respond.
 737          */
 738         mmc_go_idle(host);
 739
 740         /*
 741          * If SD_SEND_IF_COND indicates an SD 2.0
 742          * compliant card and we should set bit 30
 743          * of the ocr to indicate that we can handle
 744          * block-addressed SDHC cards.
 745          */
 746         err = mmc_send_if_cond(host, ocr);
 747         if (!err)
 748                 ocr |= SD_OCR_CCS;
 749
 750         /*
 751          * If the host supports one of UHS-I modes, request the card
 752          * to switch to 1.8V signaling level. If the card has failed
 753          * repeatedly to switch however, skip this.
 754          */
 755         if (retries && mmc_host_uhs(host))
 756                 ocr |= SD_OCR_S18R;
 757
 758         /*
 759          * If the host can supply more than 150mA at current voltage,
 760          * XPC should be set to 1.
 761          */
 762         max_current = sd_get_host_max_current(host);
 763         if (max_current > 150)
 764                 ocr |= SD_OCR_XPC;
 765
 766         err = mmc_send_app_op_cond(host, ocr, rocr);
 767         if (err)
 768                 return err;
 769
 770         /*
 771          * In case CCS and S18A in the response is set, start Signal Voltage
 772          * Switch procedure. SPI mode doesn't support CMD11.
 773          */
 774         if (!mmc_host_is_spi(host) && rocr &&
 775            ((*rocr & 0x41000000) == 0x41000000)) {
 776                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180);
 777                 if (err == -EAGAIN) {
 778                         retries--;
 779                         goto try_again;
 780                 } else if (err) {
 781                         retries = 0;
 782                         goto try_again;
 783                 }
 784         }
 785
 786         if (mmc_host_is_spi(host))
 787                 err = mmc_send_cid(host, cid);
 788         else
 789                 err = mmc_all_send_cid(host, cid);
 790
 791         return err;
 792 }
 793
 794 int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
 795 {
 796         int err;
 797
 798         /*
 799          * Fetch CSD from card.
 800          */
 801         err = mmc_send_csd(card, card->raw_csd);
 802         if (err)
 803                 return err;
 804
 805         err = mmc_decode_csd(card);
 806         if (err)
 807                 return err;
 808
 809         return 0;
 810 }
 811
 812 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
 813         bool reinit)
 814 {
 815         int err;
 816
 817         if (!reinit) {
 818                 /*
 819                  * Fetch SCR from card.
 820                  */
 821                 err = mmc_app_send_scr(card, card->raw_scr);
 822                 if (err)
 823                         return err;
 824
 825                 err = mmc_decode_scr(card);
 826                 if (err)
 827                         return err;
 828
 829                 /*
 830                  * Fetch and process SD Status register.
 831                  */
 832                 err = mmc_read_ssr(card);
 833                 if (err)
 834                         return err;
 835
 836                 /* Erase init depends on CSD and SSR */
 837                 mmc_init_erase(card);
 838
 839                 /*
 840                  * Fetch switch information from card.
 841                  */
 842                 err = mmc_read_switch(card);
 843                 if (err)
 844                         return err;
 845         }
 846
 847         /*
 848          * For SPI, enable CRC as appropriate.
 849          * This CRC enable is located AFTER the reading of the
 850          * card registers because some SDHC cards are not able
 851          * to provide valid CRCs for non-512-byte blocks.
 852          */
 853         if (mmc_host_is_spi(host)) {
 854                 err = mmc_spi_set_crc(host, use_spi_crc);
 855                 if (err)
 856                         return err;
 857         }
 858
 859         /*
 860          * Check if read-only switch is active.
 861          */
 862         if (!reinit) {
 863                 int ro = -1;
 864
 865                 if (host->ops->get_ro) {
 866                         mmc_host_clk_hold(card->host);
 867                         ro = host->ops->get_ro(host);
 868                         mmc_host_clk_release(card->host);
 869                 }
 870
 871                 if (ro < 0) {
 872                         pr_warning("%s: host does not "
 873                                 "support reading read-only "
 874                                 "switch. assuming write-enable.\n",
 875                                 mmc_hostname(host));
 876                 } else if (ro > 0) {
 877                         mmc_card_set_readonly(card);
 878                 }
 879         }
 880
 881         return 0;
 882 }
 883
 884 unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 885 {
 886         unsigned max_dtr = (unsigned int)-1;
 887
 888         if (mmc_card_highspeed(card)) {
 889                 if (max_dtr > card->sw_caps.hs_max_dtr)
 890                         max_dtr = card->sw_caps.hs_max_dtr;
 891         } else if (max_dtr > card->csd.max_dtr) {
 892                 max_dtr = card->csd.max_dtr;
 893         }
 894
 895         return max_dtr;
 896 }
 897
 898 void mmc_sd_go_highspeed(struct mmc_card *card)
 899 {
 900         mmc_card_set_highspeed(card);
 901         mmc_set_timing(card->host, MMC_TIMING_SD_HS);
 902 }
 903
 904 /*
 905  * Handle the detection and initialisation of a card.
 906  *
 907  * In the case of a resume, "oldcard" will contain the card
 908  * we're trying to reinitialise.
 909  */
 910 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
 911         struct mmc_card *oldcard)
 912 {
 913         struct mmc_card *card;
 914         int err;
 915         u32 cid[4];
 916         u32 rocr = 0;
 917
 918         BUG_ON(!host);
 919         WARN_ON(!host->claimed);
 920
 921         err = mmc_sd_get_cid(host, ocr, cid, &rocr);
 922         if (err)
 923                 return err;
 924
 925         if (oldcard) {
 926                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
 927                         return -ENOENT;
 928
 929                 card = oldcard;
 930         } else {
 931                 /*
 932                  * Allocate card structure.
 933                  */
 934                 card = mmc_alloc_card(host, &sd_type);
 935                 if (IS_ERR(card))
 936                         return PTR_ERR(card);
 937
 938                 card->type = MMC_TYPE_SD;
 939                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
 940         }
 941
 942         /*
 943          * For native busses:  get card RCA and quit open drain mode.
 944          */
 945         if (!mmc_host_is_spi(host)) {
 946                 err = mmc_send_relative_addr(host, &card->rca);
 947                 if (err)
 948                         goto free_card;
 949         }
 950
 951         if (!oldcard) {
 952                 err = mmc_sd_get_csd(host, card);
 953                 if (err)
 954                         goto free_card;
 955
 956                 mmc_decode_cid(card);
 957         }
 958
 959         /*
 960          * Select card, as all following commands rely on that.
 961          */
 962         if (!mmc_host_is_spi(host)) {
 963                 err = mmc_select_card(card);
 964                 if (err)
 965                         goto free_card;
 966         }
 967
 968         err = mmc_sd_setup_card(host, card, oldcard != NULL);
 969         if (err)
 970                 goto free_card;
 971
 972         /* Initialization sequence for UHS-I cards */
 973         if (rocr & SD_ROCR_S18A) {
 974                 err = mmc_sd_init_uhs_card(card);
 975                 if (err)
 976                         goto free_card;
 977
 978                 /* Card is an ultra-high-speed card */
 979                 mmc_card_set_uhs(card);
 980         } else {
 981                 /*
 982                  * Attempt to change to high-speed (if supported)
 983                  */
 984                 err = mmc_sd_switch_hs(card);
 985                 if (err > 0)
 986                         mmc_sd_go_highspeed(card);
 987                 else if (err)
 988                         goto free_card;
 989
 990                 /*
 991                  * Set bus speed.
 992                  */
 993                 mmc_set_clock(host, mmc_sd_get_max_clock(card));
 994
 995                 /*
 996                  * Switch to wider bus (if supported).
 997                  */
 998                 if ((host->caps & MMC_CAP_4_BIT_DATA) &&
 999                         (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1000                         err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1001                         if (err)
1002                                 goto free_card;
1003
1004                         mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1005                 }
1006         }
1007
1008         host->card = card;
1009         return 0;
1010
1011 free_card:
1012         if (!oldcard)
1013                 mmc_remove_card(card);
1014
1015         return err;
1016 }
1017
1018 /*
1019  * Host is being removed. Free up the current card.
1020  */
1021 static void mmc_sd_remove(struct mmc_host *host)
1022 {
1023         BUG_ON(!host);
1024         BUG_ON(!host->card);
1025
1026         mmc_remove_card(host->card);
1027         host->card = NULL;
1028 }
1029
1030 /*
1031  * Card detection - card is alive.
1032  */
1033 static int mmc_sd_alive(struct mmc_host *host)
1034 {
1035         return mmc_send_status(host->card, NULL);
1036 }
1037
1038 /*
1039  * Card detection callback from host.
1040  */
1041 static void mmc_sd_detect(struct mmc_host *host)
1042 {
1043         int err;
1044
1045         BUG_ON(!host);
1046         BUG_ON(!host->card);
1047
1048         mmc_get_card(host->card);
1049
1050         /*
1051          * Just check if our card has been removed.
1052          */
1053         err = _mmc_detect_card_removed(host);
1054
1055         mmc_put_card(host->card);
1056
1057         if (err) {
1058                 mmc_sd_remove(host);
1059
1060                 mmc_claim_host(host);
1061                 mmc_detach_bus(host);
1062                 mmc_power_off(host);
1063                 mmc_release_host(host);
1064         }
1065 }
1066
1067 /*
1068  * Suspend callback from host.
1069  */
1070 static int mmc_sd_suspend(struct mmc_host *host)
1071 {
1072         int err = 0;
1073
1074         BUG_ON(!host);
1075         BUG_ON(!host->card);
1076
1077         mmc_claim_host(host);
1078         if (!mmc_host_is_spi(host))
1079                 err = mmc_deselect_cards(host);
1080         host->card->state &= ~MMC_STATE_HIGHSPEED;
1081         if (!err)
1082                 mmc_power_off(host);
1083         mmc_release_host(host);
1084
1085         return err;
1086 }
1087
1088 /*
1089  * Resume callback from host.
1090  *
1091  * This function tries to determine if the same card is still present
1092  * and, if so, restore all state to it.
1093  */
1094 static int mmc_sd_resume(struct mmc_host *host)
1095 {
1096         int err;
1097
1098         BUG_ON(!host);
1099         BUG_ON(!host->card);
1100
1101         mmc_claim_host(host);
1102         mmc_power_up(host);
1103         mmc_select_voltage(host, host->ocr);
1104         err = mmc_sd_init_card(host, host->ocr, host->card);
1105         mmc_release_host(host);
1106
1107         return err;
1108 }
1109
1110 /*
1111  * Callback for runtime_suspend.
1112  */
1113 static int mmc_sd_runtime_suspend(struct mmc_host *host)
1114 {
1115         int err;
1116
1117         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1118                 return 0;
1119
1120         mmc_claim_host(host);
1121
1122         err = mmc_sd_suspend(host);
1123         if (err) {
1124                 pr_err("%s: error %d doing aggessive suspend\n",
1125                         mmc_hostname(host), err);
1126                 goto out;
1127         }
1128         mmc_power_off(host);
1129
1130 out:
1131         mmc_release_host(host);
1132         return err;
1133 }
1134
1135 /*
1136  * Callback for runtime_resume.
1137  */
1138 static int mmc_sd_runtime_resume(struct mmc_host *host)
1139 {
1140         int err;
1141
1142         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1143                 return 0;
1144
1145         mmc_claim_host(host);
1146
1147         mmc_power_up(host);
1148         err = mmc_sd_resume(host);
1149         if (err)
1150                 pr_err("%s: error %d doing aggessive resume\n",
1151                         mmc_hostname(host), err);
1152
1153         mmc_release_host(host);
1154         return 0;
1155 }
1156
1157 static int mmc_sd_power_restore(struct mmc_host *host)
1158 {
1159         int ret;
1160
1161         host->card->state &= ~MMC_STATE_HIGHSPEED;
1162         mmc_claim_host(host);
1163         ret = mmc_sd_init_card(host, host->ocr, host->card);
1164         mmc_release_host(host);
1165
1166         return ret;
1167 }
1168
1169 static const struct mmc_bus_ops mmc_sd_ops = {
1170         .remove = mmc_sd_remove,
1171         .detect = mmc_sd_detect,
1172         .suspend = NULL,
1173         .resume = NULL,
1174         .power_restore = mmc_sd_power_restore,
1175         .alive = mmc_sd_alive,
1176         .shutdown = mmc_sd_suspend,
1177 };
1178
1179 static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
1180         .remove = mmc_sd_remove,
1181         .detect = mmc_sd_detect,
1182         .runtime_suspend = mmc_sd_runtime_suspend,
1183         .runtime_resume = mmc_sd_runtime_resume,
1184         .suspend = mmc_sd_suspend,
1185         .resume = mmc_sd_resume,
1186         .power_restore = mmc_sd_power_restore,
1187         .alive = mmc_sd_alive,
1188         .shutdown = mmc_sd_suspend,
1189 };
1190
1191 static void mmc_sd_attach_bus_ops(struct mmc_host *host)
1192 {
1193         const struct mmc_bus_ops *bus_ops;
1194
1195         if (!mmc_card_is_removable(host))
1196                 bus_ops = &mmc_sd_ops_unsafe;
1197         else
1198                 bus_ops = &mmc_sd_ops;
1199         mmc_attach_bus(host, bus_ops);
1200 }
1201
1202 /*
1203  * Starting point for SD card init.
1204  */
1205 int mmc_attach_sd(struct mmc_host *host)
1206 {
1207         int err;
1208         u32 ocr;
1209
1210         BUG_ON(!host);
1211         WARN_ON(!host->claimed);
1212
1213         err = mmc_send_app_op_cond(host, 0, &ocr);
1214         if (err)
1215                 return err;
1216
1217         mmc_sd_attach_bus_ops(host);
1218         if (host->ocr_avail_sd)
1219                 host->ocr_avail = host->ocr_avail_sd;
1220
1221         /*
1222          * We need to get OCR a different way for SPI.
1223          */
1224         if (mmc_host_is_spi(host)) {
1225                 mmc_go_idle(host);
1226
1227                 err = mmc_spi_read_ocr(host, 0, &ocr);
1228                 if (err)
1229                         goto err;
1230         }
1231
1232         /*
1233          * Sanity check the voltages that the card claims to
1234          * support.
1235          */
1236         if (ocr & 0x7F) {
1237                 pr_warning("%s: card claims to support voltages "
1238                        "below the defined range. These will be ignored.\n",
1239                        mmc_hostname(host));
1240                 ocr &= ~0x7F;
1241         }
1242
1243         if ((ocr & MMC_VDD_165_195) &&
1244             !(host->ocr_avail_sd & MMC_VDD_165_195)) {
1245                 pr_warning("%s: SD card claims to support the "
1246                        "incompletely defined 'low voltage range'. This "
1247                        "will be ignored.\n", mmc_hostname(host));
1248                 ocr &= ~MMC_VDD_165_195;
1249         }
1250
1251         host->ocr = mmc_select_voltage(host, ocr);
1252
1253         /*
1254          * Can we support the voltage(s) of the card(s)?
1255          */
1256         if (!host->ocr) {
1257                 err = -EINVAL;
1258                 goto err;
1259         }
1260
1261         /*
1262          * Detect and init the card.
1263          */
1264         err = mmc_sd_init_card(host, host->ocr, NULL);
1265         if (err)
1266                 goto err;
1267
1268         mmc_release_host(host);
1269         err = mmc_add_card(host->card);
1270         mmc_claim_host(host);
1271         if (err)
1272                 goto remove_card;
1273
1274         return 0;
1275
1276 remove_card:
1277         mmc_release_host(host);
1278         mmc_remove_card(host->card);
1279         host->card = NULL;
1280         mmc_claim_host(host);
1281 err:
1282         mmc_detach_bus(host);
1283
1284         pr_err("%s: error %d whilst initialising SD card\n",
1285                 mmc_hostname(host), err);
1286
1287         return err;
1288 }
1289