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