drivers/mmc/core/host.c

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