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