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