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