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