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