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         u32 pocr = ocr;
 725
 726 try_again:
 727         if (!retries) {
 728                 ocr &= ~SD_OCR_S18R;
 729                 pr_warning("%s: Skipping voltage switch\n",
 730                         mmc_hostname(host));
 731         }
 732
 733         /*
 734          * Since we're changing the OCR value, we seem to
 735          * need to tell some cards to go back to the idle
 736          * state.  We wait 1ms to give cards time to
 737          * respond.
 738          */
 739         mmc_go_idle(host);
 740
 741         /*
 742          * If SD_SEND_IF_COND indicates an SD 2.0
 743          * compliant card and we should set bit 30
 744          * of the ocr to indicate that we can handle
 745          * block-addressed SDHC cards.
 746          */
 747         err = mmc_send_if_cond(host, ocr);
 748         if (!err)
 749                 ocr |= SD_OCR_CCS;
 750
 751         /*
 752          * If the host supports one of UHS-I modes, request the card
 753          * to switch to 1.8V signaling level. If the card has failed
 754          * repeatedly to switch however, skip this.
 755          */
 756         if (retries && mmc_host_uhs(host))
 757                 ocr |= SD_OCR_S18R;
 758
 759         /*
 760          * If the host can supply more than 150mA at current voltage,
 761          * XPC should be set to 1.
 762          */
 763         max_current = sd_get_host_max_current(host);
 764         if (max_current > 150)
 765                 ocr |= SD_OCR_XPC;
 766
 767         err = mmc_send_app_op_cond(host, ocr, rocr);
 768         if (err)
 769                 return err;
 770
 771         /*
 772          * In case CCS and S18A in the response is set, start Signal Voltage
 773          * Switch procedure. SPI mode doesn't support CMD11.
 774          */
 775         if (!mmc_host_is_spi(host) && rocr &&
 776            ((*rocr & 0x41000000) == 0x41000000)) {
 777                 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180,
 778                                         pocr);
 779                 if (err == -EAGAIN) {
 780                         retries--;
 781                         goto try_again;
 782                 } else if (err) {
 783                         retries = 0;
 784                         goto try_again;
 785                 }
 786         }
 787
 788         if (mmc_host_is_spi(host))
 789                 err = mmc_send_cid(host, cid);
 790         else
 791                 err = mmc_all_send_cid(host, cid);
 792
 793         return err;
 794 }
 795
 796 int mmc_sd_get_csd(struct mmc_host *host, struct mmc_card *card)
 797 {
 798         int err;
 799
 800         /*
 801          * Fetch CSD from card.
 802          */
 803         err = mmc_send_csd(card, card->raw_csd);
 804         if (err)
 805                 return err;
 806
 807         err = mmc_decode_csd(card);
 808         if (err)
 809                 return err;
 810
 811         return 0;
 812 }
 813
 814 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
 815         bool reinit)
 816 {
 817         int err;
 818 #ifdef CONFIG_MMC_PARANOID_SD_INIT
 819         int retries;
 820 #endif
 821
 822         if (!reinit) {
 823                 /*
 824                  * Fetch SCR from card.
 825                  */
 826                 err = mmc_app_send_scr(card, card->raw_scr);
 827                 if (err)
 828                         return err;
 829
 830                 err = mmc_decode_scr(card);
 831                 if (err)
 832                         return err;
 833
 834                 /*
 835                  * Fetch and process SD Status register.
 836                  */
 837                 err = mmc_read_ssr(card);
 838                 if (err)
 839                         return err;
 840
 841                 /* Erase init depends on CSD and SSR */
 842                 mmc_init_erase(card);
 843
 844                 /*
 845                  * Fetch switch information from card.
 846                  */
 847 #ifdef CONFIG_MMC_PARANOID_SD_INIT
 848                 for (retries = 1; retries <= 3; retries++) {
 849                         err = mmc_read_switch(card);
 850                         if (!err) {
 851                                 if (retries > 1) {
 852                                         printk(KERN_WARNING
 853                                                "%s: recovered\n",
 854                                                mmc_hostname(host));
 855                                 }
 856                                 break;
 857                         } else {
 858                                 printk(KERN_WARNING
 859                                        "%s: read switch failed (attempt %d)\n",
 860                                        mmc_hostname(host), retries);
 861                         }
 862                 }
 863 #else
 864                 err = mmc_read_switch(card);
 865 #endif
 866
 867                 if (err)
 868                         return err;
 869         }
 870
 871         /*
 872          * For SPI, enable CRC as appropriate.
 873          * This CRC enable is located AFTER the reading of the
 874          * card registers because some SDHC cards are not able
 875          * to provide valid CRCs for non-512-byte blocks.
 876          */
 877         if (mmc_host_is_spi(host)) {
 878                 err = mmc_spi_set_crc(host, use_spi_crc);
 879                 if (err)
 880                         return err;
 881         }
 882
 883         /*
 884          * Check if read-only switch is active.
 885          */
 886         if (!reinit) {
 887                 int ro = -1;
 888
 889                 if (host->ops->get_ro) {
 890                         mmc_host_clk_hold(card->host);
 891                         ro = host->ops->get_ro(host);
 892                         mmc_host_clk_release(card->host);
 893                 }
 894
 895                 if (ro < 0) {
 896                         pr_warning("%s: host does not "
 897                                 "support reading read-only "
 898                                 "switch. assuming write-enable.\n",
 899                                 mmc_hostname(host));
 900                 } else if (ro > 0) {
 901                         mmc_card_set_readonly(card);
 902                 }
 903         }
 904
 905         return 0;
 906 }
 907
 908 unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 909 {
 910         unsigned max_dtr = (unsigned int)-1;
 911
 912         if (mmc_card_highspeed(card)) {
 913                 if (max_dtr > card->sw_caps.hs_max_dtr)
 914                         max_dtr = card->sw_caps.hs_max_dtr;
 915         } else if (max_dtr > card->csd.max_dtr) {
 916                 max_dtr = card->csd.max_dtr;
 917         }
 918
 919         return max_dtr;
 920 }
 921
 922 void mmc_sd_go_highspeed(struct mmc_card *card)
 923 {
 924         mmc_card_set_highspeed(card);
 925         mmc_set_timing(card->host, MMC_TIMING_SD_HS);
 926 }
 927
 928 /*
 929  * Handle the detection and initialisation of a card.
 930  *
 931  * In the case of a resume, "oldcard" will contain the card
 932  * we're trying to reinitialise.
 933  */
 934 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
 935         struct mmc_card *oldcard)
 936 {
 937         struct mmc_card *card;
 938         int err;
 939         u32 cid[4];
 940         u32 rocr = 0;
 941
 942         BUG_ON(!host);
 943         WARN_ON(!host->claimed);
 944
 945         err = mmc_sd_get_cid(host, ocr, cid, &rocr);
 946         if (err)
 947                 return err;
 948
 949         if (oldcard) {
 950                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
 951                         return -ENOENT;
 952
 953                 card = oldcard;
 954         } else {
 955                 /*
 956                  * Allocate card structure.
 957                  */
 958                 card = mmc_alloc_card(host, &sd_type);
 959                 if (IS_ERR(card))
 960                         return PTR_ERR(card);
 961
 962                 card->ocr = ocr;
 963                 card->type = MMC_TYPE_SD;
 964                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
 965         }
 966
 967         /*
 968          * For native busses:  get card RCA and quit open drain mode.
 969          */
 970         if (!mmc_host_is_spi(host)) {
 971                 err = mmc_send_relative_addr(host, &card->rca);
 972                 if (err)
 973                         goto free_card;
 974         }
 975
 976         if (!oldcard) {
 977                 err = mmc_sd_get_csd(host, card);
 978                 if (err)
 979                         goto free_card;
 980
 981                 mmc_decode_cid(card);
 982         }
 983
 984         /*
 985          * Select card, as all following commands rely on that.
 986          */
 987         if (!mmc_host_is_spi(host)) {
 988                 err = mmc_select_card(card);
 989                 if (err)
 990                         goto free_card;
 991         }
 992
 993         err = mmc_sd_setup_card(host, card, oldcard != NULL);
 994         if (err)
 995                 goto free_card;
 996
 997         /* Initialization sequence for UHS-I cards */
 998         if (rocr & SD_ROCR_S18A) {
 999                 err = mmc_sd_init_uhs_card(card);
1000                 if (err)
1001                         goto free_card;
1002
1003                 /* Card is an ultra-high-speed card */
1004                 mmc_card_set_uhs(card);
1005         } else {
1006                 /*
1007                  * Attempt to change to high-speed (if supported)
1008                  */
1009                 err = mmc_sd_switch_hs(card);
1010                 if (err > 0)
1011                         mmc_sd_go_highspeed(card);
1012                 else if (err)
1013                         goto free_card;
1014
1015                 /*
1016                  * Set bus speed.
1017                  */
1018                 mmc_set_clock(host, mmc_sd_get_max_clock(card));
1019
1020                 /*
1021                  * Switch to wider bus (if supported).
1022                  */
1023                 if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1024                         (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1025                         err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1026                         if (err)
1027                                 goto free_card;
1028
1029                         mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1030                 }
1031         }
1032
1033         host->card = card;
1034         return 0;
1035
1036 free_card:
1037         if (!oldcard)
1038                 mmc_remove_card(card);
1039
1040         return err;
1041 }
1042
1043 /*
1044  * Host is being removed. Free up the current card.
1045  */
1046 static void mmc_sd_remove(struct mmc_host *host)
1047 {
1048         BUG_ON(!host);
1049         BUG_ON(!host->card);
1050
1051         mmc_remove_card(host->card);
1052         host->card = NULL;
1053 }
1054
1055 /*
1056  * Card detection - card is alive.
1057  */
1058 static int mmc_sd_alive(struct mmc_host *host)
1059 {
1060         return mmc_send_status(host->card, NULL);
1061 }
1062
1063 /*
1064  * Card detection callback from host.
1065  */
1066 static void mmc_sd_detect(struct mmc_host *host)
1067 {
1068         int err = 0;
1069 #ifdef CONFIG_MMC_PARANOID_SD_INIT
1070         int retries = 5;
1071 #endif
1072
1073         BUG_ON(!host);
1074         BUG_ON(!host->card);
1075
1076         mmc_get_card(host->card);
1077
1078         /*
1079          * Just check if our card has been removed.
1080          */
1081 #ifdef CONFIG_MMC_PARANOID_SD_INIT
1082         while(retries) {
1083                 err = mmc_send_status(host->card, NULL);
1084                 if (err) {
1085                         retries--;
1086                         udelay(5);
1087                         continue;
1088                 }
1089                 break;
1090         }
1091         if (!retries) {
1092                 printk(KERN_ERR "%s(%s): Unable to re-detect card (%d)\n",
1093                        __func__, mmc_hostname(host), err);
1094         }
1095 #else
1096         err = _mmc_detect_card_removed(host);
1097 #endif
1098
1099         mmc_put_card(host->card);
1100
1101         if (err) {
1102                 mmc_sd_remove(host);
1103
1104                 mmc_claim_host(host);
1105                 mmc_detach_bus(host);
1106                 mmc_power_off(host);
1107                 mmc_release_host(host);
1108         }
1109 }
1110
1111 /*
1112  * Suspend callback from host.
1113  */
1114 static int mmc_sd_suspend(struct mmc_host *host)
1115 {
1116         int err = 0;
1117
1118         BUG_ON(!host);
1119         BUG_ON(!host->card);
1120
1121         mmc_claim_host(host);
1122         if (!mmc_host_is_spi(host))
1123                 err = mmc_deselect_cards(host);
1124         host->card->state &= ~MMC_STATE_HIGHSPEED;
1125         if (!err)
1126                 mmc_power_off(host);
1127         mmc_release_host(host);
1128
1129         return err;
1130 }
1131
1132 /*
1133  * Resume callback from host.
1134  *
1135  * This function tries to determine if the same card is still present
1136  * and, if so, restore all state to it.
1137  */
1138 static int mmc_sd_resume(struct mmc_host *host)
1139 {
1140         int err;
1141
1142         BUG_ON(!host);
1143         BUG_ON(!host->card);
1144
1145         mmc_claim_host(host);
1146         mmc_power_up(host, host->card->ocr);
1147         err = mmc_sd_init_card(host, host->card->ocr, host->card);
1148         mmc_release_host(host);
1149
1150         return err;
1151 }
1152
1153 /*
1154  * Callback for runtime_suspend.
1155  */
1156 static int mmc_sd_runtime_suspend(struct mmc_host *host)
1157 {
1158         int err;
1159
1160         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1161                 return 0;
1162
1163         mmc_claim_host(host);
1164
1165         err = mmc_sd_suspend(host);
1166         if (err) {
1167                 pr_err("%s: error %d doing aggessive suspend\n",
1168                         mmc_hostname(host), err);
1169                 goto out;
1170         }
1171         mmc_power_off(host);
1172
1173 out:
1174         mmc_release_host(host);
1175         return err;
1176 }
1177
1178 /*
1179  * Callback for runtime_resume.
1180  */
1181 static int mmc_sd_runtime_resume(struct mmc_host *host)
1182 {
1183         int err;
1184
1185         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1186                 return 0;
1187
1188         mmc_claim_host(host);
1189
1190         mmc_power_up(host, host->card->ocr);
1191         err = mmc_sd_resume(host);
1192         if (err)
1193                 pr_err("%s: error %d doing aggessive resume\n",
1194                         mmc_hostname(host), err);
1195
1196         mmc_release_host(host);
1197         return 0;
1198 }
1199
1200 static int mmc_sd_power_restore(struct mmc_host *host)
1201 {
1202         int ret;
1203
1204         host->card->state &= ~MMC_STATE_HIGHSPEED;
1205         mmc_claim_host(host);
1206         ret = mmc_sd_init_card(host, host->card->ocr, host->card);
1207         mmc_release_host(host);
1208
1209         return ret;
1210 }
1211
1212 static const struct mmc_bus_ops mmc_sd_ops = {
1213         .remove = mmc_sd_remove,
1214         .detect = mmc_sd_detect,
1215         .suspend = NULL,
1216         .resume = NULL,
1217         .power_restore = mmc_sd_power_restore,
1218         .alive = mmc_sd_alive,
1219         .shutdown = mmc_sd_suspend,
1220 };
1221
1222 static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
1223         .remove = mmc_sd_remove,
1224         .detect = mmc_sd_detect,
1225         .runtime_suspend = mmc_sd_runtime_suspend,
1226         .runtime_resume = mmc_sd_runtime_resume,
1227         .suspend = mmc_sd_suspend,
1228         .resume = mmc_sd_resume,
1229         .power_restore = mmc_sd_power_restore,
1230         .alive = mmc_sd_alive,
1231         .shutdown = mmc_sd_suspend,
1232 };
1233
1234 static void mmc_sd_attach_bus_ops(struct mmc_host *host)
1235 {
1236         const struct mmc_bus_ops *bus_ops;
1237
1238         if (!mmc_card_is_removable(host))
1239                 bus_ops = &mmc_sd_ops_unsafe;
1240         else
1241                 bus_ops = &mmc_sd_ops;
1242         mmc_attach_bus(host, bus_ops);
1243 }
1244
1245 /*
1246  * Starting point for SD card init.
1247  */
1248 int mmc_attach_sd(struct mmc_host *host)
1249 {
1250         int err;
1251         u32 ocr, rocr;
1252
1253         BUG_ON(!host);
1254         WARN_ON(!host->claimed);
1255
1256         err = mmc_send_app_op_cond(host, 0, &ocr);
1257         if (err)
1258                 return err;
1259
1260         mmc_sd_attach_bus_ops(host);
1261         if (host->ocr_avail_sd)
1262                 host->ocr_avail = host->ocr_avail_sd;
1263
1264         /*
1265          * We need to get OCR a different way for SPI.
1266          */
1267         if (mmc_host_is_spi(host)) {
1268                 mmc_go_idle(host);
1269
1270                 err = mmc_spi_read_ocr(host, 0, &ocr);
1271                 if (err)
1272                         goto err;
1273         }
1274
1275         rocr = mmc_select_voltage(host, ocr);
1276
1277         /*
1278          * Can we support the voltage(s) of the card(s)?
1279          */
1280         if (!rocr) {
1281                 err = -EINVAL;
1282                 goto err;
1283         }
1284
1285         /*
1286          * Detect and init the card.
1287          */
1288         err = mmc_sd_init_card(host, rocr, NULL);
1289         if (err)
1290                 goto err;
1291
1292         mmc_release_host(host);
1293         err = mmc_add_card(host->card);
1294         mmc_claim_host(host);
1295         if (err)
1296                 goto remove_card;
1297
1298         return 0;
1299
1300 remove_card:
1301         mmc_release_host(host);
1302         mmc_remove_card(host->card);
1303         host->card = NULL;
1304         mmc_claim_host(host);
1305 err:
1306         mmc_detach_bus(host);
1307
1308         pr_err("%s: error %d whilst initialising SD card\n",
1309                 mmc_hostname(host), err);
1310
1311         return err;
1312 }
1313