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
 819         if (!reinit) {
 820                 /*
 821                  * Fetch SCR from card.
 822                  */
 823                 err = mmc_app_send_scr(card, card->raw_scr);
 824                 if (err)
 825                         return err;
 826
 827                 err = mmc_decode_scr(card);
 828                 if (err)
 829                         return err;
 830
 831                 /*
 832                  * Fetch and process SD Status register.
 833                  */
 834                 err = mmc_read_ssr(card);
 835                 if (err)
 836                         return err;
 837
 838                 /* Erase init depends on CSD and SSR */
 839                 mmc_init_erase(card);
 840
 841                 /*
 842                  * Fetch switch information from card.
 843                  */
 844                 err = mmc_read_switch(card);
 845                 if (err)
 846                         return err;
 847         }
 848
 849         /*
 850          * For SPI, enable CRC as appropriate.
 851          * This CRC enable is located AFTER the reading of the
 852          * card registers because some SDHC cards are not able
 853          * to provide valid CRCs for non-512-byte blocks.
 854          */
 855         if (mmc_host_is_spi(host)) {
 856                 err = mmc_spi_set_crc(host, use_spi_crc);
 857                 if (err)
 858                         return err;
 859         }
 860
 861         /*
 862          * Check if read-only switch is active.
 863          */
 864         if (!reinit) {
 865                 int ro = -1;
 866
 867                 if (host->ops->get_ro) {
 868                         mmc_host_clk_hold(card->host);
 869                         ro = host->ops->get_ro(host);
 870                         mmc_host_clk_release(card->host);
 871                 }
 872
 873                 if (ro < 0) {
 874                         pr_warning("%s: host does not "
 875                                 "support reading read-only "
 876                                 "switch. assuming write-enable.\n",
 877                                 mmc_hostname(host));
 878                 } else if (ro > 0) {
 879                         mmc_card_set_readonly(card);
 880                 }
 881         }
 882
 883         return 0;
 884 }
 885
 886 unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 887 {
 888         unsigned max_dtr = (unsigned int)-1;
 889
 890         if (mmc_card_highspeed(card)) {
 891                 if (max_dtr > card->sw_caps.hs_max_dtr)
 892                         max_dtr = card->sw_caps.hs_max_dtr;
 893         } else if (max_dtr > card->csd.max_dtr) {
 894                 max_dtr = card->csd.max_dtr;
 895         }
 896
 897         return max_dtr;
 898 }
 899
 900 void mmc_sd_go_highspeed(struct mmc_card *card)
 901 {
 902         mmc_card_set_highspeed(card);
 903         mmc_set_timing(card->host, MMC_TIMING_SD_HS);
 904 }
 905
 906 /*
 907  * Handle the detection and initialisation of a card.
 908  *
 909  * In the case of a resume, "oldcard" will contain the card
 910  * we're trying to reinitialise.
 911  */
 912 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
 913         struct mmc_card *oldcard)
 914 {
 915         struct mmc_card *card;
 916         int err;
 917         u32 cid[4];
 918         u32 rocr = 0;
 919
 920         BUG_ON(!host);
 921         WARN_ON(!host->claimed);
 922
 923         err = mmc_sd_get_cid(host, ocr, cid, &rocr);
 924         if (err)
 925                 return err;
 926
 927         if (oldcard) {
 928                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0)
 929                         return -ENOENT;
 930
 931                 card = oldcard;
 932         } else {
 933                 /*
 934                  * Allocate card structure.
 935                  */
 936                 card = mmc_alloc_card(host, &sd_type);
 937                 if (IS_ERR(card))
 938                         return PTR_ERR(card);
 939
 940                 card->ocr = ocr;
 941                 card->type = MMC_TYPE_SD;
 942                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
 943         }
 944
 945         /*
 946          * For native busses:  get card RCA and quit open drain mode.
 947          */
 948         if (!mmc_host_is_spi(host)) {
 949                 err = mmc_send_relative_addr(host, &card->rca);
 950                 if (err)
 951                         goto free_card;
 952         }
 953
 954         if (!oldcard) {
 955                 err = mmc_sd_get_csd(host, card);
 956                 if (err)
 957                         goto free_card;
 958
 959                 mmc_decode_cid(card);
 960         }
 961
 962         /*
 963          * Select card, as all following commands rely on that.
 964          */
 965         if (!mmc_host_is_spi(host)) {
 966                 err = mmc_select_card(card);
 967                 if (err)
 968                         goto free_card;
 969         }
 970
 971         err = mmc_sd_setup_card(host, card, oldcard != NULL);
 972         if (err)
 973                 goto free_card;
 974
 975         /* Initialization sequence for UHS-I cards */
 976         if (rocr & SD_ROCR_S18A) {
 977                 err = mmc_sd_init_uhs_card(card);
 978                 if (err)
 979                         goto free_card;
 980
 981                 /* Card is an ultra-high-speed card */
 982                 mmc_card_set_uhs(card);
 983         } else {
 984                 /*
 985                  * Attempt to change to high-speed (if supported)
 986                  */
 987                 err = mmc_sd_switch_hs(card);
 988                 if (err > 0)
 989                         mmc_sd_go_highspeed(card);
 990                 else if (err)
 991                         goto free_card;
 992
 993                 /*
 994                  * Set bus speed.
 995                  */
 996                 mmc_set_clock(host, mmc_sd_get_max_clock(card));
 997
 998                 /*
 999                  * Switch to wider bus (if supported).
1000                  */
1001                 if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1002                         (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1003                         err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1004                         if (err)
1005                                 goto free_card;
1006
1007                         mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1008                 }
1009         }
1010
1011         host->card = card;
1012         return 0;
1013
1014 free_card:
1015         if (!oldcard)
1016                 mmc_remove_card(card);
1017
1018         return err;
1019 }
1020
1021 /*
1022  * Host is being removed. Free up the current card.
1023  */
1024 static void mmc_sd_remove(struct mmc_host *host)
1025 {
1026         BUG_ON(!host);
1027         BUG_ON(!host->card);
1028
1029         mmc_remove_card(host->card);
1030         host->card = NULL;
1031 }
1032
1033 /*
1034  * Card detection - card is alive.
1035  */
1036 static int mmc_sd_alive(struct mmc_host *host)
1037 {
1038         return mmc_send_status(host->card, NULL);
1039 }
1040
1041 /*
1042  * Card detection callback from host.
1043  */
1044 static void mmc_sd_detect(struct mmc_host *host)
1045 {
1046         int err;
1047
1048         BUG_ON(!host);
1049         BUG_ON(!host->card);
1050
1051         mmc_get_card(host->card);
1052
1053         /*
1054          * Just check if our card has been removed.
1055          */
1056         err = _mmc_detect_card_removed(host);
1057
1058         mmc_put_card(host->card);
1059
1060         if (err) {
1061                 mmc_sd_remove(host);
1062
1063                 mmc_claim_host(host);
1064                 mmc_detach_bus(host);
1065                 mmc_power_off(host);
1066                 mmc_release_host(host);
1067         }
1068 }
1069
1070 /*
1071  * Suspend callback from host.
1072  */
1073 static int mmc_sd_suspend(struct mmc_host *host)
1074 {
1075         int err = 0;
1076
1077         BUG_ON(!host);
1078         BUG_ON(!host->card);
1079
1080         mmc_claim_host(host);
1081
1082         if (mmc_card_suspended(host->card))
1083                 goto out;
1084
1085         if (!mmc_host_is_spi(host))
1086                 err = mmc_deselect_cards(host);
1087         host->card->state &= ~MMC_STATE_HIGHSPEED;
1088         if (!err) {
1089                 mmc_power_off(host);
1090                 mmc_card_set_suspended(host->card);
1091         }
1092
1093 out:
1094         mmc_release_host(host);
1095         return err;
1096 }
1097
1098 /*
1099  * Resume callback from host.
1100  *
1101  * This function tries to determine if the same card is still present
1102  * and, if so, restore all state to it.
1103  */
1104 static int mmc_sd_resume(struct mmc_host *host)
1105 {
1106         int err = 0;
1107
1108         BUG_ON(!host);
1109         BUG_ON(!host->card);
1110
1111         mmc_claim_host(host);
1112
1113         if (!mmc_card_suspended(host->card))
1114                 goto out;
1115
1116         mmc_power_up(host, host->card->ocr);
1117         err = mmc_sd_init_card(host, host->card->ocr, host->card);
1118         mmc_card_clr_suspended(host->card);
1119
1120 out:
1121         mmc_release_host(host);
1122         return err;
1123 }
1124
1125 /*
1126  * Callback for runtime_suspend.
1127  */
1128 static int mmc_sd_runtime_suspend(struct mmc_host *host)
1129 {
1130         int err;
1131
1132         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1133                 return 0;
1134
1135         err = mmc_sd_suspend(host);
1136         if (err)
1137                 pr_err("%s: error %d doing aggessive suspend\n",
1138                         mmc_hostname(host), err);
1139
1140         return err;
1141 }
1142
1143 /*
1144  * Callback for runtime_resume.
1145  */
1146 static int mmc_sd_runtime_resume(struct mmc_host *host)
1147 {
1148         int err;
1149
1150         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1151                 return 0;
1152
1153         err = mmc_sd_resume(host);
1154         if (err)
1155                 pr_err("%s: error %d doing aggessive resume\n",
1156                         mmc_hostname(host), err);
1157
1158         return 0;
1159 }
1160
1161 static int mmc_sd_power_restore(struct mmc_host *host)
1162 {
1163         int ret;
1164
1165         host->card->state &= ~MMC_STATE_HIGHSPEED;
1166         mmc_claim_host(host);
1167         ret = mmc_sd_init_card(host, host->card->ocr, host->card);
1168         mmc_release_host(host);
1169
1170         return ret;
1171 }
1172
1173 static const struct mmc_bus_ops mmc_sd_ops = {
1174         .remove = mmc_sd_remove,
1175         .detect = mmc_sd_detect,
1176         .suspend = NULL,
1177         .resume = NULL,
1178         .power_restore = mmc_sd_power_restore,
1179         .alive = mmc_sd_alive,
1180         .shutdown = mmc_sd_suspend,
1181 };
1182
1183 static const struct mmc_bus_ops mmc_sd_ops_unsafe = {
1184         .remove = mmc_sd_remove,
1185         .detect = mmc_sd_detect,
1186         .runtime_suspend = mmc_sd_runtime_suspend,
1187         .runtime_resume = mmc_sd_runtime_resume,
1188         .suspend = mmc_sd_suspend,
1189         .resume = mmc_sd_resume,
1190         .power_restore = mmc_sd_power_restore,
1191         .alive = mmc_sd_alive,
1192         .shutdown = mmc_sd_suspend,
1193 };
1194
1195 static void mmc_sd_attach_bus_ops(struct mmc_host *host)
1196 {
1197         const struct mmc_bus_ops *bus_ops;
1198
1199         if (!mmc_card_is_removable(host))
1200                 bus_ops = &mmc_sd_ops_unsafe;
1201         else
1202                 bus_ops = &mmc_sd_ops;
1203         mmc_attach_bus(host, bus_ops);
1204 }
1205
1206 /*
1207  * Starting point for SD card init.
1208  */
1209 int mmc_attach_sd(struct mmc_host *host)
1210 {
1211         int err;
1212         u32 ocr, rocr;
1213
1214         BUG_ON(!host);
1215         WARN_ON(!host->claimed);
1216
1217         err = mmc_send_app_op_cond(host, 0, &ocr);
1218         if (err)
1219                 return err;
1220
1221         mmc_sd_attach_bus_ops(host);
1222         if (host->ocr_avail_sd)
1223                 host->ocr_avail = host->ocr_avail_sd;
1224
1225         /*
1226          * We need to get OCR a different way for SPI.
1227          */
1228         if (mmc_host_is_spi(host)) {
1229                 mmc_go_idle(host);
1230
1231                 err = mmc_spi_read_ocr(host, 0, &ocr);
1232                 if (err)
1233                         goto err;
1234         }
1235
1236         rocr = mmc_select_voltage(host, ocr);
1237
1238         /*
1239          * Can we support the voltage(s) of the card(s)?
1240          */
1241         if (!rocr) {
1242                 err = -EINVAL;
1243                 goto err;
1244         }
1245
1246         /*
1247          * Detect and init the card.
1248          */
1249         err = mmc_sd_init_card(host, rocr, NULL);
1250         if (err)
1251                 goto err;
1252
1253         mmc_release_host(host);
1254         err = mmc_add_card(host->card);
1255         mmc_claim_host(host);
1256         if (err)
1257                 goto remove_card;
1258
1259         return 0;
1260
1261 remove_card:
1262         mmc_release_host(host);
1263         mmc_remove_card(host->card);
1264         host->card = NULL;
1265         mmc_claim_host(host);
1266 err:
1267         mmc_detach_bus(host);
1268
1269         pr_err("%s: error %d whilst initialising SD card\n",
1270                 mmc_hostname(host), err);
1271
1272         return err;
1273 }
1274