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
 392         /* Must be after "non-removable" check */
 393         if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) {
 394                 if (host->caps & MMC_CAP_NONREMOVABLE)
 395                         host->fixed_drv_type = drv_type;
 396                 else
 397                         dev_err(host->parent,
 398                                 "can't use fixed driver type, media is removable\n");
 399         }
 400
 401         host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr);
 402         if (host->dsr_req && (host->dsr & ~0xffff)) {
 403                 dev_err(host->parent,
 404                         "device tree specified broken value for DSR: 0x%x, ignoring\n",
 405                         host->dsr);
 406                 host->dsr_req = 0;
 407         }
 408
 409         device_property_read_u32(dev, "post-power-on-delay-ms",
 410                                  &host->ios.power_delay_ms);
 411
 412         return mmc_pwrseq_alloc(host);
 413 }
 414
 415 EXPORT_SYMBOL(mmc_of_parse);
 416
 417 /**
 418  * mmc_of_parse_voltage - return mask of supported voltages
 419  * @host: host whose properties should be parsed.
 420  * @mask: mask of voltages available for MMC/SD/SDIO
 421  *
 422  * Parse the "voltage-ranges" property, returning zero if it is not
 423  * found, negative errno if the voltage-range specification is invalid,
 424  * or one if the voltage-range is specified and successfully parsed.
 425  */
 426 int mmc_of_parse_voltage(struct mmc_host *host, u32 *mask)
 427 {
 428         const char *prop = "voltage-ranges";
 429         struct device *dev = host->parent;
 430         u32 *voltage_ranges;
 431         int num_ranges, i;
 432         int ret;
 433
 434         if (!device_property_present(dev, prop)) {
 435                 dev_dbg(dev, "%s unspecified\n", prop);
 436                 return 0;
 437         }
 438
 439         ret = device_property_count_u32(dev, prop);
 440         if (ret < 0)
 441                 return ret;
 442
 443         num_ranges = ret / 2;
 444         if (!num_ranges) {
 445                 dev_err(dev, "%s empty\n", prop);
 446                 return -EINVAL;
 447         }
 448
 449         voltage_ranges = kcalloc(2 * num_ranges, sizeof(*voltage_ranges), GFP_KERNEL);
 450         if (!voltage_ranges)
 451                 return -ENOMEM;
 452
 453         ret = device_property_read_u32_array(dev, prop, voltage_ranges, 2 * num_ranges);
 454         if (ret) {
 455                 kfree(voltage_ranges);
 456                 return ret;
 457         }
 458
 459         for (i = 0; i < num_ranges; i++) {
 460                 const int j = i * 2;
 461                 u32 ocr_mask;
 462
 463                 ocr_mask = mmc_vddrange_to_ocrmask(voltage_ranges[j + 0],
 464                                                    voltage_ranges[j + 1]);
 465                 if (!ocr_mask) {
 466                         dev_err(dev, "range #%d in %s is invalid\n", i, prop);
 467                         kfree(voltage_ranges);
 468                         return -EINVAL;
 469                 }
 470                 *mask |= ocr_mask;
 471         }
 472
 473         kfree(voltage_ranges);
 474
 475         return 1;
 476 }
 477 EXPORT_SYMBOL(mmc_of_parse_voltage);
 478
 479 /**
 480  * mmc_first_nonreserved_index() - get the first index that is not reserved
 481  */
 482 static int mmc_first_nonreserved_index(void)
 483 {
 484         int max;
 485
 486         max = of_alias_get_highest_id("mmc");
 487         if (max < 0)
 488                 return 0;
 489
 490         return max + 1;
 491 }
 492
 493 /**
 494  *      mmc_alloc_host - initialise the per-host structure.
 495  *      @extra: sizeof private data structure
 496  *      @dev: pointer to host device model structure
 497  *
 498  *      Initialise the per-host structure.
 499  */
 500 struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
 501 {
 502         int err;
 503         struct mmc_host *host;
 504         int alias_id, min_idx, max_idx;
 505
 506         host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL);
 507         if (!host)
 508                 return NULL;
 509
 510         /* scanning will be enabled when we're ready */
 511         host->rescan_disable = 1;
 512
 513         alias_id = of_alias_get_id(dev->of_node, "mmc");
 514         if (alias_id >= 0) {
 515                 min_idx = alias_id;
 516                 max_idx = alias_id + 1;
 517         } else {
 518                 min_idx = mmc_first_nonreserved_index();
 519                 max_idx = 0;
 520         }
 521
 522         err = ida_simple_get(&mmc_host_ida, min_idx, max_idx, GFP_KERNEL);
 523         if (err < 0) {
 524                 kfree(host);
 525                 return NULL;
 526         }
 527
 528         host->index = err;
 529
 530         dev_set_name(&host->class_dev, "mmc%d", host->index);
 531         host->ws = wakeup_source_register(NULL, dev_name(&host->class_dev));
 532
 533         host->parent = dev;
 534         host->class_dev.parent = dev;
 535         host->class_dev.class = &mmc_host_class;
 536         device_initialize(&host->class_dev);
 537         device_enable_async_suspend(&host->class_dev);
 538
 539         if (mmc_gpio_alloc(host)) {
 540                 put_device(&host->class_dev);
 541                 return NULL;
 542         }
 543
 544         spin_lock_init(&host->lock);
 545         init_waitqueue_head(&host->wq);
 546         INIT_DELAYED_WORK(&host->detect, mmc_rescan);
 547         INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work);
 548         timer_setup(&host->retune_timer, mmc_retune_timer, 0);
 549
 550         /*
 551          * By default, hosts do not support SGIO or large requests.
 552          * They have to set these according to their abilities.
 553          */
 554         host->max_segs = 1;
 555         host->max_seg_size = PAGE_SIZE;
 556
 557         host->max_req_size = PAGE_SIZE;
 558         host->max_blk_size = 512;
 559         host->max_blk_count = PAGE_SIZE / 512;
 560
 561         host->fixed_drv_type = -EINVAL;
 562         host->ios.power_delay_ms = 10;
 563         host->ios.power_mode = MMC_POWER_UNDEFINED;
 564
 565         return host;
 566 }
 567
 568 EXPORT_SYMBOL(mmc_alloc_host);
 569
 570 /**
 571  *      mmc_add_host - initialise host hardware
 572  *      @host: mmc host
 573  *
 574  *      Register the host with the driver model. The host must be
 575  *      prepared to start servicing requests before this function
 576  *      completes.
 577  */
 578 int mmc_add_host(struct mmc_host *host)
 579 {
 580         int err;
 581
 582         WARN_ON((host->caps & MMC_CAP_SDIO_IRQ) &&
 583                 !host->ops->enable_sdio_irq);
 584
 585         err = device_add(&host->class_dev);
 586         if (err)
 587                 return err;
 588
 589         led_trigger_register_simple(dev_name(&host->class_dev), &host->led);
 590
 591 #ifdef CONFIG_DEBUG_FS
 592         mmc_add_host_debugfs(host);
 593 #endif
 594
 595         mmc_start_host(host);
 596         return 0;
 597 }
 598
 599 EXPORT_SYMBOL(mmc_add_host);
 600
 601 /**
 602  *      mmc_remove_host - remove host hardware
 603  *      @host: mmc host
 604  *
 605  *      Unregister and remove all cards associated with this host,
 606  *      and power down the MMC bus. No new requests will be issued
 607  *      after this function has returned.
 608  */
 609 void mmc_remove_host(struct mmc_host *host)
 610 {
 611         mmc_stop_host(host);
 612
 613 #ifdef CONFIG_DEBUG_FS
 614         mmc_remove_host_debugfs(host);
 615 #endif
 616
 617         device_del(&host->class_dev);
 618
 619         led_trigger_unregister_simple(host->led);
 620 }
 621
 622 EXPORT_SYMBOL(mmc_remove_host);
 623
 624 /**
 625  *      mmc_free_host - free the host structure
 626  *      @host: mmc host
 627  *
 628  *      Free the host once all references to it have been dropped.
 629  */
 630 void mmc_free_host(struct mmc_host *host)
 631 {
 632         mmc_pwrseq_free(host);
 633         put_device(&host->class_dev);
 634 }
 635
 636 EXPORT_SYMBOL(mmc_free_host);