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