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