drivers/mmc/core/sd.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  linux/drivers/mmc/core/sd.c
   4  *
   5  *  Copyright (C) 2003-2004 Russell King, All Rights Reserved.
   6  *  SD support Copyright (C) 2004 Ian Molton, All Rights Reserved.
   7  *  Copyright (C) 2005-2007 Pierre Ossman, All Rights Reserved.
   8  */
   9
  10 #include <linux/err.h>
  11 #include <linux/sizes.h>
  12 #include <linux/slab.h>
  13 #include <linux/stat.h>
  14 #include <linux/pm_runtime.h>
  15 #include <linux/random.h>
  16 #include <linux/scatterlist.h>
  17 #include <linux/sysfs.h>
  18
  19 #include <linux/mmc/host.h>
  20 #include <linux/mmc/card.h>
  21 #include <linux/mmc/mmc.h>
  22 #include <linux/mmc/sd.h>
  23
  24 #include "core.h"
  25 #include "card.h"
  26 #include "host.h"
  27 #include "bus.h"
  28 #include "mmc_ops.h"
  29 #include "quirks.h"
  30 #include "sd.h"
  31 #include "sd_ops.h"
  32
  33 static const unsigned int tran_exp[] = {
  34         10000,          100000,         1000000,        10000000,
  35         0,              0,              0,              0
  36 };
  37
  38 static const unsigned char tran_mant[] = {
  39         0,      10,     12,     13,     15,     20,     25,     30,
  40         35,     40,     45,     50,     55,     60,     70,     80,
  41 };
  42
  43 static const unsigned int taac_exp[] = {
  44         1,      10,     100,    1000,   10000,  100000, 1000000, 10000000,
  45 };
  46
  47 static const unsigned int taac_mant[] = {
  48         0,      10,     12,     13,     15,     20,     25,     30,
  49         35,     40,     45,     50,     55,     60,     70,     80,
  50 };
  51
  52 static const unsigned int sd_au_size[] = {
  53         0,              SZ_16K / 512,           SZ_32K / 512,   SZ_64K / 512,
  54         SZ_128K / 512,  SZ_256K / 512,          SZ_512K / 512,  SZ_1M / 512,
  55         SZ_2M / 512,    SZ_4M / 512,            SZ_8M / 512,    (SZ_8M + SZ_4M) / 512,
  56         SZ_16M / 512,   (SZ_16M + SZ_8M) / 512, SZ_32M / 512,   SZ_64M / 512,
  57 };
  58
  59 #define SD_POWEROFF_NOTIFY_TIMEOUT_MS 1000
  60 #define SD_WRITE_EXTR_SINGLE_TIMEOUT_MS 1000
  61
  62 struct sd_busy_data {
  63         struct mmc_card *card;
  64         u8 *reg_buf;
  65 };
  66
  67 /*
  68  * Given the decoded CSD structure, decode the raw CID to our CID structure.
  69  */
  70 void mmc_decode_cid(struct mmc_card *card)
  71 {
  72         u32 *resp = card->raw_cid;
  73
  74         /*
  75          * Add the raw card ID (cid) data to the entropy pool. It doesn't
  76          * matter that not all of it is unique, it's just bonus entropy.
  77          */
  78         add_device_randomness(&card->raw_cid, sizeof(card->raw_cid));
  79
  80         /*
  81          * SD doesn't currently have a version field so we will
  82          * have to assume we can parse this.
  83          */
  84         card->cid.manfid                = unstuff_bits(resp, 120, 8);
  85         card->cid.oemid                 = unstuff_bits(resp, 104, 16);
  86         card->cid.prod_name[0]          = unstuff_bits(resp, 96, 8);
  87         card->cid.prod_name[1]          = unstuff_bits(resp, 88, 8);
  88         card->cid.prod_name[2]          = unstuff_bits(resp, 80, 8);
  89         card->cid.prod_name[3]          = unstuff_bits(resp, 72, 8);
  90         card->cid.prod_name[4]          = unstuff_bits(resp, 64, 8);
  91         card->cid.hwrev                 = unstuff_bits(resp, 60, 4);
  92         card->cid.fwrev                 = unstuff_bits(resp, 56, 4);
  93         card->cid.serial                = unstuff_bits(resp, 24, 32);
  94         card->cid.year                  = unstuff_bits(resp, 12, 8);
  95         card->cid.month                 = unstuff_bits(resp, 8, 4);
  96
  97         card->cid.year += 2000; /* SD cards year offset */
  98 }
  99
 100 /*
 101  * Given a 128-bit response, decode to our card CSD structure.
 102  */
 103 static int mmc_decode_csd(struct mmc_card *card, bool is_sduc)
 104 {
 105         struct mmc_csd *csd = &card->csd;
 106         unsigned int e, m, csd_struct;
 107         u32 *resp = card->raw_csd;
 108
 109         csd_struct = unstuff_bits(resp, 126, 2);
 110
 111         switch (csd_struct) {
 112         case 0:
 113                 m = unstuff_bits(resp, 115, 4);
 114                 e = unstuff_bits(resp, 112, 3);
 115                 csd->taac_ns     = (taac_exp[e] * taac_mant[m] + 9) / 10;
 116                 csd->taac_clks   = unstuff_bits(resp, 104, 8) * 100;
 117
 118                 m = unstuff_bits(resp, 99, 4);
 119                 e = unstuff_bits(resp, 96, 3);
 120                 csd->max_dtr      = tran_exp[e] * tran_mant[m];
 121                 csd->cmdclass     = unstuff_bits(resp, 84, 12);
 122
 123                 e = unstuff_bits(resp, 47, 3);
 124                 m = unstuff_bits(resp, 62, 12);
 125                 csd->capacity     = (1 + m) << (e + 2);
 126
 127                 csd->read_blkbits = unstuff_bits(resp, 80, 4);
 128                 csd->read_partial = unstuff_bits(resp, 79, 1);
 129                 csd->write_misalign = unstuff_bits(resp, 78, 1);
 130                 csd->read_misalign = unstuff_bits(resp, 77, 1);
 131                 csd->dsr_imp = unstuff_bits(resp, 76, 1);
 132                 csd->r2w_factor = unstuff_bits(resp, 26, 3);
 133                 csd->write_blkbits = unstuff_bits(resp, 22, 4);
 134                 csd->write_partial = unstuff_bits(resp, 21, 1);
 135
 136                 if (unstuff_bits(resp, 46, 1)) {
 137                         csd->erase_size = 1;
 138                 } else if (csd->write_blkbits >= 9) {
 139                         csd->erase_size = unstuff_bits(resp, 39, 7) + 1;
 140                         csd->erase_size <<= csd->write_blkbits - 9;
 141                 }
 142
 143                 if (unstuff_bits(resp, 13, 1))
 144                         mmc_card_set_readonly(card);
 145                 break;
 146         case 1:
 147         case 2:
 148                 /*
 149                  * This is a block-addressed SDHC, SDXC or SDUC card.
 150                  * Most interesting fields are unused and have fixed
 151                  * values. To avoid getting tripped by buggy cards,
 152                  * we assume those fixed values ourselves.
 153                  */
 154                 mmc_card_set_blockaddr(card);
 155
 156                 csd->taac_ns     = 0; /* Unused */
 157                 csd->taac_clks   = 0; /* Unused */
 158
 159                 m = unstuff_bits(resp, 99, 4);
 160                 e = unstuff_bits(resp, 96, 3);
 161                 csd->max_dtr      = tran_exp[e] * tran_mant[m];
 162                 csd->cmdclass     = unstuff_bits(resp, 84, 12);
 163
 164                 if (csd_struct == 1)
 165                         m = unstuff_bits(resp, 48, 22);
 166                 else
 167                         m = unstuff_bits(resp, 48, 28);
 168                 csd->c_size = m;
 169
 170                 if (csd->c_size >= 0x400000 && is_sduc)
 171                         mmc_card_set_ult_capacity(card);
 172                 else if (csd->c_size >= 0xFFFF)
 173                         mmc_card_set_ext_capacity(card);
 174
 175                 csd->capacity     = (1 + (typeof(sector_t))m) << 10;
 176
 177                 csd->read_blkbits = 9;
 178                 csd->read_partial = 0;
 179                 csd->write_misalign = 0;
 180                 csd->read_misalign = 0;
 181                 csd->r2w_factor = 4; /* Unused */
 182                 csd->write_blkbits = 9;
 183                 csd->write_partial = 0;
 184                 csd->erase_size = 1;
 185
 186                 if (unstuff_bits(resp, 13, 1))
 187                         mmc_card_set_readonly(card);
 188                 break;
 189         default:
 190                 pr_err("%s: unrecognised CSD structure version %d\n",
 191                         mmc_hostname(card->host), csd_struct);
 192                 return -EINVAL;
 193         }
 194
 195         card->erase_size = csd->erase_size;
 196
 197         return 0;
 198 }
 199
 200 /*
 201  * Given a 64-bit response, decode to our card SCR structure.
 202  */
 203 int mmc_decode_scr(struct mmc_card *card)
 204 {
 205         struct sd_scr *scr = &card->scr;
 206         unsigned int scr_struct;
 207         u32 resp[4];
 208
 209         resp[3] = card->raw_scr[1];
 210         resp[2] = card->raw_scr[0];
 211
 212         scr_struct = unstuff_bits(resp, 60, 4);
 213         if (scr_struct != 0) {
 214                 pr_err("%s: unrecognised SCR structure version %d\n",
 215                         mmc_hostname(card->host), scr_struct);
 216                 return -EINVAL;
 217         }
 218
 219         scr->sda_vsn = unstuff_bits(resp, 56, 4);
 220         scr->bus_widths = unstuff_bits(resp, 48, 4);
 221         if (scr->sda_vsn == SCR_SPEC_VER_2)
 222                 /* Check if Physical Layer Spec v3.0 is supported */
 223                 scr->sda_spec3 = unstuff_bits(resp, 47, 1);
 224
 225         if (scr->sda_spec3) {
 226                 scr->sda_spec4 = unstuff_bits(resp, 42, 1);
 227                 scr->sda_specx = unstuff_bits(resp, 38, 4);
 228         }
 229
 230         if (unstuff_bits(resp, 55, 1))
 231                 card->erased_byte = 0xFF;
 232         else
 233                 card->erased_byte = 0x0;
 234
 235         if (scr->sda_spec4)
 236                 scr->cmds = unstuff_bits(resp, 32, 4);
 237         else if (scr->sda_spec3)
 238                 scr->cmds = unstuff_bits(resp, 32, 2);
 239
 240         /* SD Spec says: any SD Card shall set at least bits 0 and 2 */
 241         if (!(scr->bus_widths & SD_SCR_BUS_WIDTH_1) ||
 242             !(scr->bus_widths & SD_SCR_BUS_WIDTH_4)) {
 243                 pr_err("%s: invalid bus width\n", mmc_hostname(card->host));
 244                 return -EINVAL;
 245         }
 246
 247         return 0;
 248 }
 249
 250 /*
 251  * Fetch and process SD Status register.
 252  */
 253 static int mmc_read_ssr(struct mmc_card *card)
 254 {
 255         unsigned int au, es, et, eo;
 256         __be32 *raw_ssr;
 257         u32 resp[4] = {};
 258         u8 discard_support;
 259         int i;
 260
 261         if (!(card->csd.cmdclass & CCC_APP_SPEC)) {
 262                 pr_warn("%s: card lacks mandatory SD Status function\n",
 263                         mmc_hostname(card->host));
 264                 return 0;
 265         }
 266
 267         raw_ssr = kmalloc(sizeof(card->raw_ssr), GFP_KERNEL);
 268         if (!raw_ssr)
 269                 return -ENOMEM;
 270
 271         if (mmc_app_sd_status(card, raw_ssr)) {
 272                 pr_warn("%s: problem reading SD Status register\n",
 273                         mmc_hostname(card->host));
 274                 kfree(raw_ssr);
 275                 return 0;
 276         }
 277
 278         for (i = 0; i < 16; i++)
 279                 card->raw_ssr[i] = be32_to_cpu(raw_ssr[i]);
 280
 281         kfree(raw_ssr);
 282
 283         /*
 284          * unstuff_bits only works with four u32s so we have to offset the
 285          * bitfield positions accordingly.
 286          */
 287         au = unstuff_bits(card->raw_ssr, 428 - 384, 4);
 288         if (au) {
 289                 if (au <= 9 || card->scr.sda_spec3) {
 290                         card->ssr.au = sd_au_size[au];
 291                         es = unstuff_bits(card->raw_ssr, 408 - 384, 16);
 292                         et = unstuff_bits(card->raw_ssr, 402 - 384, 6);
 293                         if (es && et) {
 294                                 eo = unstuff_bits(card->raw_ssr, 400 - 384, 2);
 295                                 card->ssr.erase_timeout = (et * 1000) / es;
 296                                 card->ssr.erase_offset = eo * 1000;
 297                         }
 298                 } else {
 299                         pr_warn("%s: SD Status: Invalid Allocation Unit size\n",
 300                                 mmc_hostname(card->host));
 301                 }
 302         }
 303
 304         /*
 305          * starting SD5.1 discard is supported if DISCARD_SUPPORT (b313) is set
 306          */
 307         resp[3] = card->raw_ssr[6];
 308         discard_support = unstuff_bits(resp, 313 - 288, 1);
 309         card->erase_arg = (card->scr.sda_specx && discard_support) ?
 310                             SD_DISCARD_ARG : SD_ERASE_ARG;
 311
 312         return 0;
 313 }
 314
 315 /*
 316  * Fetches and decodes switch information
 317  */
 318 static int mmc_read_switch(struct mmc_card *card)
 319 {
 320         int err;
 321         u8 *status;
 322
 323         if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 324                 return 0;
 325
 326         if (!(card->csd.cmdclass & CCC_SWITCH)) {
 327                 pr_warn("%s: card lacks mandatory switch function, performance might suffer\n",
 328                         mmc_hostname(card->host));
 329                 return 0;
 330         }
 331
 332         status = kmalloc(64, GFP_KERNEL);
 333         if (!status)
 334                 return -ENOMEM;
 335
 336         /*
 337          * Find out the card's support bits with a mode 0 operation.
 338          * The argument does not matter, as the support bits do not
 339          * change with the arguments.
 340          */
 341         err = mmc_sd_switch(card, SD_SWITCH_CHECK, 0, 0, status);
 342         if (err) {
 343                 /*
 344                  * If the host or the card can't do the switch,
 345                  * fail more gracefully.
 346                  */
 347                 if (err != -EINVAL && err != -ENOSYS && err != -EFAULT)
 348                         goto out;
 349
 350                 pr_warn("%s: problem reading Bus Speed modes\n",
 351                         mmc_hostname(card->host));
 352                 err = 0;
 353
 354                 goto out;
 355         }
 356
 357         if (status[13] & SD_MODE_HIGH_SPEED)
 358                 card->sw_caps.hs_max_dtr = HIGH_SPEED_MAX_DTR;
 359
 360         if (card->scr.sda_spec3) {
 361                 card->sw_caps.sd3_bus_mode = status[13];
 362                 /* Driver Strengths supported by the card */
 363                 card->sw_caps.sd3_drv_type = status[9];
 364                 card->sw_caps.sd3_curr_limit = status[7] | status[6] << 8;
 365         }
 366
 367 out:
 368         kfree(status);
 369
 370         return err;
 371 }
 372
 373 /*
 374  * Test if the card supports high-speed mode and, if so, switch to it.
 375  */
 376 int mmc_sd_switch_hs(struct mmc_card *card)
 377 {
 378         int err;
 379         u8 *status;
 380
 381         if (card->scr.sda_vsn < SCR_SPEC_VER_1)
 382                 return 0;
 383
 384         if (!(card->csd.cmdclass & CCC_SWITCH))
 385                 return 0;
 386
 387         if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED))
 388                 return 0;
 389
 390         if (card->sw_caps.hs_max_dtr == 0)
 391                 return 0;
 392
 393         status = kmalloc(64, GFP_KERNEL);
 394         if (!status)
 395                 return -ENOMEM;
 396
 397         err = mmc_sd_switch(card, SD_SWITCH_SET, 0,
 398                         HIGH_SPEED_BUS_SPEED, status);
 399         if (err)
 400                 goto out;
 401
 402         if ((status[16] & 0xF) != HIGH_SPEED_BUS_SPEED) {
 403                 pr_warn("%s: Problem switching card into high-speed mode!\n",
 404                         mmc_hostname(card->host));
 405                 err = 0;
 406         } else {
 407                 err = 1;
 408         }
 409
 410 out:
 411         kfree(status);
 412
 413         return err;
 414 }
 415
 416 static int sd_select_driver_type(struct mmc_card *card, u8 *status)
 417 {
 418         int card_drv_type, drive_strength, drv_type;
 419         int err;
 420
 421         card->drive_strength = 0;
 422
 423         card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B;
 424
 425         drive_strength = mmc_select_drive_strength(card,
 426                                                    card->sw_caps.uhs_max_dtr,
 427                                                    card_drv_type, &drv_type);
 428
 429         if (drive_strength) {
 430                 err = mmc_sd_switch(card, SD_SWITCH_SET, 2,
 431                                 drive_strength, status);
 432                 if (err)
 433                         return err;
 434                 if ((status[15] & 0xF) != drive_strength) {
 435                         pr_warn("%s: Problem setting drive strength!\n",
 436                                 mmc_hostname(card->host));
 437                         return 0;
 438                 }
 439                 card->drive_strength = drive_strength;
 440         }
 441
 442         if (drv_type)
 443                 mmc_set_driver_type(card->host, drv_type);
 444
 445         return 0;
 446 }
 447
 448 static void sd_update_bus_speed_mode(struct mmc_card *card)
 449 {
 450         /*
 451          * If the host doesn't support any of the UHS-I modes, fallback on
 452          * default speed.
 453          */
 454         if (!mmc_host_uhs(card->host)) {
 455                 card->sd_bus_speed = 0;
 456                 return;
 457         }
 458
 459         if ((card->host->caps & MMC_CAP_UHS_SDR104) &&
 460             (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) {
 461                         card->sd_bus_speed = UHS_SDR104_BUS_SPEED;
 462         } else if ((card->host->caps & MMC_CAP_UHS_DDR50) &&
 463                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) {
 464                         card->sd_bus_speed = UHS_DDR50_BUS_SPEED;
 465         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 466                     MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode &
 467                     SD_MODE_UHS_SDR50)) {
 468                         card->sd_bus_speed = UHS_SDR50_BUS_SPEED;
 469         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 470                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) &&
 471                    (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) {
 472                         card->sd_bus_speed = UHS_SDR25_BUS_SPEED;
 473         } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 |
 474                     MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 |
 475                     MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode &
 476                     SD_MODE_UHS_SDR12)) {
 477                         card->sd_bus_speed = UHS_SDR12_BUS_SPEED;
 478         }
 479 }
 480
 481 static int sd_set_bus_speed_mode(struct mmc_card *card, u8 *status)
 482 {
 483         int err;
 484         unsigned int timing = 0;
 485
 486         switch (card->sd_bus_speed) {
 487         case UHS_SDR104_BUS_SPEED:
 488                 timing = MMC_TIMING_UHS_SDR104;
 489                 card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR;
 490                 break;
 491         case UHS_DDR50_BUS_SPEED:
 492                 timing = MMC_TIMING_UHS_DDR50;
 493                 card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR;
 494                 break;
 495         case UHS_SDR50_BUS_SPEED:
 496                 timing = MMC_TIMING_UHS_SDR50;
 497                 card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR;
 498                 break;
 499         case UHS_SDR25_BUS_SPEED:
 500                 timing = MMC_TIMING_UHS_SDR25;
 501                 card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR;
 502                 break;
 503         case UHS_SDR12_BUS_SPEED:
 504                 timing = MMC_TIMING_UHS_SDR12;
 505                 card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR;
 506                 break;
 507         default:
 508                 return 0;
 509         }
 510
 511         err = mmc_sd_switch(card, SD_SWITCH_SET, 0, card->sd_bus_speed, status);
 512         if (err)
 513                 return err;
 514
 515         if ((status[16] & 0xF) != card->sd_bus_speed)
 516                 pr_warn("%s: Problem setting bus speed mode!\n",
 517                         mmc_hostname(card->host));
 518         else {
 519                 mmc_set_timing(card->host, timing);
 520                 mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr);
 521         }
 522
 523         return 0;
 524 }
 525
 526 /* Get host's max current setting at its current voltage */
 527 static u32 sd_get_host_max_current(struct mmc_host *host)
 528 {
 529         u32 voltage, max_current;
 530
 531         voltage = 1 << host->ios.vdd;
 532         switch (voltage) {
 533         case MMC_VDD_165_195:
 534                 max_current = host->max_current_180;
 535                 break;
 536         case MMC_VDD_29_30:
 537         case MMC_VDD_30_31:
 538                 max_current = host->max_current_300;
 539                 break;
 540         case MMC_VDD_32_33:
 541         case MMC_VDD_33_34:
 542                 max_current = host->max_current_330;
 543                 break;
 544         default:
 545                 max_current = 0;
 546         }
 547
 548         return max_current;
 549 }
 550
 551 static int sd_set_current_limit(struct mmc_card *card, u8 *status)
 552 {
 553         int current_limit = SD_SET_CURRENT_NO_CHANGE;
 554         int err;
 555         u32 max_current;
 556
 557         /*
 558          * Current limit switch is only defined for SDR50, SDR104, and DDR50
 559          * bus speed modes. For other bus speed modes, we do not change the
 560          * current limit.
 561          */
 562         if ((card->sd_bus_speed != UHS_SDR50_BUS_SPEED) &&
 563             (card->sd_bus_speed != UHS_SDR104_BUS_SPEED) &&
 564             (card->sd_bus_speed != UHS_DDR50_BUS_SPEED))
 565                 return 0;
 566
 567         /*
 568          * Host has different current capabilities when operating at
 569          * different voltages, so find out its max current first.
 570          */
 571         max_current = sd_get_host_max_current(card->host);
 572
 573         /*
 574          * We only check host's capability here, if we set a limit that is
 575          * higher than the card's maximum current, the card will be using its
 576          * maximum current, e.g. if the card's maximum current is 300ma, and
 577          * when we set current limit to 200ma, the card will draw 200ma, and
 578          * when we set current limit to 400/600/800ma, the card will draw its
 579          * maximum 300ma from the host.
 580          *
 581          * The above is incorrect: if we try to set a current limit that is
 582          * not supported by the card, the card can rightfully error out the
 583          * attempt, and remain at the default current limit.  This results
 584          * in a 300mA card being limited to 200mA even though the host
 585          * supports 800mA. Failures seen with SanDisk 8GB UHS cards with
 586          * an iMX6 host. --rmk
 587          */
 588         if (max_current >= 800 &&
 589             card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_800)
 590                 current_limit = SD_SET_CURRENT_LIMIT_800;
 591         else if (max_current >= 600 &&
 592                  card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_600)
 593                 current_limit = SD_SET_CURRENT_LIMIT_600;
 594         else if (max_current >= 400 &&
 595                  card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_400)
 596                 current_limit = SD_SET_CURRENT_LIMIT_400;
 597         else if (max_current >= 200 &&
 598                  card->sw_caps.sd3_curr_limit & SD_MAX_CURRENT_200)
 599                 current_limit = SD_SET_CURRENT_LIMIT_200;
 600
 601         if (current_limit != SD_SET_CURRENT_NO_CHANGE) {
 602                 err = mmc_sd_switch(card, SD_SWITCH_SET, 3,
 603                                 current_limit, status);
 604                 if (err)
 605                         return err;
 606
 607                 if (((status[15] >> 4) & 0x0F) != current_limit)
 608                         pr_warn("%s: Problem setting current limit!\n",
 609                                 mmc_hostname(card->host));
 610
 611         }
 612
 613         return 0;
 614 }
 615
 616 /*
 617  * UHS-I specific initialization procedure
 618  */
 619 static int mmc_sd_init_uhs_card(struct mmc_card *card)
 620 {
 621         int err;
 622         u8 *status;
 623
 624         if (!(card->csd.cmdclass & CCC_SWITCH))
 625                 return 0;
 626
 627         status = kmalloc(64, GFP_KERNEL);
 628         if (!status)
 629                 return -ENOMEM;
 630
 631         /* Set 4-bit bus width */
 632         err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
 633         if (err)
 634                 goto out;
 635
 636         mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4);
 637
 638         /*
 639          * Select the bus speed mode depending on host
 640          * and card capability.
 641          */
 642         sd_update_bus_speed_mode(card);
 643
 644         /* Set the driver strength for the card */
 645         err = sd_select_driver_type(card, status);
 646         if (err)
 647                 goto out;
 648
 649         /* Set current limit for the card */
 650         err = sd_set_current_limit(card, status);
 651         if (err)
 652                 goto out;
 653
 654         /* Set bus speed mode of the card */
 655         err = sd_set_bus_speed_mode(card, status);
 656         if (err)
 657                 goto out;
 658
 659         /*
 660          * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and
 661          * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104.
 662          */
 663         if (!mmc_host_is_spi(card->host) &&
 664                 (card->host->ios.timing == MMC_TIMING_UHS_SDR50 ||
 665                  card->host->ios.timing == MMC_TIMING_UHS_DDR50 ||
 666                  card->host->ios.timing == MMC_TIMING_UHS_SDR104)) {
 667                 err = mmc_execute_tuning(card);
 668
 669                 /*
 670                  * As SD Specifications Part1 Physical Layer Specification
 671                  * Version 3.01 says, CMD19 tuning is available for unlocked
 672                  * cards in transfer state of 1.8V signaling mode. The small
 673                  * difference between v3.00 and 3.01 spec means that CMD19
 674                  * tuning is also available for DDR50 mode.
 675                  */
 676                 if (err && card->host->ios.timing == MMC_TIMING_UHS_DDR50) {
 677                         pr_warn("%s: ddr50 tuning failed\n",
 678                                 mmc_hostname(card->host));
 679                         err = 0;
 680                 }
 681         }
 682
 683 out:
 684         kfree(status);
 685
 686         return err;
 687 }
 688
 689 MMC_DEV_ATTR(cid, "%08x%08x%08x%08x\n", card->raw_cid[0], card->raw_cid[1],
 690         card->raw_cid[2], card->raw_cid[3]);
 691 MMC_DEV_ATTR(csd, "%08x%08x%08x%08x\n", card->raw_csd[0], card->raw_csd[1],
 692         card->raw_csd[2], card->raw_csd[3]);
 693 MMC_DEV_ATTR(scr, "%08x%08x\n", card->raw_scr[0], card->raw_scr[1]);
 694 MMC_DEV_ATTR(ssr,
 695         "%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x%08x\n",
 696                 card->raw_ssr[0], card->raw_ssr[1], card->raw_ssr[2],
 697                 card->raw_ssr[3], card->raw_ssr[4], card->raw_ssr[5],
 698                 card->raw_ssr[6], card->raw_ssr[7], card->raw_ssr[8],
 699                 card->raw_ssr[9], card->raw_ssr[10], card->raw_ssr[11],
 700                 card->raw_ssr[12], card->raw_ssr[13], card->raw_ssr[14],
 701                 card->raw_ssr[15]);
 702 MMC_DEV_ATTR(date, "%02d/%04d\n", card->cid.month, card->cid.year);
 703 MMC_DEV_ATTR(erase_size, "%u\n", card->erase_size << 9);
 704 MMC_DEV_ATTR(preferred_erase_size, "%u\n", card->pref_erase << 9);
 705 MMC_DEV_ATTR(fwrev, "0x%x\n", card->cid.fwrev);
 706 MMC_DEV_ATTR(hwrev, "0x%x\n", card->cid.hwrev);
 707 MMC_DEV_ATTR(manfid, "0x%06x\n", card->cid.manfid);
 708 MMC_DEV_ATTR(name, "%s\n", card->cid.prod_name);
 709 MMC_DEV_ATTR(oemid, "0x%04x\n", card->cid.oemid);
 710 MMC_DEV_ATTR(serial, "0x%08x\n", card->cid.serial);
 711 MMC_DEV_ATTR(ocr, "0x%08x\n", card->ocr);
 712 MMC_DEV_ATTR(rca, "0x%04x\n", card->rca);
 713
 714
 715 static ssize_t mmc_dsr_show(struct device *dev, struct device_attribute *attr,
 716                             char *buf)
 717 {
 718         struct mmc_card *card = mmc_dev_to_card(dev);
 719         struct mmc_host *host = card->host;
 720
 721         if (card->csd.dsr_imp && host->dsr_req)
 722                 return sysfs_emit(buf, "0x%x\n", host->dsr);
 723         /* return default DSR value */
 724         return sysfs_emit(buf, "0x%x\n", 0x404);
 725 }
 726
 727 static DEVICE_ATTR(dsr, S_IRUGO, mmc_dsr_show, NULL);
 728
 729 MMC_DEV_ATTR(vendor, "0x%04x\n", card->cis.vendor);
 730 MMC_DEV_ATTR(device, "0x%04x\n", card->cis.device);
 731 MMC_DEV_ATTR(revision, "%u.%u\n", card->major_rev, card->minor_rev);
 732
 733 #define sdio_info_attr(num)                                                                     \
 734 static ssize_t info##num##_show(struct device *dev, struct device_attribute *attr, char *buf)   \
 735 {                                                                                               \
 736         struct mmc_card *card = mmc_dev_to_card(dev);                                           \
 737                                                                                                 \
 738         if (num > card->num_info)                                                               \
 739                 return -ENODATA;                                                                \
 740         if (!card->info[num - 1][0])                                                            \
 741                 return 0;                                                                       \
 742         return sysfs_emit(buf, "%s\n", card->info[num - 1]);                                    \
 743 }                                                                                               \
 744 static DEVICE_ATTR_RO(info##num)
 745
 746 sdio_info_attr(1);
 747 sdio_info_attr(2);
 748 sdio_info_attr(3);
 749 sdio_info_attr(4);
 750
 751 static struct attribute *sd_std_attrs[] = {
 752         &dev_attr_vendor.attr,
 753         &dev_attr_device.attr,
 754         &dev_attr_revision.attr,
 755         &dev_attr_info1.attr,
 756         &dev_attr_info2.attr,
 757         &dev_attr_info3.attr,
 758         &dev_attr_info4.attr,
 759         &dev_attr_cid.attr,
 760         &dev_attr_csd.attr,
 761         &dev_attr_scr.attr,
 762         &dev_attr_ssr.attr,
 763         &dev_attr_date.attr,
 764         &dev_attr_erase_size.attr,
 765         &dev_attr_preferred_erase_size.attr,
 766         &dev_attr_fwrev.attr,
 767         &dev_attr_hwrev.attr,
 768         &dev_attr_manfid.attr,
 769         &dev_attr_name.attr,
 770         &dev_attr_oemid.attr,
 771         &dev_attr_serial.attr,
 772         &dev_attr_ocr.attr,
 773         &dev_attr_rca.attr,
 774         &dev_attr_dsr.attr,
 775         NULL,
 776 };
 777
 778 static umode_t sd_std_is_visible(struct kobject *kobj, struct attribute *attr,
 779                                  int index)
 780 {
 781         struct device *dev = kobj_to_dev(kobj);
 782         struct mmc_card *card = mmc_dev_to_card(dev);
 783
 784         /* CIS vendor and device ids, revision and info string are available only for Combo cards */
 785         if ((attr == &dev_attr_vendor.attr ||
 786              attr == &dev_attr_device.attr ||
 787              attr == &dev_attr_revision.attr ||
 788              attr == &dev_attr_info1.attr ||
 789              attr == &dev_attr_info2.attr ||
 790              attr == &dev_attr_info3.attr ||
 791              attr == &dev_attr_info4.attr
 792             ) &&!mmc_card_sd_combo(card))
 793                 return 0;
 794
 795         return attr->mode;
 796 }
 797
 798 static const struct attribute_group sd_std_group = {
 799         .attrs = sd_std_attrs,
 800         .is_visible = sd_std_is_visible,
 801 };
 802 __ATTRIBUTE_GROUPS(sd_std);
 803
 804 const struct device_type sd_type = {
 805         .groups = sd_std_groups,
 806 };
 807
 808 /*
 809  * Fetch CID from card.
 810  */
 811 int mmc_sd_get_cid(struct mmc_host *host, u32 ocr, u32 *cid, u32 *rocr)
 812 {
 813         int err;
 814         u32 max_current;
 815         int retries = 10;
 816         u32 pocr = ocr;
 817
 818 try_again:
 819         if (!retries) {
 820                 ocr &= ~SD_OCR_S18R;
 821                 pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host));
 822         }
 823
 824         /*
 825          * Since we're changing the OCR value, we seem to
 826          * need to tell some cards to go back to the idle
 827          * state.  We wait 1ms to give cards time to
 828          * respond.
 829          */
 830         mmc_go_idle(host);
 831
 832         /*
 833          * If SD_SEND_IF_COND indicates an SD 2.0
 834          * compliant card and we should set bit 30
 835          * of the ocr to indicate that we can handle
 836          * block-addressed SDHC cards.
 837          */
 838         err = mmc_send_if_cond(host, ocr);
 839         if (!err) {
 840                 ocr |= SD_OCR_CCS;
 841                 /* Set HO2T as well - SDUC card won't respond otherwise */
 842                 ocr |= SD_OCR_2T;
 843         }
 844
 845         /*
 846          * If the host supports one of UHS-I modes, request the card
 847          * to switch to 1.8V signaling level. If the card has failed
 848          * repeatedly to switch however, skip this.
 849          */
 850         if (retries && mmc_host_uhs(host))
 851                 ocr |= SD_OCR_S18R;
 852
 853         /*
 854          * If the host can supply more than 150mA at current voltage,
 855          * XPC should be set to 1.
 856          */
 857         max_current = sd_get_host_max_current(host);
 858         if (max_current > 150)
 859                 ocr |= SD_OCR_XPC;
 860
 861         err = mmc_send_app_op_cond(host, ocr, rocr);
 862         if (err)
 863                 return err;
 864
 865         /*
 866          * In case the S18A bit is set in the response, let's start the signal
 867          * voltage switch procedure. SPI mode doesn't support CMD11.
 868          * Note that, according to the spec, the S18A bit is not valid unless
 869          * the CCS bit is set as well. We deliberately deviate from the spec in
 870          * regards to this, which allows UHS-I to be supported for SDSC cards.
 871          */
 872         if (!mmc_host_is_spi(host) && (ocr & SD_OCR_S18R) &&
 873             rocr && (*rocr & SD_ROCR_S18A)) {
 874                 err = mmc_set_uhs_voltage(host, pocr);
 875                 if (err == -EAGAIN) {
 876                         retries--;
 877                         goto try_again;
 878                 } else if (err) {
 879                         retries = 0;
 880                         goto try_again;
 881                 }
 882         }
 883
 884         err = mmc_send_cid(host, cid);
 885         return err;
 886 }
 887
 888 int mmc_sd_get_csd(struct mmc_card *card, bool is_sduc)
 889 {
 890         int err;
 891
 892         /*
 893          * Fetch CSD from card.
 894          */
 895         err = mmc_send_csd(card, card->raw_csd);
 896         if (err)
 897                 return err;
 898
 899         err = mmc_decode_csd(card, is_sduc);
 900         if (err)
 901                 return err;
 902
 903         return 0;
 904 }
 905
 906 int mmc_sd_get_ro(struct mmc_host *host)
 907 {
 908         int ro;
 909
 910         /*
 911          * Some systems don't feature a write-protect pin and don't need one.
 912          * E.g. because they only have micro-SD card slot. For those systems
 913          * assume that the SD card is always read-write.
 914          */
 915         if (host->caps2 & MMC_CAP2_NO_WRITE_PROTECT)
 916                 return 0;
 917
 918         if (!host->ops->get_ro)
 919                 return -1;
 920
 921         ro = host->ops->get_ro(host);
 922
 923         return ro;
 924 }
 925
 926 int mmc_sd_setup_card(struct mmc_host *host, struct mmc_card *card,
 927         bool reinit)
 928 {
 929         int err;
 930
 931         if (!reinit) {
 932                 /*
 933                  * Fetch SCR from card.
 934                  */
 935                 err = mmc_app_send_scr(card);
 936                 if (err)
 937                         return err;
 938
 939                 err = mmc_decode_scr(card);
 940                 if (err)
 941                         return err;
 942
 943                 /*
 944                  * Fetch and process SD Status register.
 945                  */
 946                 err = mmc_read_ssr(card);
 947                 if (err)
 948                         return err;
 949
 950                 /* Erase init depends on CSD and SSR */
 951                 mmc_init_erase(card);
 952         }
 953
 954         /*
 955          * Fetch switch information from card. Note, sd3_bus_mode can change if
 956          * voltage switch outcome changes, so do this always.
 957          */
 958         err = mmc_read_switch(card);
 959         if (err)
 960                 return err;
 961
 962         /*
 963          * For SPI, enable CRC as appropriate.
 964          * This CRC enable is located AFTER the reading of the
 965          * card registers because some SDHC cards are not able
 966          * to provide valid CRCs for non-512-byte blocks.
 967          */
 968         if (mmc_host_is_spi(host)) {
 969                 err = mmc_spi_set_crc(host, use_spi_crc);
 970                 if (err)
 971                         return err;
 972         }
 973
 974         /*
 975          * Check if read-only switch is active.
 976          */
 977         if (!reinit) {
 978                 int ro = mmc_sd_get_ro(host);
 979
 980                 if (ro < 0) {
 981                         pr_warn("%s: host does not support reading read-only switch, assuming write-enable\n",
 982                                 mmc_hostname(host));
 983                 } else if (ro > 0) {
 984                         mmc_card_set_readonly(card);
 985                 }
 986         }
 987
 988         return 0;
 989 }
 990
 991 unsigned mmc_sd_get_max_clock(struct mmc_card *card)
 992 {
 993         unsigned max_dtr = (unsigned int)-1;
 994
 995         if (mmc_card_hs(card)) {
 996                 if (max_dtr > card->sw_caps.hs_max_dtr)
 997                         max_dtr = card->sw_caps.hs_max_dtr;
 998         } else if (max_dtr > card->csd.max_dtr) {
 999                 max_dtr = card->csd.max_dtr;
1000         }
1001
1002         return max_dtr;
1003 }
1004
1005 static bool mmc_sd_card_using_v18(struct mmc_card *card)
1006 {
1007         /*
1008          * According to the SD spec., the Bus Speed Mode (function group 1) bits
1009          * 2 to 4 are zero if the card is initialized at 3.3V signal level. Thus
1010          * they can be used to determine if the card has already switched to
1011          * 1.8V signaling.
1012          */
1013         return card->sw_caps.sd3_bus_mode &
1014                (SD_MODE_UHS_SDR50 | SD_MODE_UHS_SDR104 | SD_MODE_UHS_DDR50);
1015 }
1016
1017 static int sd_write_ext_reg(struct mmc_card *card, u8 fno, u8 page, u16 offset,
1018                             u8 reg_data)
1019 {
1020         struct mmc_host *host = card->host;
1021         struct mmc_request mrq = {};
1022         struct mmc_command cmd = {};
1023         struct mmc_data data = {};
1024         struct scatterlist sg;
1025         u8 *reg_buf;
1026
1027         reg_buf = kzalloc(512, GFP_KERNEL);
1028         if (!reg_buf)
1029                 return -ENOMEM;
1030
1031         mrq.cmd = &cmd;
1032         mrq.data = &data;
1033
1034         /*
1035          * Arguments of CMD49:
1036          * [31:31] MIO (0 = memory).
1037          * [30:27] FNO (function number).
1038          * [26:26] MW - mask write mode (0 = disable).
1039          * [25:18] page number.
1040          * [17:9] offset address.
1041          * [8:0] length (0 = 1 byte).
1042          */
1043         cmd.arg = fno << 27 | page << 18 | offset << 9;
1044
1045         /* The first byte in the buffer is the data to be written. */
1046         reg_buf[0] = reg_data;
1047
1048         data.flags = MMC_DATA_WRITE;
1049         data.blksz = 512;
1050         data.blocks = 1;
1051         data.sg = &sg;
1052         data.sg_len = 1;
1053         sg_init_one(&sg, reg_buf, 512);
1054
1055         cmd.opcode = SD_WRITE_EXTR_SINGLE;
1056         cmd.flags = MMC_RSP_R1 | MMC_CMD_ADTC;
1057
1058         mmc_set_data_timeout(&data, card);
1059         mmc_wait_for_req(host, &mrq);
1060
1061         kfree(reg_buf);
1062
1063         /*
1064          * Note that, the SD card is allowed to signal busy on DAT0 up to 1s
1065          * after the CMD49. Although, let's leave this to be managed by the
1066          * caller.
1067          */
1068
1069         if (cmd.error)
1070                 return cmd.error;
1071         if (data.error)
1072                 return data.error;
1073
1074         return 0;
1075 }
1076
1077 static int sd_read_ext_reg(struct mmc_card *card, u8 fno, u8 page,
1078                            u16 offset, u16 len, u8 *reg_buf)
1079 {
1080         u32 cmd_args;
1081
1082         /*
1083          * Command arguments of CMD48:
1084          * [31:31] MIO (0 = memory).
1085          * [30:27] FNO (function number).
1086          * [26:26] reserved (0).
1087          * [25:18] page number.
1088          * [17:9] offset address.
1089          * [8:0] length (0 = 1 byte, 1ff = 512 bytes).
1090          */
1091         cmd_args = fno << 27 | page << 18 | offset << 9 | (len -1);
1092
1093         return mmc_send_adtc_data(card, card->host, SD_READ_EXTR_SINGLE,
1094                                   cmd_args, reg_buf, 512);
1095 }
1096
1097 static int sd_parse_ext_reg_power(struct mmc_card *card, u8 fno, u8 page,
1098                                   u16 offset)
1099 {
1100         int err;
1101         u8 *reg_buf;
1102
1103         reg_buf = kzalloc(512, GFP_KERNEL);
1104         if (!reg_buf)
1105                 return -ENOMEM;
1106
1107         /* Read the extension register for power management function. */
1108         err = sd_read_ext_reg(card, fno, page, offset, 512, reg_buf);
1109         if (err) {
1110                 pr_warn("%s: error %d reading PM func of ext reg\n",
1111                         mmc_hostname(card->host), err);
1112                 goto out;
1113         }
1114
1115         /* PM revision consists of 4 bits. */
1116         card->ext_power.rev = reg_buf[0] & 0xf;
1117
1118         /* Power Off Notification support at bit 4. */
1119         if ((reg_buf[1] & BIT(4)) && !mmc_card_broken_sd_poweroff_notify(card))
1120                 card->ext_power.feature_support |= SD_EXT_POWER_OFF_NOTIFY;
1121
1122         /* Power Sustenance support at bit 5. */
1123         if (reg_buf[1] & BIT(5))
1124                 card->ext_power.feature_support |= SD_EXT_POWER_SUSTENANCE;
1125
1126         /* Power Down Mode support at bit 6. */
1127         if (reg_buf[1] & BIT(6))
1128                 card->ext_power.feature_support |= SD_EXT_POWER_DOWN_MODE;
1129
1130         card->ext_power.fno = fno;
1131         card->ext_power.page = page;
1132         card->ext_power.offset = offset;
1133
1134 out:
1135         kfree(reg_buf);
1136         return err;
1137 }
1138
1139 static int sd_parse_ext_reg_perf(struct mmc_card *card, u8 fno, u8 page,
1140                                  u16 offset)
1141 {
1142         int err;
1143         u8 *reg_buf;
1144
1145         reg_buf = kzalloc(512, GFP_KERNEL);
1146         if (!reg_buf)
1147                 return -ENOMEM;
1148
1149         err = sd_read_ext_reg(card, fno, page, offset, 512, reg_buf);
1150         if (err) {
1151                 pr_warn("%s: error %d reading PERF func of ext reg\n",
1152                         mmc_hostname(card->host), err);
1153                 goto out;
1154         }
1155
1156         /* PERF revision. */
1157         card->ext_perf.rev = reg_buf[0];
1158
1159         /* FX_EVENT support at bit 0. */
1160         if (reg_buf[1] & BIT(0))
1161                 card->ext_perf.feature_support |= SD_EXT_PERF_FX_EVENT;
1162
1163         /* Card initiated self-maintenance support at bit 0. */
1164         if (reg_buf[2] & BIT(0))
1165                 card->ext_perf.feature_support |= SD_EXT_PERF_CARD_MAINT;
1166
1167         /* Host initiated self-maintenance support at bit 1. */
1168         if (reg_buf[2] & BIT(1))
1169                 card->ext_perf.feature_support |= SD_EXT_PERF_HOST_MAINT;
1170
1171         /* Cache support at bit 0. */
1172         if ((reg_buf[4] & BIT(0)) && !mmc_card_broken_sd_cache(card))
1173                 card->ext_perf.feature_support |= SD_EXT_PERF_CACHE;
1174
1175         /* Command queue support indicated via queue depth bits (0 to 4). */
1176         if (reg_buf[6] & 0x1f)
1177                 card->ext_perf.feature_support |= SD_EXT_PERF_CMD_QUEUE;
1178
1179         card->ext_perf.fno = fno;
1180         card->ext_perf.page = page;
1181         card->ext_perf.offset = offset;
1182
1183 out:
1184         kfree(reg_buf);
1185         return err;
1186 }
1187
1188 static int sd_parse_ext_reg(struct mmc_card *card, u8 *gen_info_buf,
1189                             u16 *next_ext_addr)
1190 {
1191         u8 num_regs, fno, page;
1192         u16 sfc, offset, ext = *next_ext_addr;
1193         u32 reg_addr;
1194
1195         /*
1196          * Parse only one register set per extension, as that is sufficient to
1197          * support the standard functions. This means another 48 bytes in the
1198          * buffer must be available.
1199          */
1200         if (ext + 48 > 512)
1201                 return -EFAULT;
1202
1203         /* Standard Function Code */
1204         memcpy(&sfc, &gen_info_buf[ext], 2);
1205
1206         /* Address to the next extension. */
1207         memcpy(next_ext_addr, &gen_info_buf[ext + 40], 2);
1208
1209         /* Number of registers for this extension. */
1210         num_regs = gen_info_buf[ext + 42];
1211
1212         /* We support only one register per extension. */
1213         if (num_regs != 1)
1214                 return 0;
1215
1216         /* Extension register address. */
1217         memcpy(&reg_addr, &gen_info_buf[ext + 44], 4);
1218
1219         /* 9 bits (0 to 8) contains the offset address. */
1220         offset = reg_addr & 0x1ff;
1221
1222         /* 8 bits (9 to 16) contains the page number. */
1223         page = reg_addr >> 9 & 0xff ;
1224
1225         /* 4 bits (18 to 21) contains the function number. */
1226         fno = reg_addr >> 18 & 0xf;
1227
1228         /* Standard Function Code for power management. */
1229         if (sfc == 0x1)
1230                 return sd_parse_ext_reg_power(card, fno, page, offset);
1231
1232         /* Standard Function Code for performance enhancement. */
1233         if (sfc == 0x2)
1234                 return sd_parse_ext_reg_perf(card, fno, page, offset);
1235
1236         return 0;
1237 }
1238
1239 static int sd_read_ext_regs(struct mmc_card *card)
1240 {
1241         int err, i;
1242         u8 num_ext, *gen_info_buf;
1243         u16 rev, len, next_ext_addr;
1244
1245         if (mmc_host_is_spi(card->host))
1246                 return 0;
1247
1248         if (!(card->scr.cmds & SD_SCR_CMD48_SUPPORT))
1249                 return 0;
1250
1251         gen_info_buf = kzalloc(512, GFP_KERNEL);
1252         if (!gen_info_buf)
1253                 return -ENOMEM;
1254
1255         /*
1256          * Read 512 bytes of general info, which is found at function number 0,
1257          * at page 0 and with no offset.
1258          */
1259         err = sd_read_ext_reg(card, 0, 0, 0, 512, gen_info_buf);
1260         if (err) {
1261                 pr_err("%s: error %d reading general info of SD ext reg\n",
1262                         mmc_hostname(card->host), err);
1263                 goto out;
1264         }
1265
1266         /* General info structure revision. */
1267         memcpy(&rev, &gen_info_buf[0], 2);
1268
1269         /* Length of general info in bytes. */
1270         memcpy(&len, &gen_info_buf[2], 2);
1271
1272         /* Number of extensions to be find. */
1273         num_ext = gen_info_buf[4];
1274
1275         /*
1276          * We only support revision 0 and limit it to 512 bytes for simplicity.
1277          * No matter what, let's return zero to allow us to continue using the
1278          * card, even if we can't support the features from the SD function
1279          * extensions registers.
1280          */
1281         if (rev != 0 || len > 512) {
1282                 pr_warn("%s: non-supported SD ext reg layout\n",
1283                         mmc_hostname(card->host));
1284                 goto out;
1285         }
1286
1287         /*
1288          * Parse the extension registers. The first extension should start
1289          * immediately after the general info header (16 bytes).
1290          */
1291         next_ext_addr = 16;
1292         for (i = 0; i < num_ext; i++) {
1293                 err = sd_parse_ext_reg(card, gen_info_buf, &next_ext_addr);
1294                 if (err) {
1295                         pr_err("%s: error %d parsing SD ext reg\n",
1296                                 mmc_hostname(card->host), err);
1297                         goto out;
1298                 }
1299         }
1300
1301 out:
1302         kfree(gen_info_buf);
1303         return err;
1304 }
1305
1306 static bool sd_cache_enabled(struct mmc_host *host)
1307 {
1308         return host->card->ext_perf.feature_enabled & SD_EXT_PERF_CACHE;
1309 }
1310
1311 static int sd_flush_cache(struct mmc_host *host)
1312 {
1313         struct mmc_card *card = host->card;
1314         u8 *reg_buf, fno, page;
1315         u16 offset;
1316         int err;
1317
1318         if (!sd_cache_enabled(host))
1319                 return 0;
1320
1321         reg_buf = kzalloc(512, GFP_KERNEL);
1322         if (!reg_buf)
1323                 return -ENOMEM;
1324
1325         /*
1326          * Set Flush Cache at bit 0 in the performance enhancement register at
1327          * 261 bytes offset.
1328          */
1329         fno = card->ext_perf.fno;
1330         page = card->ext_perf.page;
1331         offset = card->ext_perf.offset + 261;
1332
1333         err = sd_write_ext_reg(card, fno, page, offset, BIT(0));
1334         if (err) {
1335                 pr_warn("%s: error %d writing Cache Flush bit\n",
1336                         mmc_hostname(host), err);
1337                 goto out;
1338         }
1339
1340         err = mmc_poll_for_busy(card, SD_WRITE_EXTR_SINGLE_TIMEOUT_MS, false,
1341                                 MMC_BUSY_EXTR_SINGLE);
1342         if (err)
1343                 goto out;
1344
1345         /*
1346          * Read the Flush Cache bit. The card shall reset it, to confirm that
1347          * it's has completed the flushing of the cache.
1348          */
1349         err = sd_read_ext_reg(card, fno, page, offset, 1, reg_buf);
1350         if (err) {
1351                 pr_warn("%s: error %d reading Cache Flush bit\n",
1352                         mmc_hostname(host), err);
1353                 goto out;
1354         }
1355
1356         if (reg_buf[0] & BIT(0))
1357                 err = -ETIMEDOUT;
1358 out:
1359         kfree(reg_buf);
1360         return err;
1361 }
1362
1363 static int sd_enable_cache(struct mmc_card *card)
1364 {
1365         u8 *reg_buf;
1366         int err;
1367
1368         card->ext_perf.feature_enabled &= ~SD_EXT_PERF_CACHE;
1369
1370         reg_buf = kzalloc(512, GFP_KERNEL);
1371         if (!reg_buf)
1372                 return -ENOMEM;
1373
1374         /*
1375          * Set Cache Enable at bit 0 in the performance enhancement register at
1376          * 260 bytes offset.
1377          */
1378         err = sd_write_ext_reg(card, card->ext_perf.fno, card->ext_perf.page,
1379                                card->ext_perf.offset + 260, BIT(0));
1380         if (err) {
1381                 pr_warn("%s: error %d writing Cache Enable bit\n",
1382                         mmc_hostname(card->host), err);
1383                 goto out;
1384         }
1385
1386         err = mmc_poll_for_busy(card, SD_WRITE_EXTR_SINGLE_TIMEOUT_MS, false,
1387                                 MMC_BUSY_EXTR_SINGLE);
1388         if (!err)
1389                 card->ext_perf.feature_enabled |= SD_EXT_PERF_CACHE;
1390
1391 out:
1392         kfree(reg_buf);
1393         return err;
1394 }
1395
1396 /*
1397  * Handle the detection and initialisation of a card.
1398  *
1399  * In the case of a resume, "oldcard" will contain the card
1400  * we're trying to reinitialise.
1401  */
1402 static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
1403         struct mmc_card *oldcard)
1404 {
1405         struct mmc_card *card;
1406         int err;
1407         u32 cid[4];
1408         u32 rocr = 0;
1409         bool v18_fixup_failed = false;
1410
1411         WARN_ON(!host->claimed);
1412 retry:
1413         err = mmc_sd_get_cid(host, ocr, cid, &rocr);
1414         if (err)
1415                 return err;
1416
1417         if (oldcard) {
1418                 if (memcmp(cid, oldcard->raw_cid, sizeof(cid)) != 0) {
1419                         pr_debug("%s: Perhaps the card was replaced\n",
1420                                 mmc_hostname(host));
1421                         return -ENOENT;
1422                 }
1423
1424                 card = oldcard;
1425         } else {
1426                 /*
1427                  * Allocate card structure.
1428                  */
1429                 card = mmc_alloc_card(host, &sd_type);
1430                 if (IS_ERR(card))
1431                         return PTR_ERR(card);
1432
1433                 card->ocr = ocr;
1434                 card->type = MMC_TYPE_SD;
1435                 memcpy(card->raw_cid, cid, sizeof(card->raw_cid));
1436         }
1437
1438         /*
1439          * Call the optional HC's init_card function to handle quirks.
1440          */
1441         if (host->ops->init_card)
1442                 host->ops->init_card(host, card);
1443
1444         /*
1445          * For native busses:  get card RCA and quit open drain mode.
1446          */
1447         if (!mmc_host_is_spi(host)) {
1448                 err = mmc_send_relative_addr(host, &card->rca);
1449                 if (err)
1450                         goto free_card;
1451         }
1452
1453         if (!oldcard) {
1454                 u32 sduc_arg = SD_OCR_CCS | SD_OCR_2T;
1455                 bool is_sduc = (rocr & sduc_arg) == sduc_arg;
1456
1457                 err = mmc_sd_get_csd(card, is_sduc);
1458                 if (err)
1459                         goto free_card;
1460
1461                 mmc_decode_cid(card);
1462         }
1463
1464         /*
1465          * handling only for cards supporting DSR and hosts requesting
1466          * DSR configuration
1467          */
1468         if (card->csd.dsr_imp && host->dsr_req)
1469                 mmc_set_dsr(host);
1470
1471         /*
1472          * Select card, as all following commands rely on that.
1473          */
1474         if (!mmc_host_is_spi(host)) {
1475                 err = mmc_select_card(card);
1476                 if (err)
1477                         goto free_card;
1478         }
1479
1480         /* Apply quirks prior to card setup */
1481         mmc_fixup_device(card, mmc_sd_fixups);
1482
1483         err = mmc_sd_setup_card(host, card, oldcard != NULL);
1484         if (err)
1485                 goto free_card;
1486
1487         /*
1488          * If the card has not been power cycled, it may still be using 1.8V
1489          * signaling. Detect that situation and try to initialize a UHS-I (1.8V)
1490          * transfer mode.
1491          */
1492         if (!v18_fixup_failed && !mmc_host_is_spi(host) && mmc_host_uhs(host) &&
1493             mmc_sd_card_using_v18(card) &&
1494             host->ios.signal_voltage != MMC_SIGNAL_VOLTAGE_180) {
1495                 if (mmc_host_set_uhs_voltage(host) ||
1496                     mmc_sd_init_uhs_card(card)) {
1497                         v18_fixup_failed = true;
1498                         mmc_power_cycle(host, ocr);
1499                         if (!oldcard)
1500                                 mmc_remove_card(card);
1501                         goto retry;
1502                 }
1503                 goto cont;
1504         }
1505
1506         /* Initialization sequence for UHS-I cards */
1507         if (rocr & SD_ROCR_S18A && mmc_host_uhs(host)) {
1508                 err = mmc_sd_init_uhs_card(card);
1509                 if (err)
1510                         goto free_card;
1511         } else {
1512                 /*
1513                  * Attempt to change to high-speed (if supported)
1514                  */
1515                 err = mmc_sd_switch_hs(card);
1516                 if (err > 0)
1517                         mmc_set_timing(card->host, MMC_TIMING_SD_HS);
1518                 else if (err)
1519                         goto free_card;
1520
1521                 /*
1522                  * Set bus speed.
1523                  */
1524                 mmc_set_clock(host, mmc_sd_get_max_clock(card));
1525
1526                 if (host->ios.timing == MMC_TIMING_SD_HS &&
1527                         host->ops->prepare_sd_hs_tuning) {
1528                         err = host->ops->prepare_sd_hs_tuning(host, card);
1529                         if (err)
1530                                 goto free_card;
1531                 }
1532
1533                 /*
1534                  * Switch to wider bus (if supported).
1535                  */
1536                 if ((host->caps & MMC_CAP_4_BIT_DATA) &&
1537                         (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) {
1538                         err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4);
1539                         if (err)
1540                                 goto free_card;
1541
1542                         mmc_set_bus_width(host, MMC_BUS_WIDTH_4);
1543                 }
1544
1545                 if (host->ios.timing == MMC_TIMING_SD_HS &&
1546                         host->ops->execute_sd_hs_tuning) {
1547                         err = host->ops->execute_sd_hs_tuning(host, card);
1548                         if (err)
1549                                 goto free_card;
1550                 }
1551         }
1552 cont:
1553         if (!oldcard) {
1554                 /* Read/parse the extension registers. */
1555                 err = sd_read_ext_regs(card);
1556                 if (err)
1557                         goto free_card;
1558         }
1559
1560         /* Enable internal SD cache if supported. */
1561         if (card->ext_perf.feature_support & SD_EXT_PERF_CACHE) {
1562                 err = sd_enable_cache(card);
1563                 if (err)
1564                         goto free_card;
1565         }
1566
1567         if (!mmc_card_ult_capacity(card) && host->cqe_ops && !host->cqe_enabled) {
1568                 err = host->cqe_ops->cqe_enable(host, card);
1569                 if (!err) {
1570                         host->cqe_enabled = true;
1571                         host->hsq_enabled = true;
1572                         pr_info("%s: Host Software Queue enabled\n",
1573                                 mmc_hostname(host));
1574                 }
1575         }
1576
1577         if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
1578             host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
1579                 pr_err("%s: Host failed to negotiate down from 3.3V\n",
1580                         mmc_hostname(host));
1581                 err = -EINVAL;
1582                 goto free_card;
1583         }
1584
1585         host->card = card;
1586         return 0;
1587
1588 free_card:
1589         if (!oldcard)
1590                 mmc_remove_card(card);
1591
1592         return err;
1593 }
1594
1595 /*
1596  * Host is being removed. Free up the current card.
1597  */
1598 static void mmc_sd_remove(struct mmc_host *host)
1599 {
1600         mmc_remove_card(host->card);
1601         host->card = NULL;
1602 }
1603
1604 /*
1605  * Card detection - card is alive.
1606  */
1607 static int mmc_sd_alive(struct mmc_host *host)
1608 {
1609         return mmc_send_status(host->card, NULL);
1610 }
1611
1612 /*
1613  * Card detection callback from host.
1614  */
1615 static void mmc_sd_detect(struct mmc_host *host)
1616 {
1617         int err;
1618
1619         mmc_get_card(host->card, NULL);
1620
1621         /*
1622          * Just check if our card has been removed.
1623          */
1624         err = _mmc_detect_card_removed(host);
1625
1626         mmc_put_card(host->card, NULL);
1627
1628         if (err) {
1629                 mmc_sd_remove(host);
1630
1631                 mmc_claim_host(host);
1632                 mmc_detach_bus(host);
1633                 mmc_power_off(host);
1634                 mmc_release_host(host);
1635         }
1636 }
1637
1638 static int sd_can_poweroff_notify(struct mmc_card *card)
1639 {
1640         return card->ext_power.feature_support & SD_EXT_POWER_OFF_NOTIFY;
1641 }
1642
1643 static int sd_busy_poweroff_notify_cb(void *cb_data, bool *busy)
1644 {
1645         struct sd_busy_data *data = cb_data;
1646         struct mmc_card *card = data->card;
1647         int err;
1648
1649         /*
1650          * Read the status register for the power management function. It's at
1651          * one byte offset and is one byte long. The Power Off Notification
1652          * Ready is bit 0.
1653          */
1654         err = sd_read_ext_reg(card, card->ext_power.fno, card->ext_power.page,
1655                               card->ext_power.offset + 1, 1, data->reg_buf);
1656         if (err) {
1657                 pr_warn("%s: error %d reading status reg of PM func\n",
1658                         mmc_hostname(card->host), err);
1659                 return err;
1660         }
1661
1662         *busy = !(data->reg_buf[0] & BIT(0));
1663         return 0;
1664 }
1665
1666 static int sd_poweroff_notify(struct mmc_card *card)
1667 {
1668         struct sd_busy_data cb_data;
1669         u8 *reg_buf;
1670         int err;
1671
1672         reg_buf = kzalloc(512, GFP_KERNEL);
1673         if (!reg_buf)
1674                 return -ENOMEM;
1675
1676         /*
1677          * Set the Power Off Notification bit in the power management settings
1678          * register at 2 bytes offset.
1679          */
1680         err = sd_write_ext_reg(card, card->ext_power.fno, card->ext_power.page,
1681                                card->ext_power.offset + 2, BIT(0));
1682         if (err) {
1683                 pr_warn("%s: error %d writing Power Off Notify bit\n",
1684                         mmc_hostname(card->host), err);
1685                 goto out;
1686         }
1687
1688         /* Find out when the command is completed. */
1689         err = mmc_poll_for_busy(card, SD_WRITE_EXTR_SINGLE_TIMEOUT_MS, false,
1690                                 MMC_BUSY_EXTR_SINGLE);
1691         if (err)
1692                 goto out;
1693
1694         cb_data.card = card;
1695         cb_data.reg_buf = reg_buf;
1696         err = __mmc_poll_for_busy(card->host, 0, SD_POWEROFF_NOTIFY_TIMEOUT_MS,
1697                                   &sd_busy_poweroff_notify_cb, &cb_data);
1698
1699 out:
1700         kfree(reg_buf);
1701         return err;
1702 }
1703
1704 static int _mmc_sd_suspend(struct mmc_host *host)
1705 {
1706         struct mmc_card *card = host->card;
1707         int err = 0;
1708
1709         mmc_claim_host(host);
1710
1711         if (mmc_card_suspended(card))
1712                 goto out;
1713
1714         if (sd_can_poweroff_notify(card))
1715                 err = sd_poweroff_notify(card);
1716         else if (!mmc_host_is_spi(host))
1717                 err = mmc_deselect_cards(host);
1718
1719         if (!err) {
1720                 mmc_power_off(host);
1721                 mmc_card_set_suspended(card);
1722         }
1723
1724 out:
1725         mmc_release_host(host);
1726         return err;
1727 }
1728
1729 /*
1730  * Callback for suspend
1731  */
1732 static int mmc_sd_suspend(struct mmc_host *host)
1733 {
1734         int err;
1735
1736         err = _mmc_sd_suspend(host);
1737         if (!err) {
1738                 pm_runtime_disable(&host->card->dev);
1739                 pm_runtime_set_suspended(&host->card->dev);
1740         }
1741
1742         return err;
1743 }
1744
1745 /*
1746  * This function tries to determine if the same card is still present
1747  * and, if so, restore all state to it.
1748  */
1749 static int _mmc_sd_resume(struct mmc_host *host)
1750 {
1751         int err = 0;
1752
1753         mmc_claim_host(host);
1754
1755         if (!mmc_card_suspended(host->card))
1756                 goto out;
1757
1758         mmc_power_up(host, host->card->ocr);
1759         err = mmc_sd_init_card(host, host->card->ocr, host->card);
1760         mmc_card_clr_suspended(host->card);
1761
1762 out:
1763         mmc_release_host(host);
1764         return err;
1765 }
1766
1767 /*
1768  * Callback for resume
1769  */
1770 static int mmc_sd_resume(struct mmc_host *host)
1771 {
1772         pm_runtime_enable(&host->card->dev);
1773         return 0;
1774 }
1775
1776 /*
1777  * Callback for runtime_suspend.
1778  */
1779 static int mmc_sd_runtime_suspend(struct mmc_host *host)
1780 {
1781         int err;
1782
1783         if (!(host->caps & MMC_CAP_AGGRESSIVE_PM))
1784                 return 0;
1785
1786         err = _mmc_sd_suspend(host);
1787         if (err)
1788                 pr_err("%s: error %d doing aggressive suspend\n",
1789                         mmc_hostname(host), err);
1790
1791         return err;
1792 }
1793
1794 /*
1795  * Callback for runtime_resume.
1796  */
1797 static int mmc_sd_runtime_resume(struct mmc_host *host)
1798 {
1799         int err;
1800
1801         err = _mmc_sd_resume(host);
1802         if (err && err != -ENOMEDIUM)
1803                 pr_err("%s: error %d doing runtime resume\n",
1804                         mmc_hostname(host), err);
1805
1806         return 0;
1807 }
1808
1809 static int mmc_sd_hw_reset(struct mmc_host *host)
1810 {
1811         mmc_power_cycle(host, host->card->ocr);
1812         return mmc_sd_init_card(host, host->card->ocr, host->card);
1813 }
1814
1815 static const struct mmc_bus_ops mmc_sd_ops = {
1816         .remove = mmc_sd_remove,
1817         .detect = mmc_sd_detect,
1818         .runtime_suspend = mmc_sd_runtime_suspend,
1819         .runtime_resume = mmc_sd_runtime_resume,
1820         .suspend = mmc_sd_suspend,
1821         .resume = mmc_sd_resume,
1822         .alive = mmc_sd_alive,
1823         .shutdown = mmc_sd_suspend,
1824         .hw_reset = mmc_sd_hw_reset,
1825         .cache_enabled = sd_cache_enabled,
1826         .flush_cache = sd_flush_cache,
1827 };
1828
1829 /*
1830  * Starting point for SD card init.
1831  */
1832 int mmc_attach_sd(struct mmc_host *host)
1833 {
1834         int err;
1835         u32 ocr, rocr;
1836
1837         WARN_ON(!host->claimed);
1838
1839         err = mmc_send_app_op_cond(host, 0, &ocr);
1840         if (err)
1841                 return err;
1842
1843         mmc_attach_bus(host, &mmc_sd_ops);
1844         if (host->ocr_avail_sd)
1845                 host->ocr_avail = host->ocr_avail_sd;
1846
1847         /*
1848          * We need to get OCR a different way for SPI.
1849          */
1850         if (mmc_host_is_spi(host)) {
1851                 mmc_go_idle(host);
1852
1853                 err = mmc_spi_read_ocr(host, 0, &ocr);
1854                 if (err)
1855                         goto err;
1856         }
1857
1858         /*
1859          * Some SD cards claims an out of spec VDD voltage range. Let's treat
1860          * these bits as being in-valid and especially also bit7.
1861          */
1862         ocr &= ~0x7FFF;
1863
1864         rocr = mmc_select_voltage(host, ocr);
1865
1866         /*
1867          * Can we support the voltage(s) of the card(s)?
1868          */
1869         if (!rocr) {
1870                 err = -EINVAL;
1871                 goto err;
1872         }
1873
1874         /*
1875          * Detect and init the card.
1876          */
1877         err = mmc_sd_init_card(host, rocr, NULL);
1878         if (err)
1879                 goto err;
1880
1881         mmc_release_host(host);
1882         err = mmc_add_card(host->card);
1883         if (err)
1884                 goto remove_card;
1885
1886         mmc_claim_host(host);
1887         return 0;
1888
1889 remove_card:
1890         mmc_remove_card(host->card);
1891         host->card = NULL;
1892         mmc_claim_host(host);
1893 err:
1894         mmc_detach_bus(host);
1895
1896         pr_err("%s: error %d whilst initialising SD card\n",
1897                 mmc_hostname(host), err);
1898
1899         return err;
1900 }