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 14#include <linux/mmc/host.h> 15#include <linux/mmc/card.h> 16#include <linux/mmc/sdio.h> 17#include <linux/mmc/sdio_func.h> 18 19#include "core.h" 20#include "bus.h" 21#include "sd.h" 22#include "sdio_bus.h" 23#include "mmc_ops.h" 24#include "sd_ops.h" 25#include "sdio_ops.h" 26#include "sdio_cis.h" 27 28static int sdio_read_fbr(struct sdio_func *func) 29{ 30 int ret; 31 unsigned char data; 32 33 ret = mmc_io_rw_direct(func->card, 0, 0, 34 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF, 0, &data); 35 if (ret) 36 goto out; 37 38 data &= 0x0f; 39 40 if (data == 0x0f) { 41 ret = mmc_io_rw_direct(func->card, 0, 0, 42 SDIO_FBR_BASE(func->num) + SDIO_FBR_STD_IF_EXT, 0, &data); 43 if (ret) 44 goto out; 45 } 46 47 func->class = data; 48 49out: 50 return ret; 51} 52 53static int sdio_init_func(struct mmc_card *card, unsigned int fn) 54{ 55 int ret; 56 struct sdio_func *func; 57 58 BUG_ON(fn > SDIO_MAX_FUNCS); 59 60 func = sdio_alloc_func(card); 61 if (IS_ERR(func)) 62 return PTR_ERR(func); 63 64 func->num = fn; 65 66 if (!(card->quirks & MMC_QUIRK_NONSTD_SDIO)) { 67 ret = sdio_read_fbr(func); 68 if (ret) 69 goto fail; 70 71 ret = sdio_read_func_cis(func); 72 if (ret) 73 goto fail; 74 } else { 75 func->vendor = func->card->cis.vendor; 76 func->device = func->card->cis.device; 77 func->max_blksize = func->card->cis.blksize; 78 } 79 80 card->sdio_func[fn - 1] = func; 81 82 return 0; 83 84fail: 85 /* 86 * It is okay to remove the function here even though we hold 87 * the host lock as we haven't registered the device yet. 88 */ 89 sdio_remove_func(func); 90 return ret; 91} 92 93static int sdio_read_cccr(struct mmc_card *card) 94{ 95 int ret; 96 int cccr_vsn; 97 unsigned char data; 98 99 memset(&card->cccr, 0, sizeof(struct sdio_cccr)); 100 101 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CCCR, 0, &data); 102 if (ret) 103 goto out; 104 105 cccr_vsn = data & 0x0f; 106 107 if (cccr_vsn > SDIO_CCCR_REV_1_20) { 108 printk(KERN_ERR "%s: unrecognised CCCR structure version %d\n", 109 mmc_hostname(card->host), cccr_vsn); 110 return -EINVAL; 111 } 112 113 card->cccr.sdio_vsn = (data & 0xf0) >> 4; 114 115 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_CAPS, 0, &data); 116 if (ret) 117 goto out; 118 119 if (data & SDIO_CCCR_CAP_SMB) 120 card->cccr.multi_block = 1; 121 if (data & SDIO_CCCR_CAP_LSC) 122 card->cccr.low_speed = 1; 123 if (data & SDIO_CCCR_CAP_4BLS) 124 card->cccr.wide_bus = 1; 125 126 if (cccr_vsn >= SDIO_CCCR_REV_1_10) { 127 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_POWER, 0, &data); 128 if (ret) 129 goto out; 130 131 if (data & SDIO_POWER_SMPC) 132 card->cccr.high_power = 1; 133 } 134 135 if (cccr_vsn >= SDIO_CCCR_REV_1_20) { 136 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &data); 137 if (ret) 138 goto out; 139 140 if (data & SDIO_SPEED_SHS) 141 card->cccr.high_speed = 1; 142 } 143 144out: 145 return ret; 146} 147 148static int sdio_enable_wide(struct mmc_card *card) 149{ 150 int ret; 151 u8 ctrl; 152 153 if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) 154 return 0; 155 156 if (card->cccr.low_speed && !card->cccr.wide_bus) 157 return 0; 158 159 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl); 160 if (ret) 161 return ret; 162 163 ctrl |= SDIO_BUS_WIDTH_4BIT; 164 165 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL); 166 if (ret) 167 return ret; 168 169 return 1; 170} 171 172/* 173 * If desired, disconnect the pull-up resistor on CD/DAT[3] (pin 1) 174 * of the card. This may be required on certain setups of boards, 175 * controllers and embedded sdio device which do not need the card's 176 * pull-up. As a result, card detection is disabled and power is saved. 177 */ 178static int sdio_disable_cd(struct mmc_card *card) 179{ 180 int ret; 181 u8 ctrl; 182 183 if (!card->cccr.disable_cd) 184 return 0; 185 186 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl); 187 if (ret) 188 return ret; 189 190 ctrl |= SDIO_BUS_CD_DISABLE; 191 192 return mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL); 193} 194 195/* 196 * Devices that remain active during a system suspend are 197 * put back into 1-bit mode. 198 */ 199static int sdio_disable_wide(struct mmc_card *card) 200{ 201 int ret; 202 u8 ctrl; 203 204 if (!(card->host->caps & MMC_CAP_4_BIT_DATA)) 205 return 0; 206 207 if (card->cccr.low_speed && !card->cccr.wide_bus) 208 return 0; 209 210 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_IF, 0, &ctrl); 211 if (ret) 212 return ret; 213 214 if (!(ctrl & SDIO_BUS_WIDTH_4BIT)) 215 return 0; 216 217 ctrl &= ~SDIO_BUS_WIDTH_4BIT; 218 ctrl |= SDIO_BUS_ASYNC_INT; 219 220 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_IF, ctrl, NULL); 221 if (ret) 222 return ret; 223 224 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_1); 225 226 return 0; 227} 228 229 230static int sdio_enable_4bit_bus(struct mmc_card *card) 231{ 232 int err; 233 234 if (card->type == MMC_TYPE_SDIO) 235 return sdio_enable_wide(card); 236 237 if ((card->host->caps & MMC_CAP_4_BIT_DATA) && 238 (card->scr.bus_widths & SD_SCR_BUS_WIDTH_4)) { 239 err = mmc_app_set_bus_width(card, MMC_BUS_WIDTH_4); 240 if (err) 241 return err; 242 } else 243 return 0; 244 245 err = sdio_enable_wide(card); 246 if (err <= 0) 247 mmc_app_set_bus_width(card, MMC_BUS_WIDTH_1); 248 249 return err; 250} 251 252 253/* 254 * Test if the card supports high-speed mode and, if so, switch to it. 255 */ 256static int mmc_sdio_switch_hs(struct mmc_card *card, int enable) 257{ 258 int ret; 259 u8 speed; 260 261 if (!(card->host->caps & MMC_CAP_SD_HIGHSPEED)) 262 return 0; 263 264 if (!card->cccr.high_speed) 265 return 0; 266 267 ret = mmc_io_rw_direct(card, 0, 0, SDIO_CCCR_SPEED, 0, &speed); 268 if (ret) 269 return ret; 270 271 if (enable) 272 speed |= SDIO_SPEED_EHS; 273 else 274 speed &= ~SDIO_SPEED_EHS; 275 276 ret = mmc_io_rw_direct(card, 1, 0, SDIO_CCCR_SPEED, speed, NULL); 277 if (ret) 278 return ret; 279 280 return 1; 281} 282 283/* 284 * Enable SDIO/combo card's high-speed mode. Return 0/1 if [not]supported. 285 */ 286static int sdio_enable_hs(struct mmc_card *card) 287{ 288 int ret; 289 290 ret = mmc_sdio_switch_hs(card, true); 291 if (ret <= 0 || card->type == MMC_TYPE_SDIO) 292 return ret; 293 294 ret = mmc_sd_switch_hs(card); 295 if (ret <= 0) 296 mmc_sdio_switch_hs(card, false); 297 298 return ret; 299} 300 301static unsigned mmc_sdio_get_max_clock(struct mmc_card *card) 302{ 303 unsigned max_dtr; 304 305 if (mmc_card_highspeed(card)) { 306 /* 307 * The SDIO specification doesn't mention how 308 * the CIS transfer speed register relates to 309 * high-speed, but it seems that 50 MHz is 310 * mandatory. 311 */ 312 max_dtr = 50000000; 313 } else { 314 max_dtr = card->cis.max_dtr; 315 } 316 317 if (card->type == MMC_TYPE_SD_COMBO) 318 max_dtr = min(max_dtr, mmc_sd_get_max_clock(card)); 319 320 return max_dtr; 321} 322 323/* 324 * Handle the detection and initialisation of a card. 325 * 326 * In the case of a resume, "oldcard" will contain the card 327 * we're trying to reinitialise. 328 */ 329static int mmc_sdio_init_card(struct mmc_host *host, u32 ocr, 330 struct mmc_card *oldcard, int powered_resume) 331{ 332 struct mmc_card *card; 333 int err; 334 335 BUG_ON(!host); 336 WARN_ON(!host->claimed); 337 338 /* 339 * Inform the card of the voltage 340 */ 341 if (!powered_resume) { 342 err = mmc_send_io_op_cond(host, host->ocr, &ocr); 343 if (err) 344 goto err; 345 } 346 347 /* 348 * For SPI, enable CRC as appropriate. 349 */ 350 if (mmc_host_is_spi(host)) { 351 err = mmc_spi_set_crc(host, use_spi_crc); 352 if (err) 353 goto err; 354 } 355 356 /* 357 * Allocate card structure. 358 */ 359 card = mmc_alloc_card(host, NULL); 360 if (IS_ERR(card)) { 361 err = PTR_ERR(card); 362 goto err; 363 } 364 365 if (ocr & R4_MEMORY_PRESENT 366 && mmc_sd_get_cid(host, host->ocr & ocr, card->raw_cid) == 0) { 367 card->type = MMC_TYPE_SD_COMBO; 368 369 if (oldcard && (oldcard->type != MMC_TYPE_SD_COMBO || 370 memcmp(card->raw_cid, oldcard->raw_cid, sizeof(card->raw_cid)) != 0)) { 371 mmc_remove_card(card); 372 return -ENOENT; 373 } 374 } else { 375 card->type = MMC_TYPE_SDIO; 376 377 if (oldcard && oldcard->type != MMC_TYPE_SDIO) { 378 mmc_remove_card(card); 379 return -ENOENT; 380 } 381 } 382 383 /* 384 * Call the optional HC's init_card function to handle quirks. 385 */ 386 if (host->ops->init_card) 387 host->ops->init_card(host, card); 388 389 /* 390 * For native busses: set card RCA and quit open drain mode. 391 */ 392 if (!powered_resume && !mmc_host_is_spi(host)) { 393 err = mmc_send_relative_addr(host, &card->rca); 394 if (err) 395 goto remove; 396 397 mmc_set_bus_mode(host, MMC_BUSMODE_PUSHPULL); 398 } 399 400 /* 401 * Read CSD, before selecting the card 402 */ 403 if (!oldcard && card->type == MMC_TYPE_SD_COMBO) { 404 err = mmc_sd_get_csd(host, card); 405 if (err) 406 return err; 407 408 mmc_decode_cid(card); 409 } 410 411 /* 412 * Select card, as all following commands rely on that. 413 */ 414 if (!powered_resume && !mmc_host_is_spi(host)) { 415 err = mmc_select_card(card); 416 if (err) 417 goto remove; 418 } 419 420 if (card->quirks & MMC_QUIRK_NONSTD_SDIO) { 421 /* 422 * This is non-standard SDIO device, meaning it doesn't 423 * have any CIA (Common I/O area) registers present. 424 * It's host's responsibility to fill cccr and cis 425 * structures in init_card(). 426 */ 427 mmc_set_clock(host, card->cis.max_dtr); 428 429 if (card->cccr.high_speed) { 430 mmc_card_set_highspeed(card); 431 mmc_set_timing(card->host, MMC_TIMING_SD_HS); 432 } 433 434 goto finish; 435 } 436 437 /* 438 * Read the common registers. 439 */ 440 err = sdio_read_cccr(card); 441 if (err) 442 goto remove; 443 444 /* 445 * Read the common CIS tuples. 446 */ 447 err = sdio_read_common_cis(card); 448 if (err) 449 goto remove; 450 451 if (oldcard) { 452 int same = (card->cis.vendor == oldcard->cis.vendor && 453 card->cis.device == oldcard->cis.device); 454 mmc_remove_card(card); 455 if (!same) 456 return -ENOENT; 457 458 card = oldcard; 459 return 0; 460 } 461 462 if (card->type == MMC_TYPE_SD_COMBO) { 463 err = mmc_sd_setup_card(host, card, oldcard != NULL); 464 /* handle as SDIO-only card if memory init failed */ 465 if (err) { 466 mmc_go_idle(host); 467 if (mmc_host_is_spi(host)) 468 /* should not fail, as it worked previously */ 469 mmc_spi_set_crc(host, use_spi_crc); 470 card->type = MMC_TYPE_SDIO; 471 } else 472 card->dev.type = &sd_type; 473 } 474 475 /* 476 * If needed, disconnect card detection pull-up resistor. 477 */ 478 err = sdio_disable_cd(card); 479 if (err) 480 goto remove; 481 482 /* 483 * Switch to high-speed (if supported). 484 */ 485 err = sdio_enable_hs(card); 486 if (err > 0) 487 mmc_sd_go_highspeed(card); 488 else if (err) 489 goto remove; 490 491 /* 492 * Change to the card's maximum speed. 493 */ 494 mmc_set_clock(host, mmc_sdio_get_max_clock(card)); 495 496 /* 497 * Switch to wider bus (if supported). 498 */ 499 err = sdio_enable_4bit_bus(card); 500 if (err > 0) 501 mmc_set_bus_width(card->host, MMC_BUS_WIDTH_4); 502 else if (err) 503 goto remove; 504 505finish: 506 if (!oldcard) 507 host->card = card; 508 return 0; 509 510remove: 511 if (!oldcard) 512 mmc_remove_card(card); 513 514err: 515 return err; 516} 517 518/* 519 * Host is being removed. Free up the current card. 520 */ 521static void mmc_sdio_remove(struct mmc_host *host) 522{ 523 int i; 524 525 BUG_ON(!host); 526 BUG_ON(!host->card); 527 528 for (i = 0;i < host->card->sdio_funcs;i++) { 529 if (host->card->sdio_func[i]) { 530 sdio_remove_func(host->card->sdio_func[i]); 531 host->card->sdio_func[i] = NULL; 532 } 533 } 534 535 mmc_remove_card(host->card); 536 host->card = NULL; 537} 538 539/* 540 * Card detection callback from host. 541 */ 542static void mmc_sdio_detect(struct mmc_host *host) 543{ 544 int err; 545 546 BUG_ON(!host); 547 BUG_ON(!host->card); 548 549 mmc_claim_host(host); 550 551 /* 552 * Just check if our card has been removed. 553 */ 554 err = mmc_select_card(host->card); 555 556 mmc_release_host(host); 557 558 if (err) { 559 mmc_sdio_remove(host); 560 561 mmc_claim_host(host); 562 mmc_detach_bus(host); 563 mmc_release_host(host); 564 } 565} 566 567/* 568 * SDIO suspend. We need to suspend all functions separately. 569 * Therefore all registered functions must have drivers with suspend 570 * and resume methods. Failing that we simply remove the whole card. 571 */ 572static int mmc_sdio_suspend(struct mmc_host *host) 573{ 574 int i, err = 0; 575 576 for (i = 0; i < host->card->sdio_funcs; i++) { 577 struct sdio_func *func = host->card->sdio_func[i]; 578 if (func && sdio_func_present(func) && func->dev.driver) { 579 const struct dev_pm_ops *pmops = func->dev.driver->pm; 580 if (!pmops || !pmops->suspend || !pmops->resume) { 581 /* force removal of entire card in that case */ 582 err = -ENOSYS; 583 } else 584 err = pmops->suspend(&func->dev); 585 if (err) 586 break; 587 } 588 } 589 while (err && --i >= 0) { 590 struct sdio_func *func = host->card->sdio_func[i]; 591 if (func && sdio_func_present(func) && func->dev.driver) { 592 const struct dev_pm_ops *pmops = func->dev.driver->pm; 593 pmops->resume(&func->dev); 594 } 595 } 596 597 if (!err && host->pm_flags & MMC_PM_KEEP_POWER) { 598 mmc_claim_host(host); 599 sdio_disable_wide(host->card); 600 mmc_release_host(host); 601 } 602 603 return err; 604} 605 606static int mmc_sdio_resume(struct mmc_host *host) 607{ 608 int i, err; 609 610 BUG_ON(!host); 611 BUG_ON(!host->card); 612 613 /* Basic card reinitialization. */ 614 mmc_claim_host(host); 615 err = mmc_sdio_init_card(host, host->ocr, host->card, 616 (host->pm_flags & MMC_PM_KEEP_POWER)); 617 if (!err) { 618 /* We may have switched to 1-bit mode during suspend. */ 619 err = sdio_enable_4bit_bus(host->card); 620 if (err > 0) { 621 mmc_set_bus_width(host, MMC_BUS_WIDTH_4); 622 err = 0; 623 } 624 } 625 if (!err && host->sdio_irqs) 626 mmc_signal_sdio_irq(host); 627 mmc_release_host(host); 628 629 /* 630 * If the card looked to be the same as before suspending, then 631 * we proceed to resume all card functions. If one of them returns 632 * an error then we simply return that error to the core and the 633 * card will be redetected as new. It is the responsibility of 634 * the function driver to perform further tests with the extra 635 * knowledge it has of the card to confirm the card is indeed the 636 * same as before suspending (same MAC address for network cards, 637 * etc.) and return an error otherwise. 638 */ 639 for (i = 0; !err && i < host->card->sdio_funcs; i++) { 640 struct sdio_func *func = host->card->sdio_func[i]; 641 if (func && sdio_func_present(func) && func->dev.driver) { 642 const struct dev_pm_ops *pmops = func->dev.driver->pm; 643 err = pmops->resume(&func->dev); 644 } 645 } 646 647 return err; 648} 649 650static const struct mmc_bus_ops mmc_sdio_ops = { 651 .remove = mmc_sdio_remove, 652 .detect = mmc_sdio_detect, 653 .suspend = mmc_sdio_suspend, 654 .resume = mmc_sdio_resume, 655}; 656 657 658/* 659 * Starting point for SDIO card init. 660 */ 661int mmc_attach_sdio(struct mmc_host *host, u32 ocr) 662{ 663 int err; 664 int i, funcs; 665 struct mmc_card *card; 666 667 BUG_ON(!host); 668 WARN_ON(!host->claimed); 669 670 mmc_attach_bus(host, &mmc_sdio_ops); 671 672 /* 673 * Sanity check the voltages that the card claims to 674 * support. 675 */ 676 if (ocr & 0x7F) { 677 printk(KERN_WARNING "%s: card claims to support voltages " 678 "below the defined range. These will be ignored.\n", 679 mmc_hostname(host)); 680 ocr &= ~0x7F; 681 } 682 683 host->ocr = mmc_select_voltage(host, ocr); 684 685 /* 686 * Can we support the voltage(s) of the card(s)? 687 */ 688 if (!host->ocr) { 689 err = -EINVAL; 690 goto err; 691 } 692 693 /* 694 * Detect and init the card. 695 */ 696 err = mmc_sdio_init_card(host, host->ocr, NULL, 0); 697 if (err) 698 goto err; 699 card = host->card; 700 701 /* 702 * The number of functions on the card is encoded inside 703 * the ocr. 704 */ 705 funcs = (ocr & 0x70000000) >> 28; 706 card->sdio_funcs = 0; 707 708 /* 709 * Initialize (but don't add) all present functions. 710 */ 711 for (i = 0; i < funcs; i++, card->sdio_funcs++) { 712 err = sdio_init_func(host->card, i + 1); 713 if (err) 714 goto remove; 715 } 716 717 mmc_release_host(host); 718 719 /* 720 * First add the card to the driver model... 721 */ 722 err = mmc_add_card(host->card); 723 if (err) 724 goto remove_added; 725 726 /* 727 * ...then the SDIO functions. 728 */ 729 for (i = 0;i < funcs;i++) { 730 err = sdio_add_func(host->card->sdio_func[i]); 731 if (err) 732 goto remove_added; 733 } 734 735 return 0; 736 737 738remove_added: 739 /* Remove without lock if the device has been added. */ 740 mmc_sdio_remove(host); 741 mmc_claim_host(host); 742remove: 743 /* And with lock if it hasn't been added. */ 744 if (host->card) 745 mmc_sdio_remove(host); 746err: 747 mmc_detach_bus(host); 748 mmc_release_host(host); 749 750 printk(KERN_ERR "%s: error %d whilst initialising SDIO card\n", 751 mmc_hostname(host), err); 752 753 return err; 754} 755