/* * linux/drivers/mmc/core/host.c * * Copyright (C) 2003 Russell King, All Rights Reserved. * Copyright (C) 2007-2008 Pierre Ossman * Copyright (C) 2010 Linus Walleij * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * MMC host class device management */ #include #include #include #include #include #include #include #include #include #include #include #include #include "core.h" #include "crypto.h" #include "host.h" #include "slot-gpio.h" #include "pwrseq.h" #include "sdio_ops.h" #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev) #define MMC_DEVFRQ_DEFAULT_UP_THRESHOLD 35 #define MMC_DEVFRQ_DEFAULT_DOWN_THRESHOLD 5 #define MMC_DEVFRQ_DEFAULT_POLLING_MSEC 100 static DEFINE_IDA(mmc_host_ida); static void mmc_host_classdev_release(struct device *dev) { struct mmc_host *host = cls_dev_to_mmc_host(dev); ida_simple_remove(&mmc_host_ida, host->index); kfree(host); } static int mmc_host_prepare(struct device *dev) { /* * Since mmc_host is a virtual device, we don't have to do anything. * If we return a positive value, the pm framework will consider that * the runtime suspend and system suspend of this device is same and * will set direct_complete flag as true. We don't want this as the * mmc_host always has positive disable_depth and setting the flag * will not speed up the suspend process. * So return 0. */ return 0; } static const struct dev_pm_ops mmc_pm_ops = { .prepare = mmc_host_prepare, }; static struct class mmc_host_class = { .name = "mmc_host", .dev_release = mmc_host_classdev_release, .pm = &mmc_pm_ops, }; int mmc_register_host_class(void) { return class_register(&mmc_host_class); } void mmc_unregister_host_class(void) { class_unregister(&mmc_host_class); } void mmc_retune_enable(struct mmc_host *host) { host->can_retune = 1; if (host->retune_period) mod_timer(&host->retune_timer, jiffies + host->retune_period * HZ); } /* * Pause re-tuning for a small set of operations. The pause begins after the * next command. */ void mmc_retune_pause(struct mmc_host *host) { if (!host->retune_paused) { host->retune_paused = 1; mmc_retune_hold(host); } } EXPORT_SYMBOL(mmc_retune_pause); void mmc_retune_unpause(struct mmc_host *host) { if (host->retune_paused) { host->retune_paused = 0; mmc_retune_release(host); } } EXPORT_SYMBOL(mmc_retune_unpause); void mmc_retune_disable(struct mmc_host *host) { mmc_retune_unpause(host); host->can_retune = 0; del_timer_sync(&host->retune_timer); host->retune_now = 0; host->need_retune = 0; } void mmc_retune_timer_stop(struct mmc_host *host) { del_timer_sync(&host->retune_timer); } EXPORT_SYMBOL(mmc_retune_timer_stop); void mmc_retune_hold(struct mmc_host *host) { if (!host->hold_retune) host->retune_now = 1; host->hold_retune += 1; } void mmc_retune_release(struct mmc_host *host) { if (host->hold_retune) host->hold_retune -= 1; else WARN_ON(1); } EXPORT_SYMBOL(mmc_retune_release); int mmc_retune(struct mmc_host *host) { bool return_to_hs400 = false; int err; if (host->retune_now) host->retune_now = 0; else return 0; if (!host->need_retune || host->doing_retune || !host->card || mmc_card_hs400es(host->card) || (host->ios.clock <= MMC_HIGH_DDR_MAX_DTR)) return 0; host->need_retune = 0; host->doing_retune = 1; if (host->ios.timing == MMC_TIMING_MMC_HS400) { err = mmc_hs400_to_hs200(host->card); if (err) goto out; return_to_hs400 = true; } /* * Timing should be adjusted to the HS400 target * operation frequency for tuning process. * Similar handling is also done in mmc_hs200_tuning() * This is handled properly in sdhci-msm.c from msm-5.4 onwards. */ if (host->card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400 && host->ios.bus_width == MMC_BUS_WIDTH_8) mmc_set_timing(host, MMC_TIMING_MMC_HS400); err = mmc_execute_tuning(host->card); if (err) goto out; if (return_to_hs400) err = mmc_hs200_to_hs400(host->card); out: host->doing_retune = 0; return err; } /** * mmc_host_may_gate_card - check if this card may be gated * @card: card to check. */ bool mmc_host_may_gate_card(struct mmc_card *card) { /* If there is no card we may gate it */ if (!card) return true; /* * SDIO3.0 card allows the clock to be gated off so check if * that is the case or not */ if (mmc_card_sdio(card) && card->cccr.async_intr_sup) return true; /* * Don't gate SDIO cards! These need to be clocked at all times * since they may be independent systems generating interrupts * and other events. The clock requests counter from the core will * go down to zero since the core does not need it, but we will not * gate the clock, because there is somebody out there that may still * be using it. */ return !(card->quirks & MMC_QUIRK_BROKEN_CLK_GATING); } static void mmc_retune_timer(struct timer_list *t) { struct mmc_host *host = from_timer(host, t, retune_timer); mmc_retune_needed(host); } /** * mmc_of_parse() - parse host's device-tree node * @host: host whose node should be parsed. * * To keep the rest of the MMC subsystem unaware of whether DT has been * used to to instantiate and configure this host instance or not, we * parse the properties and set respective generic mmc-host flags and * parameters. */ int mmc_of_parse(struct mmc_host *host) { struct device *dev = host->parent; u32 bus_width, drv_type, cd_debounce_delay_ms; int ret; bool cd_cap_invert, cd_gpio_invert = false; bool ro_cap_invert, ro_gpio_invert = false; if (!dev || !dev_fwnode(dev)) return 0; /* "bus-width" is translated to MMC_CAP_*_BIT_DATA flags */ if (device_property_read_u32(dev, "bus-width", &bus_width) < 0) { dev_dbg(host->parent, "\"bus-width\" property is missing, assuming 1 bit.\n"); bus_width = 1; } switch (bus_width) { case 8: host->caps |= MMC_CAP_8_BIT_DATA; /* Hosts capable of 8-bit transfers can also do 4 bits */ case 4: host->caps |= MMC_CAP_4_BIT_DATA; break; case 1: break; default: dev_err(host->parent, "Invalid \"bus-width\" value %u!\n", bus_width); return -EINVAL; } /* f_max is obtained from the optional "max-frequency" property */ device_property_read_u32(dev, "max-frequency", &host->f_max); /* * Configure CD and WP pins. They are both by default active low to * match the SDHCI spec. If GPIOs are provided for CD and / or WP, the * mmc-gpio helpers are used to attach, configure and use them. If * polarity inversion is specified in DT, one of MMC_CAP2_CD_ACTIVE_HIGH * and MMC_CAP2_RO_ACTIVE_HIGH capability-2 flags is set. If the * "broken-cd" property is provided, the MMC_CAP_NEEDS_POLL capability * is set. If the "non-removable" property is found, the * MMC_CAP_NONREMOVABLE capability is set and no card-detection * configuration is performed. */ /* Parse Card Detection */ if (device_property_read_bool(dev, "non-removable")) { host->caps |= MMC_CAP_NONREMOVABLE; } else { cd_cap_invert = device_property_read_bool(dev, "cd-inverted"); if (device_property_read_u32(dev, "cd-debounce-delay-ms", &cd_debounce_delay_ms)) cd_debounce_delay_ms = 200; if (device_property_read_bool(dev, "broken-cd")) host->caps |= MMC_CAP_NEEDS_POLL; ret = mmc_gpiod_request_cd(host, "cd", 0, true, cd_debounce_delay_ms * 1000, &cd_gpio_invert); if (!ret) dev_info(host->parent, "Got CD GPIO\n"); else if (ret != -ENOENT && ret != -ENOSYS) return ret; /* * There are two ways to flag that the CD line is inverted: * through the cd-inverted flag and by the GPIO line itself * being inverted from the GPIO subsystem. This is a leftover * from the times when the GPIO subsystem did not make it * possible to flag a line as inverted. * * If the capability on the host AND the GPIO line are * both inverted, the end result is that the CD line is * not inverted. */ if (cd_cap_invert ^ cd_gpio_invert) host->caps2 |= MMC_CAP2_CD_ACTIVE_HIGH; } /* Parse Write Protection */ ro_cap_invert = device_property_read_bool(dev, "wp-inverted"); ret = mmc_gpiod_request_ro(host, "wp", 0, false, 0, &ro_gpio_invert); if (!ret) dev_info(host->parent, "Got WP GPIO\n"); else if (ret != -ENOENT && ret != -ENOSYS) return ret; if (device_property_read_bool(dev, "disable-wp")) host->caps2 |= MMC_CAP2_NO_WRITE_PROTECT; /* See the comment on CD inversion above */ if (ro_cap_invert ^ ro_gpio_invert) host->caps2 |= MMC_CAP2_RO_ACTIVE_HIGH; if (device_property_read_bool(dev, "cap-sd-highspeed")) host->caps |= MMC_CAP_SD_HIGHSPEED; if (device_property_read_bool(dev, "cap-mmc-highspeed")) host->caps |= MMC_CAP_MMC_HIGHSPEED; if (device_property_read_bool(dev, "sd-uhs-sdr12")) host->caps |= MMC_CAP_UHS_SDR12; if (device_property_read_bool(dev, "sd-uhs-sdr25")) host->caps |= MMC_CAP_UHS_SDR25; if (device_property_read_bool(dev, "sd-uhs-sdr50")) host->caps |= MMC_CAP_UHS_SDR50; if (device_property_read_bool(dev, "sd-uhs-sdr104")) host->caps |= MMC_CAP_UHS_SDR104; if (device_property_read_bool(dev, "sd-uhs-ddr50")) host->caps |= MMC_CAP_UHS_DDR50; if (device_property_read_bool(dev, "cap-power-off-card")) host->caps |= MMC_CAP_POWER_OFF_CARD; if (device_property_read_bool(dev, "cap-mmc-hw-reset")) host->caps |= MMC_CAP_HW_RESET; if (device_property_read_bool(dev, "cap-sdio-irq")) host->caps |= MMC_CAP_SDIO_IRQ; if (device_property_read_bool(dev, "full-pwr-cycle")) host->caps2 |= MMC_CAP2_FULL_PWR_CYCLE; if (device_property_read_bool(dev, "keep-power-in-suspend")) host->pm_caps |= MMC_PM_KEEP_POWER; if (device_property_read_bool(dev, "wakeup-source") || device_property_read_bool(dev, "enable-sdio-wakeup")) /* legacy */ host->pm_caps |= MMC_PM_WAKE_SDIO_IRQ; if (device_property_read_bool(dev, "mmc-ddr-3_3v")) host->caps |= MMC_CAP_3_3V_DDR; if (device_property_read_bool(dev, "mmc-ddr-1_8v")) host->caps |= MMC_CAP_1_8V_DDR; if (device_property_read_bool(dev, "mmc-ddr-1_2v")) host->caps |= MMC_CAP_1_2V_DDR; if (device_property_read_bool(dev, "mmc-hs200-1_8v")) host->caps2 |= MMC_CAP2_HS200_1_8V_SDR; if (device_property_read_bool(dev, "mmc-hs200-1_2v")) host->caps2 |= MMC_CAP2_HS200_1_2V_SDR; if (device_property_read_bool(dev, "mmc-hs400-1_8v")) host->caps2 |= MMC_CAP2_HS400_1_8V | MMC_CAP2_HS200_1_8V_SDR; if (device_property_read_bool(dev, "mmc-hs400-1_2v")) host->caps2 |= MMC_CAP2_HS400_1_2V | MMC_CAP2_HS200_1_2V_SDR; if (device_property_read_bool(dev, "mmc-hs400-enhanced-strobe")) host->caps2 |= MMC_CAP2_HS400_ES; if (device_property_read_bool(dev, "no-sdio")) host->caps2 |= MMC_CAP2_NO_SDIO; if (device_property_read_bool(dev, "no-sd")) host->caps2 |= MMC_CAP2_NO_SD; if (device_property_read_bool(dev, "no-mmc")) host->caps2 |= MMC_CAP2_NO_MMC; /* Must be after "non-removable" check */ if (device_property_read_u32(dev, "fixed-emmc-driver-type", &drv_type) == 0) { if (host->caps & MMC_CAP_NONREMOVABLE) host->fixed_drv_type = drv_type; else dev_err(host->parent, "can't use fixed driver type, media is removable\n"); } host->dsr_req = !device_property_read_u32(dev, "dsr", &host->dsr); if (host->dsr_req && (host->dsr & ~0xffff)) { dev_err(host->parent, "device tree specified broken value for DSR: 0x%x, ignoring\n", host->dsr); host->dsr_req = 0; } device_property_read_u32(dev, "post-power-on-delay-ms", &host->ios.power_delay_ms); return mmc_pwrseq_alloc(host); } EXPORT_SYMBOL(mmc_of_parse); /** * mmc_alloc_host - initialise the per-host structure. * @extra: sizeof private data structure * @dev: pointer to host device model structure * * Initialise the per-host structure. */ struct mmc_host *mmc_alloc_host(int extra, struct device *dev) { int err; struct mmc_host *host; host = kzalloc(sizeof(struct mmc_host) + extra, GFP_KERNEL); if (!host) return NULL; /* scanning will be enabled when we're ready */ host->rescan_disable = 1; err = ida_simple_get(&mmc_host_ida, 0, 0, GFP_KERNEL); if (err < 0) { kfree(host); return NULL; } host->index = err; dev_set_name(&host->class_dev, "mmc%d", host->index); host->parent = dev; host->class_dev.parent = dev; host->class_dev.class = &mmc_host_class; device_initialize(&host->class_dev); device_enable_async_suspend(&host->class_dev); if (mmc_gpio_alloc(host)) { put_device(&host->class_dev); return NULL; } spin_lock_init(&host->lock); atomic_set(&host->active_reqs, 0); init_waitqueue_head(&host->wq); INIT_DELAYED_WORK(&host->detect, mmc_rescan); INIT_DELAYED_WORK(&host->sdio_irq_work, sdio_irq_work); timer_setup(&host->retune_timer, mmc_retune_timer, 0); #ifdef CONFIG_EMMC_SDCARD_OPTIMIZE host->detect_change_retry = 5; #endif /* CONFIG_EMMC_SDCARD_OPTIMIZE */ /* * By default, hosts do not support SGIO or large requests. * They have to set these according to their abilities. */ host->max_segs = 1; host->max_seg_size = PAGE_SIZE; host->max_req_size = PAGE_SIZE; host->max_blk_size = 512; host->max_blk_count = PAGE_SIZE / 512; host->fixed_drv_type = -EINVAL; host->ios.power_delay_ms = 10; return host; } EXPORT_SYMBOL(mmc_alloc_host); static ssize_t enable_show(struct device *dev, struct device_attribute *attr, char *buf) { struct mmc_host *host = cls_dev_to_mmc_host(dev); if (!host) return -EINVAL; return snprintf(buf, PAGE_SIZE, "%d\n", mmc_can_scale_clk(host)); } static ssize_t enable_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct mmc_host *host = cls_dev_to_mmc_host(dev); unsigned long value; if (!host || !host->card || kstrtoul(buf, 0, &value)) return -EINVAL; mmc_get_card(host->card, NULL); if (!value) { /* Suspend the clock scaling and mask host capability */ if (host->clk_scaling.enable) mmc_suspend_clk_scaling(host); host->clk_scaling.enable = false; host->caps2 &= ~MMC_CAP2_CLK_SCALE; host->clk_scaling.state = MMC_LOAD_HIGH; /* Set to max. frequency when disabling */ mmc_clk_update_freq(host, host->card->clk_scaling_highest, host->clk_scaling.state); } else if (value) { /* Unmask host capability and resume scaling */ host->caps2 |= MMC_CAP2_CLK_SCALE; if (!host->clk_scaling.enable) { host->clk_scaling.enable = true; mmc_resume_clk_scaling(host); } } mmc_put_card(host->card, NULL); return count; } static ssize_t up_threshold_show(struct device *dev, struct device_attribute *attr, char *buf) { struct mmc_host *host = cls_dev_to_mmc_host(dev); if (!host) return -EINVAL; return snprintf(buf, PAGE_SIZE, "%d\n", host->clk_scaling.upthreshold); } #define MAX_PERCENTAGE 100 static ssize_t up_threshold_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct mmc_host *host = cls_dev_to_mmc_host(dev); unsigned long value; if (!host || kstrtoul(buf, 0, &value) || (value > MAX_PERCENTAGE)) return -EINVAL; host->clk_scaling.upthreshold = value; pr_debug("%s: clkscale_up_thresh set to %lu\n", mmc_hostname(host), value); return count; } static ssize_t down_threshold_show(struct device *dev, struct device_attribute *attr, char *buf) { struct mmc_host *host = cls_dev_to_mmc_host(dev); if (!host) return -EINVAL; return snprintf(buf, PAGE_SIZE, "%d\n", host->clk_scaling.downthreshold); } static ssize_t down_threshold_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct mmc_host *host = cls_dev_to_mmc_host(dev); unsigned long value; if (!host || kstrtoul(buf, 0, &value) || (value > MAX_PERCENTAGE)) return -EINVAL; host->clk_scaling.downthreshold = value; pr_debug("%s: clkscale_down_thresh set to %lu\n", mmc_hostname(host), value); return count; } static ssize_t polling_interval_show(struct device *dev, struct device_attribute *attr, char *buf) { struct mmc_host *host = cls_dev_to_mmc_host(dev); if (!host) return -EINVAL; return snprintf(buf, PAGE_SIZE, "%lu milliseconds\n", host->clk_scaling.polling_delay_ms); } static ssize_t polling_interval_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { struct mmc_host *host = cls_dev_to_mmc_host(dev); unsigned long value; if (!host || kstrtoul(buf, 0, &value)) return -EINVAL; host->clk_scaling.polling_delay_ms = value; pr_debug("%s: clkscale_polling_delay_ms set to %lu\n", mmc_hostname(host), value); return count; } DEVICE_ATTR_RW(enable); DEVICE_ATTR_RW(polling_interval); DEVICE_ATTR_RW(up_threshold); DEVICE_ATTR_RW(down_threshold); static struct attribute *clk_scaling_attrs[] = { &dev_attr_enable.attr, &dev_attr_up_threshold.attr, &dev_attr_down_threshold.attr, &dev_attr_polling_interval.attr, NULL, }; static struct attribute_group clk_scaling_attr_grp = { .name = "clk_scaling", .attrs = clk_scaling_attrs, }; static int mmc_validate_host_caps(struct mmc_host *host) { if (host->caps & MMC_CAP_SDIO_IRQ && !host->ops->enable_sdio_irq) { dev_warn(host->parent, "missing ->enable_sdio_irq() ops\n"); return -EINVAL; } return 0; } /** * mmc_add_host - initialise host hardware * @host: mmc host * * Register the host with the driver model. The host must be * prepared to start servicing requests before this function * completes. */ int mmc_add_host(struct mmc_host *host) { int err; err = mmc_validate_host_caps(host); if (err) return err; err = device_add(&host->class_dev); if (err) return err; led_trigger_register_simple(dev_name(&host->class_dev), &host->led); host->clk_scaling.upthreshold = MMC_DEVFRQ_DEFAULT_UP_THRESHOLD; host->clk_scaling.downthreshold = MMC_DEVFRQ_DEFAULT_DOWN_THRESHOLD; host->clk_scaling.polling_delay_ms = MMC_DEVFRQ_DEFAULT_POLLING_MSEC; host->clk_scaling.skip_clk_scale_freq_update = false; #ifdef CONFIG_DEBUG_FS mmc_add_host_debugfs(host); #endif #ifdef CONFIG_MMC_IPC_LOGGING host->ipc_log_ctxt = ipc_log_context_create(NUM_LOG_PAGES, dev_name(&host->class_dev), 0); if (!host->ipc_log_ctxt) pr_err("%s: Error getting ipc_log_ctxt\n", __func__); #endif err = sysfs_create_group(&host->class_dev.kobj, &clk_scaling_attr_grp); if (err) pr_err("%s: failed to create clk scale sysfs group with err %d\n", __func__, err); mmc_start_host(host); if (!(host->pm_flags & MMC_PM_IGNORE_PM_NOTIFY)) mmc_register_pm_notifier(host); return 0; } EXPORT_SYMBOL(mmc_add_host); /** * mmc_remove_host - remove host hardware * @host: mmc host * * Unregister and remove all cards associated with this host, * and power down the MMC bus. No new requests will be issued * after this function has returned. */ void mmc_remove_host(struct mmc_host *host) { if (!(host->pm_flags & MMC_PM_IGNORE_PM_NOTIFY)) mmc_unregister_pm_notifier(host); mmc_stop_host(host); #ifdef CONFIG_DEBUG_FS mmc_remove_host_debugfs(host); #endif #ifdef CONFIG_MMC_IPC_LOGGING ipc_log_context_destroy(host->ipc_log_ctxt); host->ipc_log_ctxt = NULL; #endif sysfs_remove_group(&host->class_dev.kobj, &clk_scaling_attr_grp); device_del(&host->class_dev); led_trigger_unregister_simple(host->led); } EXPORT_SYMBOL(mmc_remove_host); /** * mmc_free_host - free the host structure * @host: mmc host * * Free the host once all references to it have been dropped. */ void mmc_free_host(struct mmc_host *host) { cancel_delayed_work_sync(&host->detect); mmc_crypto_free_host(host); mmc_pwrseq_free(host); put_device(&host->class_dev); } EXPORT_SYMBOL(mmc_free_host);