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