1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/drivers/mmc/core/host.c 4 * 5 * Copyright (C) 2003 Russell King, All Rights Reserved. 6 * Copyright (C) 2007-2008 Pierre Ossman 7 * Copyright (C) 2010 Linus Walleij 8 * 9 * MMC host class device management 10 */ 11 12 #include <linux/device.h> 13 #include <linux/err.h> 14 #include <linux/idr.h> 15 #include <linux/of.h> 16 #include <linux/of_gpio.h> 17 #include <linux/pagemap.h> 18 #include <linux/pm_wakeup.h> 19 #include <linux/export.h> 20 #include <linux/leds.h> 21 #include <linux/slab.h> 22 23 #include <linux/mmc/host.h> 24 #include <linux/mmc/card.h> 25 #include <linux/mmc/slot-gpio.h> 26 27 #include "core.h" 28 #include "crypto.h" 29 #include "host.h" 30 #include "slot-gpio.h" 31 #include "pwrseq.h" 32 #include "sdio_ops.h" 33 34 #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev) 35 36 static DEFINE_IDA(mmc_host_ida); 37 38 #ifdef CONFIG_PM_SLEEP 39 static int mmc_host_class_prepare(struct device *dev) 40 { 41 struct mmc_host *host = cls_dev_to_mmc_host(dev); 42 43 /* 44 * It's safe to access the bus_ops pointer, as both userspace and the 45 * workqueue for detecting cards are frozen at this point. 46 */ 47 if (!host->bus_ops) 48 return 0; 49 50 /* Validate conditions for system suspend. */ 51 if (host->bus_ops->pre_suspend) 52 return host->bus_ops->pre_suspend(host); 53 54 return 0; 55 } 56 57 static void mmc_host_class_complete(struct device *dev) 58 { 59 struct mmc_host *host = cls_dev_to_mmc_host(dev); 60 61 _mmc_detect_change(host, 0, false); 62 } 63 64 static const struct dev_pm_ops mmc_host_class_dev_pm_ops = { 65 .prepare = mmc_host_class_prepare, 66 .complete = mmc_host_class_complete, 67 }; 68 69 #define MMC_HOST_CLASS_DEV_PM_OPS (&mmc_host_class_dev_pm_ops) 70 #else 71 #define MMC_HOST_CLASS_DEV_PM_OPS NULL 72 #endif 73 74 static void mmc_host_classdev_release(struct device *dev) 75 { 76 struct mmc_host *host = cls_dev_to_mmc_host(dev); 77 wakeup_source_unregister(host->ws); 78 if (of_alias_get_id(host->parent->of_node, "mmc") < 0) 79 ida_simple_remove(&mmc_host_ida, host->index); 80 kfree(host); 81 } 82 83 static int mmc_host_classdev_shutdown(struct device *dev) 84 { 85 struct mmc_host *host = cls_dev_to_mmc_host(dev); 86 87 __mmc_stop_host(host); 88 return 0; 89 } 90 91 static struct class mmc_host_class = { 92 .name = "mmc_host", 93 .dev_release = mmc_host_classdev_release, 94 .shutdown_pre = mmc_host_classdev_shutdown, 95 .pm = MMC_HOST_CLASS_DEV_PM_OPS, 96 }; 97 98 int mmc_register_host_class(void) 99 { 100 return class_register(&mmc_host_class); 101 } 102 103 void mmc_unregister_host_class(void) 104 { 105 class_unregister(&mmc_host_class); 106 } 107 108 /** 109 * mmc_retune_enable() - enter a transfer mode that requires retuning 110 * @host: host which should retune now 111 */ 112 void mmc_retune_enable(struct mmc_host *host) 113 { 114 host->can_retune = 1; 115 if (host->retune_period) 116 mod_timer(&host->retune_timer, 117 jiffies + host->retune_period * HZ); 118 } 119 120 /* 121 * Pause re-tuning for a small set of operations. The pause begins after the 122 * next command and after first doing re-tuning. 123 */ 124 void mmc_retune_pause(struct mmc_host *host) 125 { 126 if (!host->retune_paused) { 127 host->retune_paused = 1; 128 mmc_retune_needed(host); 129 mmc_retune_hold(host); 130 } 131 } 132 EXPORT_SYMBOL(mmc_retune_pause); 133 134 void mmc_retune_unpause(struct mmc_host *host) 135 { 136 if (host->retune_paused) { 137 host->retune_paused = 0; 138 mmc_retune_release(host); 139 } 140 } 141 EXPORT_SYMBOL(mmc_retune_unpause); 142 143 /** 144 * mmc_retune_disable() - exit a transfer mode that requires retuning 145 * @host: host which should not retune anymore 146 * 147 * It is not meant for temporarily preventing retuning! 148 */ 149 void mmc_retune_disable(struct mmc_host *host) 150 { 151 mmc_retune_unpause(host); 152 host->can_retune = 0; 153 del_timer_sync(&host->retune_timer); 154 mmc_retune_clear(host); 155 } 156 157 void mmc_retune_timer_stop(struct mmc_host *host) 158 { 159 del_timer_sync(&host->retune_timer); 160 } 161 EXPORT_SYMBOL(mmc_retune_timer_stop); 162 163 void mmc_retune_hold(struct mmc_host *host) 164 { 165 if (!host->hold_retune) 166 host->retune_now = 1; 167 host->hold_retune += 1; 168 } 169 170 void mmc_retune_release(struct mmc_host *host) 171 { 172 if (host->hold_retune) 173 host->hold_retune -= 1; 174 else 175 WARN_ON(1); 176 } 177 EXPORT_SYMBOL(mmc_retune_release); 178 179 int mmc_retune(struct mmc_host *host) 180 { 181 bool return_to_hs400 = false; 182 int err; 183 184 if (host->retune_now) 185 host->retune_now = 0; 186 else 187 return 0; 188 189 if (!host->need_retune || host->doing_retune || !host->card) 190 return 0; 191 192 host->need_retune = 0; 193 194 host->doing_retune = 1; 195 196 if (host->ios.timing == MMC_TIMING_MMC_HS400) { 197 err = mmc_hs400_to_hs200(host->card); 198 if (err) 199 goto out; 200 201 return_to_hs400 = true; 202 } 203 204 err = mmc_execute_tuning(host->card); 205 if (err) 206 goto out; 207 208 if (return_to_hs400) 209 err = mmc_hs200_to_hs400(host->card); 210 out: 211 host->doing_retune = 0; 212 213 return err; 214 } 215 216 static void mmc_retune_timer(struct timer_list *t) 217 { 218 struct mmc_host *host = from_timer(host, t, retune_timer); 219 220 mmc_retune_needed(host); 221 } 222 223 static void mmc_of_parse_timing_phase(struct device *dev, const char *prop, 224 struct mmc_clk_phase *phase) 225 { 226 int degrees[2] = {0}; 227 int rc; 228 229 rc = device_property_read_u32_array(dev, prop, degrees, 2); 230 phase->valid = !rc; 231 if (phase->valid) { 232 phase->in_deg = degrees[0]; 233 phase->out_deg = degrees[1]; 234 } 235 } 236 237 void 238 mmc_of_parse_clk_phase(struct mmc_host *host, struct mmc_clk_phase_map *map) 239 { 240 struct device *dev = host->parent; 241 242 mmc_of_parse_timing_phase(dev, "clk-phase-legacy", 243 &map->phase[MMC_TIMING_LEGACY]); 244 mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs", 245 &map->phase[MMC_TIMING_MMC_HS]); 246 mmc_of_parse_timing_phase(dev, "clk-phase-sd-hs", 247 &map->phase[MMC_TIMING_SD_HS]); 248 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr12", 249 &map->phase[MMC_TIMING_UHS_SDR12]); 250 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr25", 251 &map->phase[MMC_TIMING_UHS_SDR25]); 252 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr50", 253 &map->phase[MMC_TIMING_UHS_SDR50]); 254 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-sdr104", 255 &map->phase[MMC_TIMING_UHS_SDR104]); 256 mmc_of_parse_timing_phase(dev, "clk-phase-uhs-ddr50", 257 &map->phase[MMC_TIMING_UHS_DDR50]); 258 mmc_of_parse_timing_phase(dev, "clk-phase-mmc-ddr52", 259 &map->phase[MMC_TIMING_MMC_DDR52]); 260 mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs200", 261 &map->phase[MMC_TIMING_MMC_HS200]); 262 mmc_of_parse_timing_phase(dev, "clk-phase-mmc-hs400", 263 &map->phase[MMC_TIMING_MMC_HS400]); 264 } 265 EXPORT_SYMBOL(mmc_of_parse_clk_phase); 266 267 /** 268 * mmc_of_parse() - parse host's device properties 269 * @host: host whose properties should be parsed. 270 * 271 * To keep the rest of the MMC subsystem unaware of whether DT has been 272 * used to instantiate and configure this host instance or not, we 273 * parse the properties and set respective generic mmc-host flags and 274 * parameters. 275 */ 276 int mmc_of_parse(struct mmc_host *host) 277 { 278 struct device *dev = host->parent; 279 u32 bus_width, drv_type, cd_debounce_delay_ms; 280 int ret; 281 282 if (!dev || !dev_fwnode(dev)) 283 return 0; 284 285 /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ 286 if (device_property_read_u32(dev, "bus-width", &bus_width) < 0) { 287 dev_dbg(host->parent, 288 "\"bus-width\" property is missing, assuming 1 bit.\n"); 289 bus_width = 1; 290 } 291 292 switch (bus_width) { 293 case 8: 294 host->caps |= MMC_CAP_8_BIT_DATA; 295 fallthrough; /* Hosts capable of 8-bit can also do 4 bits */ 296 case 4: 297 host->caps |= MMC_CAP_4_BIT_DATA; 298 break; 299 case 1: 300 break; 301 default: 302 dev_err(host->parent, 303 "Invalid \"bus-width\" value %u!\n", bus_width); 304 return -EINVAL; 305 } 306 307 /* f_max is obtained from the optional "max-frequency" property */ 308 device_property_read_u32(dev, "max-frequency", &host->f_max); 309 310 /* 311 * Configure CD and WP pins. They are both by default active low to 312 * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the 313 * mmc-gpio helpers are used to attach, configure and use them. If 314 * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH 315 * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the 316 * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability 317 * is set. If the "non-removable" property is found, the 318 * MMC_CAP_NONREMOVABLE capability is set and no card-detection 319 * configuration is performed. 320 */ 321 322 /* Parse Card Detection */ 323 324 if (device_property_read_bool(dev, "non-removable")) { 325 host->caps |= MMC_CAP_NONREMOVABLE; 326 } else { 327 if (device_property_read_bool(dev, "cd-inverted")) 328 host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; 329 330 if (device_property_read_u32(dev, "cd-debounce-delay-ms", 331 &cd_debounce_delay_ms)) 332 cd_debounce_delay_ms = 200; 333 334 if (device_property_read_bool(dev, "broken-cd")) 335 host->caps |= MMC_CAP_NEEDS_POLL; 336 337 ret = mmc_gpiod_request_cd(host, "cd", 0, false, 338 cd_debounce_delay_ms * 1000); 339 if (!ret) 340 dev_info(host->parent, "Got CD GPIO\n"); 341 else if (ret != -ENOENT && ret != -ENOSYS) 342 return ret; 343 } 344 345 /* Parse Write Protection */ 346 347 if (device_property_read_bool(dev, "wp-inverted")) 348 host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; 349 350 ret = mmc_gpiod_request_ro(host, "wp", 0, 0); 351 if (!ret) 352 dev_info(host->parent, "Got WP GPIO\n"); 353 else if (ret != -ENOENT && ret != -ENOSYS) 354 return ret; 355 356 if (device_property_read_bool(dev, "disable-wp")) 357 host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; 358 359 if (device_property_read_bool(dev, "cap-sd-highspeed")) 360 host->caps |= MMC_CAP_SD_HIGHSPEED; 361 if (device_property_read_bool(dev, "cap-mmc-highspeed")) 362 host->caps |= MMC_CAP_MMC_HIGHSPEED; 363 if (device_property_read_bool(dev, "sd-uhs-sdr12")) 364 host->caps |= MMC_CAP_UHS_SDR12; 365 if (device_property_read_bool(dev, "sd-uhs-sdr25")) 366 host->caps |= MMC_CAP_UHS_SDR25; 367 if (device_property_read_bool(dev, "sd-uhs-sdr50")) 368 host->caps |= MMC_CAP_UHS_SDR50; 369 if (device_property_read_bool(dev, "sd-uhs-sdr104")) 370 host->caps |= MMC_CAP_UHS_SDR104; 371 if (device_property_read_bool(dev, "sd-uhs-ddr50")) 372 host->caps |= MMC_CAP_UHS_DDR50; 373 if (device_property_read_bool(dev, "cap-power-off-card")) 374 host->caps |= MMC_CAP_POWER_OFF_CARD; 375 if (device_property_read_bool(dev, "cap-mmc-hw-reset")) 376 host->caps |= MMC_CAP_HW_RESET; 377 if (device_property_read_bool(dev, "cap-sdio-irq")) 378 host->caps |= MMC_CAP_SDIO_IRQ; 379 if (device_property_read_bool(dev, "full-pwr-cycle")) 380 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; 381 if (device_property_read_bool(dev, "full-pwr-cycle-in-suspend")) 382 host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE_IN_SUSPEND; 383 if (device_property_read_bool(dev, "keep-power-in-suspend")) 384 host->pm_caps |= MMC_PM_KEEP_POWER; 385 if (device_property_read_bool(dev, "wakeup-source") || 386 device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */ 387 host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; 388 if (device_property_read_bool(dev, "mmc-ddr-3_3v")) 389 host->caps |= MMC_CAP_3_3V_DDR; 390 if (device_property_read_bool(dev, "mmc-ddr-1_8v")) 391 host->caps |= MMC_CAP_1_8V_DDR; 392 if (device_property_read_bool(dev, "mmc-ddr-1_2v")) 393 host->caps |= MMC_CAP_1_2V_DDR; 394 if (device_property_read_bool(dev, "mmc-hs200-1_8v")) 395 host->caps2 |= MMC_CAP2_HS200_1_8V_SDR; 396 if (device_property_read_bool(dev, "mmc-hs200-1_2v")) 397 host->caps2 |= MMC_CAP2_HS200_1_2V_SDR; 398 if (device_property_read_bool(dev, "mmc-hs400-1_8v")) 399 host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR; 400 if (device_property_read_bool(dev, "mmc-hs400-1_2v")) 401 host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR; 402 if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe")) 403 host->caps2 |= MMC_CAP2_HS400_ES; 404 if (device_property_read_bool(dev, "no-sdio")) 405 host->caps2 |= MMC_CAP2_NO_SDIO; 406 if (device_property_read_bool(dev, "no-sd")) 407 host->caps2 |= MMC_CAP2_NO_SD; 408 if (device_property_read_bool(dev, "no-mmc")) 409 host->caps2 |= MMC_CAP2_NO_MMC; 410 if (device_property_read_bool(dev, "no-mmc-hs400")) 411 host->caps2 &= ~(MMC_CAP2_HS400_1_8V | MMC_CAP2_HS400_1_2V | 412 MMC_CAP2_HS400_ES); 413 414 /* Must be after "non-removable" check */ 415 if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) { 416 if (host->caps & MMC_CAP_NONREMOVABLE) 417 host->fixed_drv_type = drv_type; 418 else 419 dev_err(host->parent, 420 "can't use fixed driver type, media is removable\n"); 421 } 422 423 host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr); 424 if (host->dsr_req && (host->dsr & ~0xffff)) { 425 dev_err(host->parent, 426 "device tree specified broken value for DSR: 0x%x, ignoring\n", 427 host->dsr); 428 host->dsr_req = 0; 429 } 430 431 device_property_read_u32(dev, "post-power-on-delay-ms", 432 &host->ios.power_delay_ms); 433 434 return mmc_pwrseq_alloc(host); 435 } 436 437 EXPORT_SYMBOL(mmc_of_parse); 438 439 /** 440 * mmc_of_parse_voltage - return mask of supported voltages 441 * @host: host whose properties should be parsed. 442 * @mask: mask of voltages available for MMC/SD/SDIO 443 * 444 * Parse the "voltage-ranges" property, returning zero if it is not 445 * found, negative errno if the voltage-range specification is invalid, 446 * or one if the voltage-range is specified and successfully parsed. 447 */ 448 int mmc_of_parse_voltage(struct mmc_host *host, u32 *mask) 449 { 450 const char *prop = "voltage-ranges"; 451 struct device *dev = host->parent; 452 u32 *voltage_ranges; 453 int num_ranges, i; 454 int ret; 455 456 if (!device_property_present(dev, prop)) { 457 dev_dbg(dev, "%s unspecified\n", prop); 458 return 0; 459 } 460 461 ret = device_property_count_u32(dev, prop); 462 if (ret < 0) 463 return ret; 464 465 num_ranges = ret / 2; 466 if (!num_ranges) { 467 dev_err(dev, "%s empty\n", prop); 468 return -EINVAL; 469 } 470 471 voltage_ranges = kcalloc(2 * num_ranges, sizeof(*voltage_ranges), GFP_KERNEL); 472 if (!voltage_ranges) 473 return -ENOMEM; 474 475 ret = device_property_read_u32_array(dev, prop, voltage_ranges, 2 * num_ranges); 476 if (ret) { 477 kfree(voltage_ranges); 478 return ret; 479 } 480 481 for (i = 0; i < num_ranges; i++) { 482 const int j = i * 2; 483 u32 ocr_mask; 484 485 ocr_mask = mmc_vddrange_to_ocrmask(voltage_ranges[j + 0], 486 voltage_ranges[j + 1]); 487 if (!ocr_mask) { 488 dev_err(dev, "range #%d in %s is invalid\n", i, prop); 489 kfree(voltage_ranges); 490 return -EINVAL; 491 } 492 *mask |= ocr_mask; 493 } 494 495 kfree(voltage_ranges); 496 497 return 1; 498 } 499 EXPORT_SYMBOL(mmc_of_parse_voltage); 500 501 /** 502 * mmc_first_nonreserved_index() - get the first index that is not reserved 503 */ 504 static int mmc_first_nonreserved_index(void) 505 { 506 int max; 507 508 max = of_alias_get_highest_id("mmc"); 509 if (max < 0) 510 return 0; 511 512 return max + 1; 513 } 514 515 /** 516 * mmc_alloc_host - initialise the per-host structure. 517 * @extra: sizeof private data structure 518 * @dev: pointer to host device model structure 519 * 520 * Initialise the per-host structure. 521 */ 522 struct mmc_host *mmc_alloc_host(int extra, struct device *dev) 523 { 524 int index; 525 struct mmc_host *host; 526 int alias_id, min_idx, max_idx; 527 528 host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); 529 if (!host) 530 return NULL; 531 532 /* scanning will be enabled when we're ready */ 533 host->rescan_disable = 1; 534 535 alias_id = of_alias_get_id(dev->of_node, "mmc"); 536 if (alias_id >= 0) { 537 index = alias_id; 538 } else { 539 min_idx = mmc_first_nonreserved_index(); 540 max_idx = 0; 541 542 index = ida_simple_get(&mmc_host_ida, min_idx, max_idx, GFP_KERNEL); 543 if (index < 0) { 544 kfree(host); 545 return NULL; 546 } 547 } 548 549 host->index = index; 550 551 dev_set_name(&host->class_dev, "mmc%d", host->index); 552 host->ws = wakeup_source_register(NULL, dev_name(&host->class_dev)); 553 554 host->parent = dev; 555 host->class_dev.parent = dev; 556 host->class_dev.class = &mmc_host_class; 557 device_initialize(&host->class_dev); 558 device_enable_async_suspend(&host->class_dev); 559 560 if (mmc_gpio_alloc(host)) { 561 put_device(&host->class_dev); 562 return NULL; 563 } 564 565 spin_lock_init(&host->lock); 566 init_waitqueue_head(&host->wq); 567 INIT_DELAYED_WORK(&host->detect, mmc_rescan); 568 INIT_WORK(&host->sdio_irq_work, sdio_irq_work); 569 timer_setup(&host->retune_timer, mmc_retune_timer, 0); 570 571 /* 572 * By default, hosts do not support SGIO or large requests. 573 * They have to set these according to their abilities. 574 */ 575 host->max_segs = 1; 576 host->max_seg_size = PAGE_SIZE; 577 578 host->max_req_size = PAGE_SIZE; 579 host->max_blk_size = 512; 580 host->max_blk_count = PAGE_SIZE / 512; 581 582 host->fixed_drv_type = -EINVAL; 583 host->ios.power_delay_ms = 10; 584 host->ios.power_mode = MMC_POWER_UNDEFINED; 585 586 return host; 587 } 588 589 EXPORT_SYMBOL(mmc_alloc_host); 590 591 static void devm_mmc_host_release(struct device *dev, void *res) 592 { 593 mmc_free_host(*(struct mmc_host **)res); 594 } 595 596 struct mmc_host *devm_mmc_alloc_host(struct device *dev, int extra) 597 { 598 struct mmc_host **dr, *host; 599 600 dr = devres_alloc(devm_mmc_host_release, sizeof(*dr), GFP_KERNEL); 601 if (!dr) 602 return NULL; 603 604 host = mmc_alloc_host(extra, dev); 605 if (!host) { 606 devres_free(dr); 607 return NULL; 608 } 609 610 *dr = host; 611 devres_add(dev, dr); 612 613 return host; 614 } 615 EXPORT_SYMBOL(devm_mmc_alloc_host); 616 617 static int mmc_validate_host_caps(struct mmc_host *host) 618 { 619 struct device *dev = host->parent; 620 u32 caps = host->caps, caps2 = host->caps2; 621 622 if (caps & MMC_CAP_SDIO_IRQ && !host->ops->enable_sdio_irq) { 623 dev_warn(dev, "missing ->enable_sdio_irq() ops\n"); 624 return -EINVAL; 625 } 626 627 if (caps2 & (MMC_CAP2_HS400_ES | MMC_CAP2_HS400) && 628 !(caps & MMC_CAP_8_BIT_DATA) && !(caps2 & MMC_CAP2_NO_MMC)) { 629 dev_warn(dev, "drop HS400 support since no 8-bit bus\n"); 630 host->caps2 = caps2 & ~MMC_CAP2_HS400_ES & ~MMC_CAP2_HS400; 631 } 632 633 return 0; 634 } 635 636 /** 637 * mmc_add_host - initialise host hardware 638 * @host: mmc host 639 * 640 * Register the host with the driver model. The host must be 641 * prepared to start servicing requests before this function 642 * completes. 643 */ 644 int mmc_add_host(struct mmc_host *host) 645 { 646 int err; 647 648 err = mmc_validate_host_caps(host); 649 if (err) 650 return err; 651 652 err = device_add(&host->class_dev); 653 if (err) 654 return err; 655 656 led_trigger_register_simple(dev_name(&host->class_dev), &host->led); 657 658 mmc_add_host_debugfs(host); 659 660 mmc_start_host(host); 661 return 0; 662 } 663 664 EXPORT_SYMBOL(mmc_add_host); 665 666 /** 667 * mmc_remove_host - remove host hardware 668 * @host: mmc host 669 * 670 * Unregister and remove all cards associated with this host, 671 * and power down the MMC bus. No new requests will be issued 672 * after this function has returned. 673 */ 674 void mmc_remove_host(struct mmc_host *host) 675 { 676 mmc_stop_host(host); 677 678 mmc_remove_host_debugfs(host); 679 680 device_del(&host->class_dev); 681 682 led_trigger_unregister_simple(host->led); 683 } 684 685 EXPORT_SYMBOL(mmc_remove_host); 686 687 /** 688 * mmc_free_host - free the host structure 689 * @host: mmc host 690 * 691 * Free the host once all references to it have been dropped. 692 */ 693 void mmc_free_host(struct mmc_host *host) 694 { 695 mmc_pwrseq_free(host); 696 put_device(&host->class_dev); 697 } 698 699 EXPORT_SYMBOL(mmc_free_host); 700