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