1 /* 2 * linux/drivers/mmc/sdio.c 3 * 4 * Copyright 2006-2007 Pierre Ossman 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or (at 9 * your option) any later version. 10 */ 11 12 #include <linux/err.h> 13 #include <linux/pm_runtime.h> 14 15 #include <linux/mmc/host.h> 16 #include <linux/mmc/card.h> 17 #include <linux/mmc/mmc.h> 18 #include <linux/mmc/sdio.h> 19 #include <linux/mmc/sdio_func.h> 20 #include <linux/mmc/sdio_ids.h> 21 22 #include "core.h" 23 #include "bus.h" 24 #include "sd.h" 25 #include "sdio_bus.h" 26 #include "mmc_ops.h" 27 #include "sd_ops.h" 28 #include "sdio_ops.h" 29 #include "sdio_cis.h" 30 31 static int sdio_read_fbr(struct sdio_func *func) 32 { 33 int ret; 34 unsigned char data; 35 36 if (mmc_card_nonstd_func_interface(func->card)) { 37 func->class = SDIO_CLASS_NONE; 38 return 0; 39 } 40 41 ret = mmc_io_rw_direct(func->card, 0, 0, 42 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data); 43 if (ret) 44 goto out; 45 46 data &= 0x0f; 47 48 if (data == 0x0f) { 49 ret = mmc_io_rw_direct(func->card, 0, 0, 50 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data); 51 if (ret) 52 goto out; 53 } 54 55 func->class = data; 56 57 out: 58 return ret; 59 } 60 61 static int sdio_init_func(struct mmc_card *card, unsigned int fn) 62 { 63 int ret; 64 struct sdio_func *func; 65 66 if (WARN_ON(fn > SDIO_MAX_FUNCS)) 67 return -EINVAL; 68 69 func = sdio_alloc_func(card); 70 if (IS_ERR(func)) 71 return PTR_ERR(func); 72 73 func->num = fn; 74 75 if (!(card->quirks & MMC_QUIRK_NONSTD_SDIO)) { 76 ret = sdio_read_fbr(func); 77 if (ret) 78 goto fail; 79 80 ret = sdio_read_func_cis(func); 81 if (ret) 82 goto fail; 83 } else { 84 func->vendor = func->card->cis.vendor; 85 func->device = func->card->cis.device; 86 func->max_blksize = func->card->cis.blksize; 87 } 88 89 card->sdio_func[fn - 1] = func; 90 91 return 0; 92 93 fail: 94 /* 95 * It is okay to remove the function here even though we hold 96 * the host lock as we haven't registered the device yet. 97 */ 98 sdio_remove_func(func); 99 return ret; 100 } 101 102 static int sdio_read_cccr(struct mmc_card *card, u32 ocr) 103 { 104 int ret; 105 int cccr_vsn; 106 int uhs = ocr & R4_18V_PRESENT; 107 unsigned char data; 108 unsigned char speed; 109 110 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CCCR, 0, &data); 111 if (ret) 112 goto out; 113 114 cccr_vsn = data & 0x0f; 115 116 if (cccr_vsn > SDIO_CCCR_REV_3_00) { 117 pr_err("%s: unrecognised CCCR structure version %d\n", 118 mmc_hostname(card->host), cccr_vsn); 119 return -EINVAL; 120 } 121 122 card->cccr.sdio_vsn = (data & 0xf0) >> 4; 123 124 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CAPS, 0, &data); 125 if (ret) 126 goto out; 127 128 if (data & SDIO_CCCR_CAP_SMB) 129 card->cccr.multi_block = 1; 130 if (data & SDIO_CCCR_CAP_LSC) 131 card->cccr.low_speed = 1; 132 if (data & SDIO_CCCR_CAP_4BLS) 133 card->cccr.wide_bus = 1; 134 135 if (cccr_vsn >= SDIO_CCCR_REV_1_10) { 136 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_POWER, 0, &data); 137 if (ret) 138 goto out; 139 140 if (data & SDIO_POWER_SMPC) 141 card->cccr.high_power = 1; 142 } 143 144 if (cccr_vsn >= SDIO_CCCR_REV_1_20) { 145 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed); 146 if (ret) 147 goto out; 148 149 card->scr.sda_spec3 = 0; 150 card->sw_caps.sd3_bus_mode = 0; 151 card->sw_caps.sd3_drv_type = 0; 152 if (cccr_vsn >= SDIO_CCCR_REV_3_00 && uhs) { 153 card->scr.sda_spec3 = 1; 154 ret = mmc_io_rw_direct(card, 0, 0, 155 SDIO_CCCR_UHS, 0, &data); 156 if (ret) 157 goto out; 158 159 if (mmc_host_uhs(card->host)) { 160 if (data & SDIO_UHS_DDR50) 161 card->sw_caps.sd3_bus_mode 162 |= SD_MODE_UHS_DDR50; 163 164 if (data & SDIO_UHS_SDR50) 165 card->sw_caps.sd3_bus_mode 166 |= SD_MODE_UHS_SDR50; 167 168 if (data & SDIO_UHS_SDR104) 169 card->sw_caps.sd3_bus_mode 170 |= SD_MODE_UHS_SDR104; 171 } 172 173 ret = mmc_io_rw_direct(card, 0, 0, 174 SDIO_CCCR_DRIVE_STRENGTH, 0, &data); 175 if (ret) 176 goto out; 177 178 if (data & SDIO_DRIVE_SDTA) 179 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_A; 180 if (data & SDIO_DRIVE_SDTC) 181 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_C; 182 if (data & SDIO_DRIVE_SDTD) 183 card->sw_caps.sd3_drv_type |= SD_DRIVER_TYPE_D; 184 } 185 186 /* if no uhs mode ensure we check for high speed */ 187 if (!card->sw_caps.sd3_bus_mode) { 188 if (speed & SDIO_SPEED_SHS) { 189 card->cccr.high_speed = 1; 190 card->sw_caps.hs_max_dtr = 50000000; 191 } else { 192 card->cccr.high_speed = 0; 193 card->sw_caps.hs_max_dtr = 25000000; 194 } 195 } 196 } 197 198 out: 199 return ret; 200 } 201 202 static int sdio_enable_wide(struct mmc_card *card) 203 { 204 int ret; 205 u8 ctrl; 206 207 if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) 208 return 0; 209 210 if (card->cccr.low_speed && !card->cccr.wide_bus) 211 return 0; 212 213 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl); 214 if (ret) 215 return ret; 216 217 if ((ctrl & SDIO_BUS_WIDTH_MASK) == SDIO_BUS_WIDTH_RESERVED) 218 pr_warn("%s: SDIO_CCCR_IF is invalid: 0x%02x\n", 219 mmc_hostname(card->host), ctrl); 220 221 /* set as 4-bit bus width */ 222 ctrl &= ~SDIO_BUS_WIDTH_MASK; 223 ctrl |= SDIO_BUS_WIDTH_4BIT; 224 225 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL); 226 if (ret) 227 return ret; 228 229 return 1; 230 } 231 232 /* 233 * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1) 234 * of the card. This may be required on certain setups of boards, 235 * controllers and embedded sdio device which do not need the card's 236 * pull-up. As a result, card detection is disabled and power is saved. 237 */ 238 static int sdio_disable_cd(struct mmc_card *card) 239 { 240 int ret; 241 u8 ctrl; 242 243 if (!mmc_card_disable_cd(card)) 244 return 0; 245 246 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl); 247 if (ret) 248 return ret; 249 250 ctrl |= SDIO_BUS_CD_DISABLE; 251 252 return mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL); 253 } 254 255 /* 256 * Devices that remain active during a system suspend are 257 * put back into 1-bit mode. 258 */ 259 static int sdio_disable_wide(struct mmc_card *card) 260 { 261 int ret; 262 u8 ctrl; 263 264 if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) 265 return 0; 266 267 if (card->cccr.low_speed && !card->cccr.wide_bus) 268 return 0; 269 270 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl); 271 if (ret) 272 return ret; 273 274 if (!(ctrl & SDIO_BUS_WIDTH_4BIT)) 275 return 0; 276 277 ctrl &= ~SDIO_BUS_WIDTH_4BIT; 278 ctrl |= SDIO_BUS_ASYNC_INT; 279 280 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL); 281 if (ret) 282 return ret; 283 284 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1); 285 286 return 0; 287 } 288 289 290 static int sdio_enable_4bit_bus(struct mmc_card *card) 291 { 292 int err; 293 294 if (card->type == MMC_TYPE_SDIO) 295 err = sdio_enable_wide(card); 296 else if ((card->host->caps & MMC_CAP_4_BIT_DATA) && 297 (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) { 298 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4); 299 if (err) 300 return err; 301 err = sdio_enable_wide(card); 302 if (err <= 0) 303 mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1); 304 } else 305 return 0; 306 307 if (err > 0) { 308 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4); 309 err = 0; 310 } 311 312 return err; 313 } 314 315 316 /* 317 * Test if the card supports high-speed mode and, if so, switch to it. 318 */ 319 static int mmc_sdio_switch_hs(struct mmc_card *card, int enable) 320 { 321 int ret; 322 u8 speed; 323 324 if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED)) 325 return 0; 326 327 if (!card->cccr.high_speed) 328 return 0; 329 330 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed); 331 if (ret) 332 return ret; 333 334 if (enable) 335 speed |= SDIO_SPEED_EHS; 336 else 337 speed &= ~SDIO_SPEED_EHS; 338 339 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL); 340 if (ret) 341 return ret; 342 343 return 1; 344 } 345 346 /* 347 * Enable SDIO/combo card's high-speed mode. Return 0/1 if [not]supported. 348 */ 349 static int sdio_enable_hs(struct mmc_card *card) 350 { 351 int ret; 352 353 ret = mmc_sdio_switch_hs(card, true); 354 if (ret <= 0 || card->type == MMC_TYPE_SDIO) 355 return ret; 356 357 ret = mmc_sd_switch_hs(card); 358 if (ret <= 0) 359 mmc_sdio_switch_hs(card, false); 360 361 return ret; 362 } 363 364 static unsigned mmc_sdio_get_max_clock(struct mmc_card *card) 365 { 366 unsigned max_dtr; 367 368 if (mmc_card_hs(card)) { 369 /* 370 * The SDIO specification doesn't mention how 371 * the CIS transfer speed register relates to 372 * high-speed, but it seems that 50 MHz is 373 * mandatory. 374 */ 375 max_dtr = 50000000; 376 } else { 377 max_dtr = card->cis.max_dtr; 378 } 379 380 if (card->type == MMC_TYPE_SD_COMBO) 381 max_dtr = min(max_dtr, mmc_sd_get_max_clock(card)); 382 383 return max_dtr; 384 } 385 386 static unsigned char host_drive_to_sdio_drive(int host_strength) 387 { 388 switch (host_strength) { 389 case MMC_SET_DRIVER_TYPE_A: 390 return SDIO_DTSx_SET_TYPE_A; 391 case MMC_SET_DRIVER_TYPE_B: 392 return SDIO_DTSx_SET_TYPE_B; 393 case MMC_SET_DRIVER_TYPE_C: 394 return SDIO_DTSx_SET_TYPE_C; 395 case MMC_SET_DRIVER_TYPE_D: 396 return SDIO_DTSx_SET_TYPE_D; 397 default: 398 return SDIO_DTSx_SET_TYPE_B; 399 } 400 } 401 402 static void sdio_select_driver_type(struct mmc_card *card) 403 { 404 int card_drv_type, drive_strength, drv_type; 405 unsigned char card_strength; 406 int err; 407 408 card->drive_strength = 0; 409 410 card_drv_type = card->sw_caps.sd3_drv_type | SD_DRIVER_TYPE_B; 411 412 drive_strength = mmc_select_drive_strength(card, 413 card->sw_caps.uhs_max_dtr, 414 card_drv_type, &drv_type); 415 416 if (drive_strength) { 417 /* if error just use default for drive strength B */ 418 err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_DRIVE_STRENGTH, 0, 419 &card_strength); 420 if (err) 421 return; 422 423 card_strength &= ~(SDIO_DRIVE_DTSx_MASK<<SDIO_DRIVE_DTSx_SHIFT); 424 card_strength |= host_drive_to_sdio_drive(drive_strength); 425 426 /* if error default to drive strength B */ 427 err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_DRIVE_STRENGTH, 428 card_strength, NULL); 429 if (err) 430 return; 431 card->drive_strength = drive_strength; 432 } 433 434 if (drv_type) 435 mmc_set_driver_type(card->host, drv_type); 436 } 437 438 439 static int sdio_set_bus_speed_mode(struct mmc_card *card) 440 { 441 unsigned int bus_speed, timing; 442 int err; 443 unsigned char speed; 444 445 /* 446 * If the host doesn't support any of the UHS-I modes, fallback on 447 * default speed. 448 */ 449 if (!mmc_host_uhs(card->host)) 450 return 0; 451 452 bus_speed = SDIO_SPEED_SDR12; 453 timing = MMC_TIMING_UHS_SDR12; 454 if ((card->host->caps & MMC_CAP_UHS_SDR104) && 455 (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR104)) { 456 bus_speed = SDIO_SPEED_SDR104; 457 timing = MMC_TIMING_UHS_SDR104; 458 card->sw_caps.uhs_max_dtr = UHS_SDR104_MAX_DTR; 459 card->sd_bus_speed = UHS_SDR104_BUS_SPEED; 460 } else if ((card->host->caps & MMC_CAP_UHS_DDR50) && 461 (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_DDR50)) { 462 bus_speed = SDIO_SPEED_DDR50; 463 timing = MMC_TIMING_UHS_DDR50; 464 card->sw_caps.uhs_max_dtr = UHS_DDR50_MAX_DTR; 465 card->sd_bus_speed = UHS_DDR50_BUS_SPEED; 466 } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | 467 MMC_CAP_UHS_SDR50)) && (card->sw_caps.sd3_bus_mode & 468 SD_MODE_UHS_SDR50)) { 469 bus_speed = SDIO_SPEED_SDR50; 470 timing = MMC_TIMING_UHS_SDR50; 471 card->sw_caps.uhs_max_dtr = UHS_SDR50_MAX_DTR; 472 card->sd_bus_speed = UHS_SDR50_BUS_SPEED; 473 } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | 474 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25)) && 475 (card->sw_caps.sd3_bus_mode & SD_MODE_UHS_SDR25)) { 476 bus_speed = SDIO_SPEED_SDR25; 477 timing = MMC_TIMING_UHS_SDR25; 478 card->sw_caps.uhs_max_dtr = UHS_SDR25_MAX_DTR; 479 card->sd_bus_speed = UHS_SDR25_BUS_SPEED; 480 } else if ((card->host->caps & (MMC_CAP_UHS_SDR104 | 481 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR25 | 482 MMC_CAP_UHS_SDR12)) && (card->sw_caps.sd3_bus_mode & 483 SD_MODE_UHS_SDR12)) { 484 bus_speed = SDIO_SPEED_SDR12; 485 timing = MMC_TIMING_UHS_SDR12; 486 card->sw_caps.uhs_max_dtr = UHS_SDR12_MAX_DTR; 487 card->sd_bus_speed = UHS_SDR12_BUS_SPEED; 488 } 489 490 err = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed); 491 if (err) 492 return err; 493 494 speed &= ~SDIO_SPEED_BSS_MASK; 495 speed |= bus_speed; 496 err = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL); 497 if (err) 498 return err; 499 500 if (bus_speed) { 501 mmc_set_timing(card->host, timing); 502 mmc_set_clock(card->host, card->sw_caps.uhs_max_dtr); 503 } 504 505 return 0; 506 } 507 508 /* 509 * UHS-I specific initialization procedure 510 */ 511 static int mmc_sdio_init_uhs_card(struct mmc_card *card) 512 { 513 int err; 514 515 if (!card->scr.sda_spec3) 516 return 0; 517 518 /* 519 * Switch to wider bus (if supported). 520 */ 521 if (card->host->caps & MMC_CAP_4_BIT_DATA) 522 err = sdio_enable_4bit_bus(card); 523 524 /* Set the driver strength for the card */ 525 sdio_select_driver_type(card); 526 527 /* Set bus speed mode of the card */ 528 err = sdio_set_bus_speed_mode(card); 529 if (err) 530 goto out; 531 532 /* 533 * SPI mode doesn't define CMD19 and tuning is only valid for SDR50 and 534 * SDR104 mode SD-cards. Note that tuning is mandatory for SDR104. 535 */ 536 if (!mmc_host_is_spi(card->host) && 537 ((card->host->ios.timing == MMC_TIMING_UHS_SDR50) || 538 (card->host->ios.timing == MMC_TIMING_UHS_SDR104))) 539 err = mmc_execute_tuning(card); 540 out: 541 return err; 542 } 543 544 /* 545 * Handle the detection and initialisation of a card. 546 * 547 * In the case of a resume, "oldcard" will contain the card 548 * we're trying to reinitialise. 549 */ 550 static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr, 551 struct mmc_card *oldcard, int powered_resume) 552 { 553 struct mmc_card *card; 554 int err; 555 int retries = 10; 556 u32 rocr = 0; 557 u32 ocr_card = ocr; 558 559 WARN_ON(!host->claimed); 560 561 /* to query card if 1.8V signalling is supported */ 562 if (mmc_host_uhs(host)) 563 ocr |= R4_18V_PRESENT; 564 565 try_again: 566 if (!retries) { 567 pr_warn("%s: Skipping voltage switch\n", mmc_hostname(host)); 568 ocr &= ~R4_18V_PRESENT; 569 } 570 571 /* 572 * Inform the card of the voltage 573 */ 574 if (!powered_resume) { 575 err = mmc_send_io_op_cond(host, ocr, &rocr); 576 if (err) 577 goto err; 578 } 579 580 /* 581 * For SPI, enable CRC as appropriate. 582 */ 583 if (mmc_host_is_spi(host)) { 584 err = mmc_spi_set_crc(host, use_spi_crc); 585 if (err) 586 goto err; 587 } 588 589 /* 590 * Allocate card structure. 591 */ 592 card = mmc_alloc_card(host, NULL); 593 if (IS_ERR(card)) { 594 err = PTR_ERR(card); 595 goto err; 596 } 597 598 if ((rocr & R4_MEMORY_PRESENT) && 599 mmc_sd_get_cid(host, ocr & rocr, card->raw_cid, NULL) == 0) { 600 card->type = MMC_TYPE_SD_COMBO; 601 602 if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO || 603 memcmp(card->raw_cid, oldcard->raw_cid, sizeof(card->raw_cid)) != 0)) { 604 mmc_remove_card(card); 605 return -ENOENT; 606 } 607 } else { 608 card->type = MMC_TYPE_SDIO; 609 610 if (oldcard && oldcard->type != MMC_TYPE_SDIO) { 611 mmc_remove_card(card); 612 return -ENOENT; 613 } 614 } 615 616 /* 617 * Call the optional HC's init_card function to handle quirks. 618 */ 619 if (host->ops->init_card) 620 host->ops->init_card(host, card); 621 622 /* 623 * If the host and card support UHS-I mode request the card 624 * to switch to 1.8V signaling level. No 1.8v signalling if 625 * UHS mode is not enabled to maintain compatibility and some 626 * systems that claim 1.8v signalling in fact do not support 627 * it. 628 */ 629 if (!powered_resume && (rocr & ocr & R4_18V_PRESENT)) { 630 err = mmc_set_signal_voltage(host, MMC_SIGNAL_VOLTAGE_180, 631 ocr_card); 632 if (err == -EAGAIN) { 633 sdio_reset(host); 634 mmc_go_idle(host); 635 mmc_send_if_cond(host, host->ocr_avail); 636 mmc_remove_card(card); 637 retries--; 638 goto try_again; 639 } else if (err) { 640 ocr &= ~R4_18V_PRESENT; 641 } 642 err = 0; 643 } else { 644 ocr &= ~R4_18V_PRESENT; 645 } 646 647 /* 648 * For native busses: set card RCA and quit open drain mode. 649 */ 650 if (!powered_resume && !mmc_host_is_spi(host)) { 651 err = mmc_send_relative_addr(host, &card->rca); 652 if (err) 653 goto remove; 654 655 /* 656 * Update oldcard with the new RCA received from the SDIO 657 * device -- we're doing this so that it's updated in the 658 * "card" struct when oldcard overwrites that later. 659 */ 660 if (oldcard) 661 oldcard->rca = card->rca; 662 } 663 664 /* 665 * Read CSD, before selecting the card 666 */ 667 if (!oldcard && card->type == MMC_TYPE_SD_COMBO) { 668 err = mmc_sd_get_csd(host, card); 669 if (err) 670 return err; 671 672 mmc_decode_cid(card); 673 } 674 675 /* 676 * Select card, as all following commands rely on that. 677 */ 678 if (!powered_resume && !mmc_host_is_spi(host)) { 679 err = mmc_select_card(card); 680 if (err) 681 goto remove; 682 } 683 684 if (card->quirks & MMC_QUIRK_NONSTD_SDIO) { 685 /* 686 * This is non-standard SDIO device, meaning it doesn't 687 * have any CIA (Common I/O area) registers present. 688 * It's host's responsibility to fill cccr and cis 689 * structures in init_card(). 690 */ 691 mmc_set_clock(host, card->cis.max_dtr); 692 693 if (card->cccr.high_speed) { 694 mmc_set_timing(card->host, MMC_TIMING_SD_HS); 695 } 696 697 goto finish; 698 } 699 700 /* 701 * Read the common registers. 702 */ 703 err = sdio_read_cccr(card, ocr); 704 if (err) 705 goto remove; 706 707 /* 708 * Read the common CIS tuples. 709 */ 710 err = sdio_read_common_cis(card); 711 if (err) 712 goto remove; 713 714 if (oldcard) { 715 int same = (card->cis.vendor == oldcard->cis.vendor && 716 card->cis.device == oldcard->cis.device); 717 mmc_remove_card(card); 718 if (!same) 719 return -ENOENT; 720 721 card = oldcard; 722 } 723 card->ocr = ocr_card; 724 mmc_fixup_device(card, NULL); 725 726 if (card->type == MMC_TYPE_SD_COMBO) { 727 err = mmc_sd_setup_card(host, card, oldcard != NULL); 728 /* handle as SDIO-only card if memory init failed */ 729 if (err) { 730 mmc_go_idle(host); 731 if (mmc_host_is_spi(host)) 732 /* should not fail, as it worked previously */ 733 mmc_spi_set_crc(host, use_spi_crc); 734 card->type = MMC_TYPE_SDIO; 735 } else 736 card->dev.type = &sd_type; 737 } 738 739 /* 740 * If needed, disconnect card detection pull-up resistor. 741 */ 742 err = sdio_disable_cd(card); 743 if (err) 744 goto remove; 745 746 /* Initialization sequence for UHS-I cards */ 747 /* Only if card supports 1.8v and UHS signaling */ 748 if ((ocr & R4_18V_PRESENT) && card->sw_caps.sd3_bus_mode) { 749 err = mmc_sdio_init_uhs_card(card); 750 if (err) 751 goto remove; 752 } else { 753 /* 754 * Switch to high-speed (if supported). 755 */ 756 err = sdio_enable_hs(card); 757 if (err > 0) 758 mmc_set_timing(card->host, MMC_TIMING_SD_HS); 759 else if (err) 760 goto remove; 761 762 /* 763 * Change to the card's maximum speed. 764 */ 765 mmc_set_clock(host, mmc_sdio_get_max_clock(card)); 766 767 /* 768 * Switch to wider bus (if supported). 769 */ 770 err = sdio_enable_4bit_bus(card); 771 if (err) 772 goto remove; 773 } 774 finish: 775 if (!oldcard) 776 host->card = card; 777 return 0; 778 779 remove: 780 if (!oldcard) 781 mmc_remove_card(card); 782 783 err: 784 return err; 785 } 786 787 /* 788 * Host is being removed. Free up the current card. 789 */ 790 static void mmc_sdio_remove(struct mmc_host *host) 791 { 792 int i; 793 794 for (i = 0;i < host->card->sdio_funcs;i++) { 795 if (host->card->sdio_func[i]) { 796 sdio_remove_func(host->card->sdio_func[i]); 797 host->card->sdio_func[i] = NULL; 798 } 799 } 800 801 mmc_remove_card(host->card); 802 host->card = NULL; 803 } 804 805 /* 806 * Card detection - card is alive. 807 */ 808 static int mmc_sdio_alive(struct mmc_host *host) 809 { 810 return mmc_select_card(host->card); 811 } 812 813 /* 814 * Card detection callback from host. 815 */ 816 static void mmc_sdio_detect(struct mmc_host *host) 817 { 818 int err; 819 820 /* Make sure card is powered before detecting it */ 821 if (host->caps & MMC_CAP_POWER_OFF_CARD) { 822 err = pm_runtime_get_sync(&host->card->dev); 823 if (err < 0) { 824 pm_runtime_put_noidle(&host->card->dev); 825 goto out; 826 } 827 } 828 829 mmc_claim_host(host); 830 831 /* 832 * Just check if our card has been removed. 833 */ 834 err = _mmc_detect_card_removed(host); 835 836 mmc_release_host(host); 837 838 /* 839 * Tell PM core it's OK to power off the card now. 840 * 841 * The _sync variant is used in order to ensure that the card 842 * is left powered off in case an error occurred, and the card 843 * is going to be removed. 844 * 845 * Since there is no specific reason to believe a new user 846 * is about to show up at this point, the _sync variant is 847 * desirable anyway. 848 */ 849 if (host->caps & MMC_CAP_POWER_OFF_CARD) 850 pm_runtime_put_sync(&host->card->dev); 851 852 out: 853 if (err) { 854 mmc_sdio_remove(host); 855 856 mmc_claim_host(host); 857 mmc_detach_bus(host); 858 mmc_power_off(host); 859 mmc_release_host(host); 860 } 861 } 862 863 /* 864 * SDIO pre_suspend. We need to suspend all functions separately. 865 * Therefore all registered functions must have drivers with suspend 866 * and resume methods. Failing that we simply remove the whole card. 867 */ 868 static int mmc_sdio_pre_suspend(struct mmc_host *host) 869 { 870 int i, err = 0; 871 872 for (i = 0; i < host->card->sdio_funcs; i++) { 873 struct sdio_func *func = host->card->sdio_func[i]; 874 if (func && sdio_func_present(func) && func->dev.driver) { 875 const struct dev_pm_ops *pmops = func->dev.driver->pm; 876 if (!pmops || !pmops->suspend || !pmops->resume) { 877 /* force removal of entire card in that case */ 878 err = -ENOSYS; 879 break; 880 } 881 } 882 } 883 884 return err; 885 } 886 887 /* 888 * SDIO suspend. Suspend all functions separately. 889 */ 890 static int mmc_sdio_suspend(struct mmc_host *host) 891 { 892 mmc_claim_host(host); 893 894 if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) 895 sdio_disable_wide(host->card); 896 897 if (!mmc_card_keep_power(host)) { 898 mmc_power_off(host); 899 } else if (host->retune_period) { 900 mmc_retune_timer_stop(host); 901 mmc_retune_needed(host); 902 } 903 904 mmc_release_host(host); 905 906 return 0; 907 } 908 909 static int mmc_sdio_resume(struct mmc_host *host) 910 { 911 int err = 0; 912 913 /* Basic card reinitialization. */ 914 mmc_claim_host(host); 915 916 /* Restore power if needed */ 917 if (!mmc_card_keep_power(host)) { 918 mmc_power_up(host, host->card->ocr); 919 /* 920 * Tell runtime PM core we just powered up the card, 921 * since it still believes the card is powered off. 922 * Note that currently runtime PM is only enabled 923 * for SDIO cards that are MMC_CAP_POWER_OFF_CARD 924 */ 925 if (host->caps & MMC_CAP_POWER_OFF_CARD) { 926 pm_runtime_disable(&host->card->dev); 927 pm_runtime_set_active(&host->card->dev); 928 pm_runtime_enable(&host->card->dev); 929 } 930 } 931 932 /* No need to reinitialize powered-resumed nonremovable cards */ 933 if (mmc_card_is_removable(host) || !mmc_card_keep_power(host)) { 934 sdio_reset(host); 935 mmc_go_idle(host); 936 mmc_send_if_cond(host, host->card->ocr); 937 err = mmc_send_io_op_cond(host, 0, NULL); 938 if (!err) 939 err = mmc_sdio_init_card(host, host->card->ocr, 940 host->card, 941 mmc_card_keep_power(host)); 942 } else if (mmc_card_keep_power(host) && mmc_card_wake_sdio_irq(host)) { 943 /* We may have switched to 1-bit mode during suspend */ 944 err = sdio_enable_4bit_bus(host->card); 945 } 946 947 if (!err && host->sdio_irqs) { 948 if (!(host->caps2 & MMC_CAP2_SDIO_IRQ_NOTHREAD)) 949 wake_up_process(host->sdio_irq_thread); 950 else if (host->caps & MMC_CAP_SDIO_IRQ) 951 host->ops->enable_sdio_irq(host, 1); 952 } 953 954 mmc_release_host(host); 955 956 host->pm_flags &= ~MMC_PM_KEEP_POWER; 957 return err; 958 } 959 960 static int mmc_sdio_power_restore(struct mmc_host *host) 961 { 962 int ret; 963 964 mmc_claim_host(host); 965 966 /* 967 * Reset the card by performing the same steps that are taken by 968 * mmc_rescan_try_freq() and mmc_attach_sdio() during a "normal" probe. 969 * 970 * sdio_reset() is technically not needed. Having just powered up the 971 * hardware, it should already be in reset state. However, some 972 * platforms (such as SD8686 on OLPC) do not instantly cut power, 973 * meaning that a reset is required when restoring power soon after 974 * powering off. It is harmless in other cases. 975 * 976 * The CMD5 reset (mmc_send_io_op_cond()), according to the SDIO spec, 977 * is not necessary for non-removable cards. However, it is required 978 * for OLPC SD8686 (which expects a [CMD5,5,3,7] init sequence), and 979 * harmless in other situations. 980 * 981 */ 982 983 sdio_reset(host); 984 mmc_go_idle(host); 985 mmc_send_if_cond(host, host->card->ocr); 986 987 ret = mmc_send_io_op_cond(host, 0, NULL); 988 if (ret) 989 goto out; 990 991 ret = mmc_sdio_init_card(host, host->card->ocr, host->card, 992 mmc_card_keep_power(host)); 993 if (!ret && host->sdio_irqs) 994 mmc_signal_sdio_irq(host); 995 996 out: 997 mmc_release_host(host); 998 999 return ret; 1000 } 1001 1002 static int mmc_sdio_runtime_suspend(struct mmc_host *host) 1003 { 1004 /* No references to the card, cut the power to it. */ 1005 mmc_claim_host(host); 1006 mmc_power_off(host); 1007 mmc_release_host(host); 1008 1009 return 0; 1010 } 1011 1012 static int mmc_sdio_runtime_resume(struct mmc_host *host) 1013 { 1014 int ret; 1015 1016 /* Restore power and re-initialize. */ 1017 mmc_claim_host(host); 1018 mmc_power_up(host, host->card->ocr); 1019 ret = mmc_sdio_power_restore(host); 1020 mmc_release_host(host); 1021 1022 return ret; 1023 } 1024 1025 static int mmc_sdio_reset(struct mmc_host *host) 1026 { 1027 mmc_power_cycle(host, host->card->ocr); 1028 return mmc_sdio_power_restore(host); 1029 } 1030 1031 static const struct mmc_bus_ops mmc_sdio_ops = { 1032 .remove = mmc_sdio_remove, 1033 .detect = mmc_sdio_detect, 1034 .pre_suspend = mmc_sdio_pre_suspend, 1035 .suspend = mmc_sdio_suspend, 1036 .resume = mmc_sdio_resume, 1037 .runtime_suspend = mmc_sdio_runtime_suspend, 1038 .runtime_resume = mmc_sdio_runtime_resume, 1039 .power_restore = mmc_sdio_power_restore, 1040 .alive = mmc_sdio_alive, 1041 .reset = mmc_sdio_reset, 1042 }; 1043 1044 1045 /* 1046 * Starting point for SDIO card init. 1047 */ 1048 int mmc_attach_sdio(struct mmc_host *host) 1049 { 1050 int err, i, funcs; 1051 u32 ocr, rocr; 1052 struct mmc_card *card; 1053 1054 WARN_ON(!host->claimed); 1055 1056 err = mmc_send_io_op_cond(host, 0, &ocr); 1057 if (err) 1058 return err; 1059 1060 mmc_attach_bus(host, &mmc_sdio_ops); 1061 if (host->ocr_avail_sdio) 1062 host->ocr_avail = host->ocr_avail_sdio; 1063 1064 1065 rocr = mmc_select_voltage(host, ocr); 1066 1067 /* 1068 * Can we support the voltage(s) of the card(s)? 1069 */ 1070 if (!rocr) { 1071 err = -EINVAL; 1072 goto err; 1073 } 1074 1075 /* 1076 * Detect and init the card. 1077 */ 1078 err = mmc_sdio_init_card(host, rocr, NULL, 0); 1079 if (err) 1080 goto err; 1081 1082 card = host->card; 1083 1084 /* 1085 * Enable runtime PM only if supported by host+card+board 1086 */ 1087 if (host->caps & MMC_CAP_POWER_OFF_CARD) { 1088 /* 1089 * Let runtime PM core know our card is active 1090 */ 1091 err = pm_runtime_set_active(&card->dev); 1092 if (err) 1093 goto remove; 1094 1095 /* 1096 * Enable runtime PM for this card 1097 */ 1098 pm_runtime_enable(&card->dev); 1099 } 1100 1101 /* 1102 * The number of functions on the card is encoded inside 1103 * the ocr. 1104 */ 1105 funcs = (ocr & 0x70000000) >> 28; 1106 card->sdio_funcs = 0; 1107 1108 /* 1109 * Initialize (but don't add) all present functions. 1110 */ 1111 for (i = 0; i < funcs; i++, card->sdio_funcs++) { 1112 err = sdio_init_func(host->card, i + 1); 1113 if (err) 1114 goto remove; 1115 1116 /* 1117 * Enable Runtime PM for this func (if supported) 1118 */ 1119 if (host->caps & MMC_CAP_POWER_OFF_CARD) 1120 pm_runtime_enable(&card->sdio_func[i]->dev); 1121 } 1122 1123 /* 1124 * First add the card to the driver model... 1125 */ 1126 mmc_release_host(host); 1127 err = mmc_add_card(host->card); 1128 if (err) 1129 goto remove_added; 1130 1131 /* 1132 * ...then the SDIO functions. 1133 */ 1134 for (i = 0;i < funcs;i++) { 1135 err = sdio_add_func(host->card->sdio_func[i]); 1136 if (err) 1137 goto remove_added; 1138 } 1139 1140 mmc_claim_host(host); 1141 return 0; 1142 1143 1144 remove_added: 1145 /* Remove without lock if the device has been added. */ 1146 mmc_sdio_remove(host); 1147 mmc_claim_host(host); 1148 remove: 1149 /* And with lock if it hasn't been added. */ 1150 mmc_release_host(host); 1151 if (host->card) 1152 mmc_sdio_remove(host); 1153 mmc_claim_host(host); 1154 err: 1155 mmc_detach_bus(host); 1156 1157 pr_err("%s: error %d whilst initialising SDIO card\n", 1158 mmc_hostname(host), err); 1159 1160 return err; 1161 } 1162 1163