| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Message-ID: <36492d8e-9cc7-0462-5366-3612a4214136@codeaurora.org>
Date: Mon, 23 Jul 2018 15:31:11 +0530
From: Vijay Viswanath <vviswana@...eaurora.org>
To: Sayali Lokhande <sayalil@...eaurora.org>, adrian.hunter@...el.com,
ulf.hansson@...aro.org, robh+dt@...nel.org, mark.rutland@....com
Cc: linux-mmc@...r.kernel.org, linux-kernel@...r.kernel.org,
shawn.lin@...k-chips.com, linux-arm-msm@...r.kernel.org,
georgi.djakov@...aro.org, devicetree@...r.kernel.org,
asutoshd@...eaurora.org, stummala@...eaurora.org,
venkatg@...eaurora.org, bjorn.andersson@...aro.org,
riteshh@...eaurora.org, vbadigan@...eaurora.org,
Talel Shenhar <tatias@...eaurora.org>
Subject: Re: [PATCH RFC 2/7] mmc: core: devfreq: Add devfreq based clock
scaling support
Hi Sayali,
On 7/13/2018 3:22 PM, Sayali Lokhande wrote:
> This change adds the use of devfreq to MMC.
> Both eMMC and SD card will use it.
> For some workloads, such as video playback, it isn't
> necessary for these cards to run at high speed.
> Running at lower frequency, for example 52MHz, in such
> cases can still meet the deadlines for data transfers.
> Scaling down the clock frequency dynamically has power
> savings not only because the bus is running at lower frequency
> but also has an advantage of scaling down the system core
> voltage, if supported.
> Provide an ondemand clock scaling support similar to the
> cpufreq ondemand governor having two thresholds,
> up_threshold and down_threshold to decide whether to
> increase the frequency or scale it down respectively.
> The sampling interval is in the order of milliseconds.
> If sampling interval is too low, frequent switching of
> frequencies can lead to high power consumption and if
> sampling interval is too high, the clock scaling logic
> would take long time to realize that the underlying
> hardware (controller and card) is busy and scale up
> the clocks.
>
> Signed-off-by: Talel Shenhar <tatias@...eaurora.org>
> Signed-off-by: Sayali Lokhande <sayalil@...eaurora.org>
> ---
> .../devicetree/bindings/mmc/sdhci-msm.txt | 10 +
> drivers/mmc/core/core.c | 560 +++++++++++++++++++++
> drivers/mmc/core/core.h | 7 +
> drivers/mmc/core/debugfs.c | 46 ++
> drivers/mmc/core/host.c | 8 +
> drivers/mmc/core/mmc.c | 200 +++++++-
> drivers/mmc/core/sd.c | 72 ++-
> drivers/mmc/host/sdhci-msm.c | 37 ++
> drivers/mmc/host/sdhci-pltfm.c | 11 +
> drivers/mmc/host/sdhci.c | 27 +
> drivers/mmc/host/sdhci.h | 8 +
> include/linux/mmc/card.h | 5 +
> include/linux/mmc/host.h | 70 +++
> 13 files changed, 1059 insertions(+), 2 deletions(-)
>
> diff --git a/Documentation/devicetree/bindings/mmc/sdhci-msm.txt b/Documentation/devicetree/bindings/mmc/sdhci-msm.txt
> index 502b3b8..bd8470a 100644
> --- a/Documentation/devicetree/bindings/mmc/sdhci-msm.txt
> +++ b/Documentation/devicetree/bindings/mmc/sdhci-msm.txt
> @@ -26,6 +26,15 @@ Required properties:
> "cal" - reference clock for RCLK delay calibration (optional)
> "sleep" - sleep clock for RCLK delay calibration (optional)
>
> +Optional Properties:
> +- qcom,devfreq,freq-table - specifies supported frequencies for clock scaling.
> + Clock scaling logic shall toggle between these frequencies based
> + on card load. In case the defined frequencies are over or below
> + the supported card frequencies, they will be overridden
> + during card init. In case this entry is not supplied,
> + the driver will construct one based on the card
> + supported max and min frequencies.
> + The frequencies must be ordered from lowest to highest.
> Example:
>
> sdhc_1: sdhci@...24900 {
> @@ -43,6 +52,7 @@ Example:
>
> clocks = <&gcc GCC_SDCC1_APPS_CLK>, <&gcc GCC_SDCC1_AHB_CLK>;
> clock-names = "core", "iface";
> + qcom,devfreq,freq-table = <52000000 200000000>;
> };
>
> sdhc_2: sdhci@...a4900 {
> diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
> index 281826d..0eaee42 100644
> --- a/drivers/mmc/core/core.c
> +++ b/drivers/mmc/core/core.c
> @@ -14,6 +14,7 @@
> #include <linux/init.h>
> #include <linux/interrupt.h>
> #include <linux/completion.h>
> +#include <linux/devfreq.h>
> #include <linux/device.h>
> #include <linux/delay.h>
> #include <linux/pagemap.h>
> @@ -112,6 +113,556 @@ static inline void mmc_should_fail_request(struct mmc_host *host,
>
> #endif /* CONFIG_FAIL_MMC_REQUEST */
>
> +static bool mmc_is_data_request(struct mmc_request *mmc_request)
> +{
> + switch (mmc_request->cmd->opcode) {
> + case MMC_READ_SINGLE_BLOCK:
> + case MMC_READ_MULTIPLE_BLOCK:
> + case MMC_WRITE_BLOCK:
> + case MMC_WRITE_MULTIPLE_BLOCK:
> + return true;
> + default:
> + return false;
> + }
> +}
> +
> +static void mmc_clk_scaling_start_busy(struct mmc_host *host, bool lock_needed)
> +{
> + struct mmc_devfeq_clk_scaling *clk_scaling = &host->clk_scaling;
> +
> + if (!clk_scaling->enable)
> + return;
> +
> + if (lock_needed)
> + spin_lock_bh(&clk_scaling->lock);
> +
> + clk_scaling->start_busy = ktime_get();
> + clk_scaling->is_busy_started = true;
> +
> + if (lock_needed)
> + spin_unlock_bh(&clk_scaling->lock);
> +}
> +
> +static void mmc_clk_scaling_stop_busy(struct mmc_host *host, bool lock_needed)
> +{
> + struct mmc_devfeq_clk_scaling *clk_scaling = &host->clk_scaling;
> +
> + if (!clk_scaling->enable)
> + return;
> +
> + if (lock_needed)
> + spin_lock_bh(&clk_scaling->lock);
> +
> + if (!clk_scaling->is_busy_started) {
> + WARN_ON(1);
> + goto out;
> + }
> +
> + clk_scaling->total_busy_time_us +=
> + ktime_to_us(ktime_sub(ktime_get(),
> + clk_scaling->start_busy));
> + pr_debug("%s: accumulated busy time is %lu usec\n",
> + mmc_hostname(host), clk_scaling->total_busy_time_us);
> + clk_scaling->is_busy_started = false;
> +
> +out:
> + if (lock_needed)
> + spin_unlock_bh(&clk_scaling->lock);
> +}
> +
> +/**
> + * mmc_can_scale_clk() - Check clock scaling capability
> + * @host: pointer to mmc host structure
> + */
> +bool mmc_can_scale_clk(struct mmc_host *host)
> +{
> + if (!host) {
> + pr_err("bad host parameter\n");
> + WARN_ON(1);
> + return false;
> + }
> +
> + return host->caps2 & MMC_CAP2_CLK_SCALE;
> +}
> +EXPORT_SYMBOL(mmc_can_scale_clk);
> +
> +static int mmc_devfreq_get_dev_status(struct device *dev,
> + struct devfreq_dev_status *status)
> +{
> + struct mmc_host *host = container_of(dev, struct mmc_host, class_dev);
> + struct mmc_devfeq_clk_scaling *clk_scaling;
> +
> + if (!host) {
> + pr_err("bad host parameter\n");
> + WARN_ON(1);
> + return -EINVAL;
> + }
> +
> + clk_scaling = &host->clk_scaling;
> +
> + if (!clk_scaling->enable)
> + return 0;
> +
> + spin_lock_bh(&clk_scaling->lock);
> +
> + /* accumulate the busy time of ongoing work */
> + memset(status, 0, sizeof(*status));
> + if (clk_scaling->is_busy_started) {
> + mmc_clk_scaling_stop_busy(host, false);
> + mmc_clk_scaling_start_busy(host, false);
> + }
> +
> + status->busy_time = clk_scaling->total_busy_time_us;
> + status->total_time = ktime_to_us(ktime_sub(ktime_get(),
> + clk_scaling->measure_interval_start));
> + clk_scaling->total_busy_time_us = 0;
> + status->current_frequency = clk_scaling->curr_freq;
> + clk_scaling->measure_interval_start = ktime_get();
> +
> + pr_debug("%s: status: load = %lu%% - total_time=%lu busy_time = %lu, clk=%lu\n",
> + mmc_hostname(host),
> + (status->busy_time*100)/status->total_time,
> + status->total_time, status->busy_time,
> + status->current_frequency);
> +
> + spin_unlock_bh(&clk_scaling->lock);
> +
> + return 0;
> +}
> +
> +static bool mmc_is_valid_state_for_clk_scaling(struct mmc_host *host)
> +{
> + struct mmc_card *card = host->card;
> + u32 status;
> +
> + /*
> + * If the current partition type is RPMB, clock switching may not
> + * work properly as sending tuning command (CMD21) is illegal in
> + * this mode.
> + */
> + if (!card || (mmc_card_mmc(card) &&
> + (card->part_curr == EXT_CSD_PART_CONFIG_ACC_RPMB ||
> + mmc_card_doing_bkops(card))))
> + return false;
> +
> + if (mmc_send_status(card, &status)) {
> + pr_err("%s: Get card status fail\n", mmc_hostname(card->host));
> + return false;
> + }
> +
> + return R1_CURRENT_STATE(status) == R1_STATE_TRAN;
> +}
> +
> +int mmc_clk_update_freq(struct mmc_host *host,
> + unsigned long freq, enum mmc_load state)
> +{
> + int err = 0;
> +
> + if (!host) {
> + pr_err("bad host parameter\n");
> + WARN_ON(1);
> + return -EINVAL;
> + }
> +
> + /* make sure the card supports the frequency we want */
> + if (unlikely(freq > host->card->clk_scaling_highest)) {
> + freq = host->card->clk_scaling_highest;
> + pr_warn("%s: %s: frequency was overridden to %lu\n",
> + mmc_hostname(host), __func__,
> + host->card->clk_scaling_highest);
> + }
> +
> + if (unlikely(freq < host->card->clk_scaling_lowest)) {
> + freq = host->card->clk_scaling_lowest;
> + pr_warn("%s: %s: frequency was overridden to %lu\n",
> + mmc_hostname(host), __func__,
> + host->card->clk_scaling_lowest);
> + }
> +
> + if (freq == host->clk_scaling.curr_freq)
> + goto out;
> +
> + if (host->ops->notify_load) {
> + err = host->ops->notify_load(host, state);
> + if (err) {
> + pr_err("%s: %s: fail on notify_load\n",
> + mmc_hostname(host), __func__);
> + goto out;
> + }
> + }
> +
> + if (!mmc_is_valid_state_for_clk_scaling(host)) {
> + pr_debug("%s: invalid state for clock scaling - skipping",
> + mmc_hostname(host));
> + goto invalid_state;
> + }
> +
> + err = host->bus_ops->change_bus_speed(host, &freq);
> + if (!err)
> + host->clk_scaling.curr_freq = freq;
> + else
> + pr_err("%s: %s: failed (%d) at freq=%lu\n",
> + mmc_hostname(host), __func__, err, freq);
> +
> +invalid_state:
> + if (err) {
> + /* restore previous state */
> + if (host->ops->notify_load)
> + if (host->ops->notify_load(host,
> + host->clk_scaling.state))
> + pr_err("%s: %s: fail on notify_load restore\n",
> + mmc_hostname(host), __func__);
> + }
> +out:
> + return err;
> +}
> +EXPORT_SYMBOL(mmc_clk_update_freq);
> +
> +static int mmc_devfreq_set_target(struct device *dev,
> + unsigned long *freq, u32 devfreq_flags)
> +{
> + struct mmc_host *host = container_of(dev, struct mmc_host, class_dev);
> + struct mmc_devfeq_clk_scaling *clk_scaling;
> + int err = 0;
> + int abort;
> + unsigned long pflags = current->flags;
> +
> + /* Ensure scaling would happen even in memory pressure conditions */
> + current->flags |= PF_MEMALLOC;
> +
> + if (!(host && freq)) {
> + pr_err("%s: unexpected host/freq parameter\n", __func__);
> + err = -EINVAL;
> + goto out;
> + }
> +
> + clk_scaling = &host->clk_scaling;
> +
> + if (!clk_scaling->enable)
> + goto out;
> +
> + pr_debug("%s: target freq = %lu (%s)\n", mmc_hostname(host),
> + *freq, current->comm);
> +
> + if ((clk_scaling->curr_freq == *freq) ||
> + clk_scaling->skip_clk_scale_freq_update)
> + goto out;
> +
Suppose devfreq issued a low_freq request while mmc is handling a
request already issued to card (so mmc host is claimed by issuing
context). So we will set target freq to LOW_FREQ and quit from here.
Now, if devfreq comes again and issues a HIGH_FREQ request (before mmc
thread had a chance to change the freq to LOW in mmc_deferred_scaling),
we will skip this devfreq request (since current freq is high already).
Then, when mmc thread comes, it will execute deferred scaling to LOW_FREQ.
How about comparing *freq with clk_scaling->target_freq ?
> + /* No need to scale the clocks if they are gated */
> + if (!host->ios.clock)
> + goto out;
> +
> + spin_lock_bh(&clk_scaling->lock);
> + if (clk_scaling->clk_scaling_in_progress) {
> + pr_debug("%s: clocks scaling is already in-progress by mmc thread\n",
> + mmc_hostname(host));
> + spin_unlock_bh(&clk_scaling->lock);
> + goto out;
> + }
> + clk_scaling->need_freq_change = true;
> + clk_scaling->target_freq = *freq;
> + clk_scaling->state = *freq < clk_scaling->curr_freq ?
> + MMC_LOAD_LOW : MMC_LOAD_HIGH;
> + spin_unlock_bh(&clk_scaling->lock);
> +
> + abort = __mmc_claim_host(host, NULL, &clk_scaling->devfreq_abort);
> + if (abort)
> + goto out;
> +
> + /*
> + * In case we were able to claim host there is no need to
> + * defer the frequency change. It will be done now
> + */
> + clk_scaling->need_freq_change = false;
> +
> + err = mmc_clk_update_freq(host, *freq, clk_scaling->state);
> + if (err && err != -EAGAIN) {
> + pr_err("%s: clock scale to %lu failed with error %d\n",
> + mmc_hostname(host), *freq, err);
> + } else {
> + pr_debug("%s: clock change to %lu finished successfully (%s)\n",
> + mmc_hostname(host), *freq, current->comm);
> + }
> +
> + mmc_release_host(host);
> +out:
> + current->flags &= ~PF_MEMALLOC;
> + current->flags |= pflags & PF_MEMALLOC;
> + return err;
> +}
> +
> +/**
> + * mmc_deferred_scaling() - scale clocks from data path (mmc thread context)
> + * @host: pointer to mmc host structure
> + *
> + * This function does clock scaling in case "need_freq_change" flag was set
> + * by the clock scaling logic.
> + */
> +void mmc_deferred_scaling(struct mmc_host *host)
> +{
> + unsigned long target_freq;
> + int err;
> +
> + if (!host->clk_scaling.enable)
> + return;
> +
> + spin_lock_bh(&host->clk_scaling.lock);
> +
> + if (host->clk_scaling.clk_scaling_in_progress ||
> + !(host->clk_scaling.need_freq_change)) {
> + spin_unlock_bh(&host->clk_scaling.lock);
> + return;
> + }
> +
> +
> + atomic_inc(&host->clk_scaling.devfreq_abort);
> + target_freq = host->clk_scaling.target_freq;
> + host->clk_scaling.clk_scaling_in_progress = true;
> + host->clk_scaling.need_freq_change = false;
> + spin_unlock_bh(&host->clk_scaling.lock);
> + pr_debug("%s: doing deferred frequency change (%lu) (%s)\n",
> + mmc_hostname(host),
> + target_freq, current->comm);
> +
> + err = mmc_clk_update_freq(host, target_freq,
> + host->clk_scaling.state);
> + if (err && err != -EAGAIN) {
> + pr_err("%s: failed on deferred scale clocks (%d)\n",
> + mmc_hostname(host), err);
> + } else {
> + pr_debug("%s: clocks were successfully scaled to %lu (%s)\n",
> + mmc_hostname(host),
> + target_freq, current->comm);
> + }
> + host->clk_scaling.clk_scaling_in_progress = false;
> + atomic_dec(&host->clk_scaling.devfreq_abort);
> +}
> +EXPORT_SYMBOL(mmc_deferred_scaling);
> +
> +static int mmc_devfreq_create_freq_table(struct mmc_host *host)
> +{
> + int i;
> + struct mmc_devfeq_clk_scaling *clk_scaling = &host->clk_scaling;
> +
> + pr_debug("%s: supported: lowest=%lu, highest=%lu\n",
> + mmc_hostname(host),
> + host->card->clk_scaling_lowest,
> + host->card->clk_scaling_highest);
> +
> + /*
> + * Create the frequency table and initialize it with default values.
> + * Initialize it with platform specific frequencies if the frequency
> + * table supplied by platform driver is present, otherwise initialize
> + * it with min and max frequencies supported by the card.
> + */
> + if (!clk_scaling->freq_table) {
> + if (clk_scaling->pltfm_freq_table_sz)
> + clk_scaling->freq_table_sz =
> + clk_scaling->pltfm_freq_table_sz;
> + else
> + clk_scaling->freq_table_sz = 2;
> +
> + clk_scaling->freq_table = kzalloc(
> + (clk_scaling->freq_table_sz *
> + sizeof(*(clk_scaling->freq_table))), GFP_KERNEL);
> + if (!clk_scaling->freq_table)
> + return -ENOMEM;
> +
> + if (clk_scaling->pltfm_freq_table) {
> + memcpy(clk_scaling->freq_table,
> + clk_scaling->pltfm_freq_table,
> + (clk_scaling->pltfm_freq_table_sz *
> + sizeof(*(clk_scaling->pltfm_freq_table))));
> + } else {
> + pr_debug("%s: no frequency table defined - setting default\n",
> + mmc_hostname(host));
> + clk_scaling->freq_table[0] =
> + host->card->clk_scaling_lowest;
> + clk_scaling->freq_table[1] =
> + host->card->clk_scaling_highest;
> + goto out;
> + }
> + }
> +
> + if (host->card->clk_scaling_lowest >
> + clk_scaling->freq_table[0])
> + pr_debug("%s: frequency table undershot possible freq\n",
> + mmc_hostname(host));
> +
> + for (i = 0; i < clk_scaling->freq_table_sz; i++) {
> + if (clk_scaling->freq_table[i] <=
> + host->card->clk_scaling_highest)
> + continue;
> + clk_scaling->freq_table[i] =
> + host->card->clk_scaling_highest;
> + clk_scaling->freq_table_sz = i + 1;
> + pr_debug("%s: frequency table overshot possible freq (%d)\n",
> + mmc_hostname(host), clk_scaling->freq_table[i]);
> + break;
> + }
> +
> +out:
> + /**
> + * devfreq requires unsigned long type freq_table while the
> + * freq_table in clk_scaling is un32. Here allocates an individual
> + * memory space for it and release it when exit clock scaling.
> + */
> + clk_scaling->devfreq_profile.freq_table = kzalloc(
> + clk_scaling->freq_table_sz *
> + sizeof(*(clk_scaling->devfreq_profile.freq_table)),
> + GFP_KERNEL);
> + if (!clk_scaling->devfreq_profile.freq_table)
> + return -ENOMEM;
> + clk_scaling->devfreq_profile.max_state = clk_scaling->freq_table_sz;
> +
> + for (i = 0; i < clk_scaling->freq_table_sz; i++) {
> + clk_scaling->devfreq_profile.freq_table[i] =
> + clk_scaling->freq_table[i];
> + pr_debug("%s: freq[%d] = %u\n",
> + mmc_hostname(host), i, clk_scaling->freq_table[i]);
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * mmc_init_devfreq_clk_scaling() - Initialize clock scaling
> + * @host: pointer to mmc host structure
> + *
> + * Initialize clock scaling for supported hosts. It is assumed that the caller
> + * ensure clock is running at maximum possible frequency before calling this
> + * function. Shall use struct devfreq_simple_ondemand_data to configure
> + * governor.
> + */
> +int mmc_init_clk_scaling(struct mmc_host *host)
> +{
> + int err;
> +
> + if (!host || !host->card) {
> + pr_err("%s: unexpected host/card parameters\n",
> + __func__);
> + return -EINVAL;
> + }
> +
> + if (!mmc_can_scale_clk(host) ||
> + !host->bus_ops->change_bus_speed) {
> + pr_debug("%s: clock scaling is not supported\n",
> + mmc_hostname(host));
> + return 0;
> + }
> +
> + pr_debug("registering %s dev (%p) to devfreq",
> + mmc_hostname(host),
> + mmc_classdev(host));
> +
> + if (host->clk_scaling.devfreq) {
> + pr_err("%s: dev is already registered for dev %p\n",
> + mmc_hostname(host),
> + mmc_dev(host));
> + return -EPERM;
> + }
> + spin_lock_init(&host->clk_scaling.lock);
> + atomic_set(&host->clk_scaling.devfreq_abort, 0);
> + host->clk_scaling.curr_freq = host->ios.clock;
> + host->clk_scaling.clk_scaling_in_progress = false;
> + host->clk_scaling.need_freq_change = false;
> + host->clk_scaling.is_busy_started = false;
> +
> + host->clk_scaling.devfreq_profile.polling_ms =
> + host->clk_scaling.polling_delay_ms;
> + host->clk_scaling.devfreq_profile.get_dev_status =
> + mmc_devfreq_get_dev_status;
> + host->clk_scaling.devfreq_profile.target = mmc_devfreq_set_target;
> + host->clk_scaling.devfreq_profile.initial_freq = host->ios.clock;
> +
> + host->clk_scaling.ondemand_gov_data.simple_scaling = true;
> + host->clk_scaling.ondemand_gov_data.upthreshold =
> + host->clk_scaling.upthreshold;
> + host->clk_scaling.ondemand_gov_data.downdifferential =
> + host->clk_scaling.upthreshold - host->clk_scaling.downthreshold;
> +
> + err = mmc_devfreq_create_freq_table(host);
> + if (err) {
> + pr_err("%s: fail to create devfreq frequency table\n",
> + mmc_hostname(host));
> + return err;
> + }
> +
> + pr_debug("%s: adding devfreq with: upthreshold=%u downthreshold=%u polling=%u\n",
> + mmc_hostname(host),
> + host->clk_scaling.ondemand_gov_data.upthreshold,
> + host->clk_scaling.ondemand_gov_data.downdifferential,
> + host->clk_scaling.devfreq_profile.polling_ms);
> + host->clk_scaling.devfreq = devfreq_add_device(
> + mmc_classdev(host),
> + &host->clk_scaling.devfreq_profile,
> + "simple_ondemand",
> + &host->clk_scaling.ondemand_gov_data);
> + if (!host->clk_scaling.devfreq) {
> + pr_err("%s: unable to register with devfreq\n",
> + mmc_hostname(host));
> + return -EPERM;
> + }
> +
> + pr_debug("%s: clk scaling is enabled for device %s (%p) with devfreq %p (clock = %uHz)\n",
> + mmc_hostname(host),
> + dev_name(mmc_classdev(host)),
> + mmc_classdev(host),
> + host->clk_scaling.devfreq,
> + host->ios.clock);
> +
> + host->clk_scaling.enable = true;
> +
> + return err;
> +}
> +EXPORT_SYMBOL(mmc_init_clk_scaling);
> +
> +/**
> + * mmc_exit_devfreq_clk_scaling() - Disable clock scaling
> + * @host: pointer to mmc host structure
> + *
> + * Disable clock scaling permanently.
> + */
> +int mmc_exit_clk_scaling(struct mmc_host *host)
> +{
> + int err;
> +
> + if (!host) {
> + pr_err("%s: bad host parameter\n", __func__);
> + WARN_ON(1);
> + return -EINVAL;
> + }
> +
> + if (!mmc_can_scale_clk(host))
> + return 0;
> +
> + if (!host->clk_scaling.devfreq) {
> + pr_err("%s: %s: no devfreq is assosiated with this device\n",
> + mmc_hostname(host), __func__);
> + return -EPERM;
> + }
> +
> + err = devfreq_remove_device(host->clk_scaling.devfreq);
> + if (err) {
> + pr_err("%s: remove devfreq failed (%d)\n",
> + mmc_hostname(host), err);
> + return err;
> + }
> +
> + kfree(host->clk_scaling.devfreq_profile.freq_table);
> +
> + host->clk_scaling.devfreq = NULL;
> + atomic_set(&host->clk_scaling.devfreq_abort, 1);
> +
> + kfree(host->clk_scaling.freq_table);
> + host->clk_scaling.freq_table = NULL;
> +
> + pr_debug("%s: devfreq was removed\n", mmc_hostname(host));
> +
> + return 0;
> +}
> +EXPORT_SYMBOL(mmc_exit_clk_scaling);
> +
> static inline void mmc_complete_cmd(struct mmc_request *mrq)
> {
> if (mrq->cap_cmd_during_tfr && !completion_done(&mrq->cmd_completion))
> @@ -143,6 +694,9 @@ void mmc_request_done(struct mmc_host *host, struct mmc_request *mrq)
> struct mmc_command *cmd = mrq->cmd;
> int err = cmd->error;
>
> + if (host->clk_scaling.is_busy_started)
> + mmc_clk_scaling_stop_busy(host, true);
> +
> /* Flag re-tuning needed on CRC errors */
> if ((cmd->opcode != MMC_SEND_TUNING_BLOCK &&
> cmd->opcode != MMC_SEND_TUNING_BLOCK_HS200) &&
> @@ -354,6 +908,12 @@ int mmc_start_request(struct mmc_host *host, struct mmc_request *mrq)
> return err;
>
> led_trigger_event(host->led, LED_FULL);
> +
> + if (mmc_is_data_request(mrq)) {
> + mmc_deferred_scaling(host);
> + mmc_clk_scaling_start_busy(host, true);
> + }
> +
> __mmc_start_request(host, mrq);
>
> return 0;
> diff --git a/drivers/mmc/core/core.h b/drivers/mmc/core/core.h
> index 9d8f09a..fc0a9b7 100644
> --- a/drivers/mmc/core/core.h
> +++ b/drivers/mmc/core/core.h
> @@ -34,6 +34,7 @@ struct mmc_bus_ops {
> int (*shutdown)(struct mmc_host *);
> int (*hw_reset)(struct mmc_host *);
> int (*sw_reset)(struct mmc_host *);
> + int (*change_bus_speed)(struct mmc_host *, unsigned long *);
> };
>
> void mmc_attach_bus(struct mmc_host *host, const struct mmc_bus_ops *ops);
> @@ -46,6 +47,8 @@ struct device_node *mmc_of_find_child_device(struct mmc_host *host,
>
> void mmc_set_chip_select(struct mmc_host *host, int mode);
> void mmc_set_clock(struct mmc_host *host, unsigned int hz);
> +int mmc_clk_update_freq(struct mmc_host *host,
> + unsigned long freq, enum mmc_load state);
> void mmc_set_bus_mode(struct mmc_host *host, unsigned int mode);
> void mmc_set_bus_width(struct mmc_host *host, unsigned int width);
> u32 mmc_select_voltage(struct mmc_host *host, u32 ocr);
> @@ -91,6 +94,10 @@ static inline void mmc_delay(unsigned int ms)
> void mmc_add_card_debugfs(struct mmc_card *card);
> void mmc_remove_card_debugfs(struct mmc_card *card);
>
> +extern bool mmc_can_scale_clk(struct mmc_host *host);
> +extern int mmc_init_clk_scaling(struct mmc_host *host);
> +extern int mmc_exit_clk_scaling(struct mmc_host *host);
> +
> int mmc_execute_tuning(struct mmc_card *card);
> int mmc_hs200_to_hs400(struct mmc_card *card);
> int mmc_hs400_to_hs200(struct mmc_card *card);
> diff --git a/drivers/mmc/core/debugfs.c b/drivers/mmc/core/debugfs.c
> index d2275c5..630ca8e 100644
> --- a/drivers/mmc/core/debugfs.c
> +++ b/drivers/mmc/core/debugfs.c
> @@ -225,6 +225,43 @@ static int mmc_clock_opt_set(void *data, u64 val)
> DEFINE_SIMPLE_ATTRIBUTE(mmc_clock_fops, mmc_clock_opt_get, mmc_clock_opt_set,
> "%llu\n");
>
> +#include <linux/delay.h>
> +
> +static int mmc_scale_get(void *data, u64 *val)
> +{
> + struct mmc_host *host = data;
> +
> + *val = host->clk_scaling.curr_freq;
> +
> + return 0;
> +}
> +
> +static int mmc_scale_set(void *data, u64 val)
> +{
> + int err = 0;
> + struct mmc_host *host = data;
> +
> + mmc_claim_host(host);
> +
> + /* change frequency from sysfs manually */
> + err = mmc_clk_update_freq(host, val, host->clk_scaling.state);
> + if (err == -EAGAIN)
> + err = 0;
> + else if (err)
> + pr_err("%s: clock scale to %llu failed with error %d\n",
> + mmc_hostname(host), val, err);
> + else
> + pr_debug("%s: clock change to %llu finished successfully (%s)\n",
> + mmc_hostname(host), val, current->comm);
> +
> + mmc_release_host(host);
> +
> + return err;
> +}
> +
> +DEFINE_SIMPLE_ATTRIBUTE(mmc_scale_fops, mmc_scale_get, mmc_scale_set,
> + "%llu\n");
> +
> void mmc_add_host_debugfs(struct mmc_host *host)
> {
> struct dentry *root;
> @@ -253,6 +290,15 @@ void mmc_add_host_debugfs(struct mmc_host *host)
> &mmc_clock_fops))
> goto err_node;
>
> + if (!debugfs_create_file("scale", 0600, root, host,
> + &mmc_scale_fops))
> + goto err_node;
> +
> + if (!debugfs_create_bool("skip_clk_scale_freq_update",
> + 0600, root,
> + &host->clk_scaling.skip_clk_scale_freq_update))
> + goto err_node;
> +
> #ifdef CONFIG_FAIL_MMC_REQUEST
> if (fail_request)
> setup_fault_attr(&fail_default_attr, fail_request);
> diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
> index abf9e88..1e46aa4 100644
> --- a/drivers/mmc/core/host.c
> +++ b/drivers/mmc/core/host.c
> @@ -32,6 +32,10 @@
> #include "pwrseq.h"
> #include "sdio_ops.h"
>
> +#define MMC_DEVFRQ_DEFAULT_UP_THRESHOLD 35
> +#define MMC_DEVFRQ_DEFAULT_DOWN_THRESHOLD 5
> +#define MMC_DEVFRQ_DEFAULT_POLLING_MSEC 100
> +
> #define cls_dev_to_mmc_host(d) container_of(d, struct mmc_host, class_dev)
>
> static DEFINE_IDA(mmc_host_ida);
> @@ -435,6 +439,10 @@ int mmc_add_host(struct mmc_host *host)
> 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);
> diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
> index 4466f5d..c8aedf3 100644
> --- a/drivers/mmc/core/mmc.c
> +++ b/drivers/mmc/core/mmc.c
> @@ -1526,6 +1526,170 @@ static int mmc_hs200_tuning(struct mmc_card *card)
> }
>
> /*
> + * Scale down from HS400 to HS in order to allow frequency change.
> + * This is needed for cards that doesn't support changing frequency in HS400
> + */
> +static int mmc_scale_low(struct mmc_host *host, unsigned long freq)
> +{
> + int err = 0;
> +
> + mmc_set_timing(host, MMC_TIMING_LEGACY);
> + mmc_set_clock(host, MMC_HIGH_26_MAX_DTR);
> +
> + err = mmc_select_hs(host->card);
> + if (err) {
> + pr_err("%s: %s: scaling low: failed (%d)\n",
> + mmc_hostname(host), __func__, err);
> + return err;
> + }
> +
> + err = mmc_select_bus_width(host->card);
> + if (err < 0) {
> + pr_err("%s: %s: select_bus_width failed(%d)\n",
> + mmc_hostname(host), __func__, err);
> + return err;
> + }
> +
> + mmc_set_clock(host, freq);
> +
> + return 0;
> +}
> +
> +/*
> + * Scale UP from HS to HS200/H400
> + */
> +static int mmc_scale_high(struct mmc_host *host)
> +{
> + int err = 0;
> +
> + if (mmc_card_ddr52(host->card)) {
> + mmc_set_timing(host, MMC_TIMING_LEGACY);
> + mmc_set_clock(host, MMC_HIGH_26_MAX_DTR);
> + }
> +
> + if (!host->card->ext_csd.strobe_support) {
> + if (!(host->card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200)) {
> + pr_err("%s: %s: card does not support HS200\n",
> + mmc_hostname(host), __func__);
> + WARN_ON(1);
> + return -EPERM;
> + }
> +
> + err = mmc_select_hs200(host->card);
> + if (err) {
> + pr_err("%s: %s: selecting HS200 failed (%d)\n",
> + mmc_hostname(host), __func__, err);
> + return err;
> + }
> +
> + mmc_set_bus_speed(host->card);
> +
> + err = mmc_hs200_tuning(host->card);
> + if (err) {
> + pr_err("%s: %s: hs200 tuning failed (%d)\n",
> + mmc_hostname(host), __func__, err);
> + return err;
> + }
> +
> + if (!(host->card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400)) {
> + pr_debug("%s: card does not support HS400\n",
> + mmc_hostname(host));
> + return 0;
> + }
> + }
> +
> + err = mmc_select_hs400(host->card);
> + if (err) {
> + pr_err("%s: %s: select hs400 failed (%d)\n",
> + mmc_hostname(host), __func__, err);
> + return err;
> + }
> +
> + return err;
> +}
> +
> +static int mmc_set_clock_bus_speed(struct mmc_card *card, unsigned long freq)
> +{
> + int err = 0;
> +
> + if (freq == MMC_HS200_MAX_DTR)
> + err = mmc_scale_high(card->host);
> + else
> + err = mmc_scale_low(card->host, freq);
> +
> + return err;
> +}
> +
> +static inline unsigned long mmc_ddr_freq_accommodation(unsigned long freq)
> +{
> + if (freq == MMC_HIGH_DDR_MAX_DTR)
> + return freq;
> +
> + return freq/2;
> +}
> +
> +/**
> + * mmc_change_bus_speed() - Change MMC card bus frequency at runtime
> + * @host: pointer to mmc host structure
> + * @freq: pointer to desired frequency to be set
> + *
> + * Change the MMC card bus frequency at runtime after the card is
> + * initialized. Callers are expected to make sure of the card's
> + * state (DATA/RCV/TRANSFER) before changing the frequency at runtime.
> + *
> + * If the frequency to change is greater than max. supported by card,
> + * *freq is changed to max. supported by card. If it is less than min.
> + * supported by host, *freq is changed to min. supported by host.
> + * Host is assumed to be calimed while calling this funciton.
> + */
> +static int mmc_change_bus_speed(struct mmc_host *host, unsigned long *freq)
> +{
> + int err = 0;
> + struct mmc_card *card;
> + unsigned long actual_freq;
> +
> + card = host->card;
> +
> + if (!card || !freq) {
> + err = -EINVAL;
> + goto out;
> + }
> + actual_freq = *freq;
> +
> + WARN_ON(!host->claimed);
> +
> + /*
> + * For scaling up/down HS400 we'll need special handling,
> + * for other timings we can simply do clock frequency change
> + */
> + if (mmc_card_hs400(card) ||
> + (!mmc_card_hs200(host->card) && *freq == MMC_HS200_MAX_DTR)) {
> + err = mmc_set_clock_bus_speed(card, *freq);
> + if (err) {
> + pr_err("%s: %s: failed (%d)to set bus and clock speed (freq=%lu)\n",
> + mmc_hostname(host), __func__, err, *freq);
> + goto out;
> + }
> + } else if (mmc_card_hs200(host->card)) {
> + mmc_set_clock(host, *freq);
> + err = mmc_hs200_tuning(host->card);
> + if (err) {
> + pr_warn("%s: %s: tuning execution failed %d\n",
> + mmc_hostname(card->host),
> + __func__, err);
> + mmc_set_clock(host, host->clk_scaling.curr_freq);
> + }
> + } else {
> + if (mmc_card_ddr52(host->card))
> + actual_freq = mmc_ddr_freq_accommodation(*freq);
> + mmc_set_clock(host, actual_freq);
> + }
> +
> +out:
> + return err;
> +}
> +
> +/*
> * Handle the detection and initialisation of a card.
> *
> * In the case of a resume, "oldcard" will contain the card
> @@ -1751,6 +1915,16 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
> }
> }
>
> + card->clk_scaling_lowest = host->f_min;
> + if ((card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS400) ||
> + (card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS200))
> + card->clk_scaling_highest = card->ext_csd.hs200_max_dtr;
> + else if ((card->mmc_avail_type & EXT_CSD_CARD_TYPE_HS) ||
> + (card->mmc_avail_type & EXT_CSD_CARD_TYPE_DDR_52))
> + card->clk_scaling_highest = card->ext_csd.hs_max_dtr;
> + else
> + card->clk_scaling_highest = card->csd.max_dtr;
> +
> /*
> * Choose the power class with selected bus interface
> */
> @@ -1942,6 +2116,7 @@ static int mmc_poweroff_notify(struct mmc_card *card, unsigned int notify_type)
> */
> static void mmc_remove(struct mmc_host *host)
> {
> + mmc_exit_clk_scaling(host);
> mmc_remove_card(host->card);
> host->card = NULL;
> }
> @@ -2064,6 +2239,13 @@ static int mmc_shutdown(struct mmc_host *host)
> int err = 0;
>
> /*
> + * Exit clock scaling so that it doesn't kick in after
> + * power off notification is sent
> + */
> + if (host->caps2 & MMC_CAP2_CLK_SCALE)
> + mmc_exit_clk_scaling(host);
> +
> + /*
> * In a specific case for poweroff notify, we need to resume the card
> * before we can shutdown it properly.
> */
> @@ -2132,6 +2314,7 @@ static int mmc_can_reset(struct mmc_card *card)
> static int _mmc_hw_reset(struct mmc_host *host)
> {
> struct mmc_card *card = host->card;
> + int ret;
>
> /*
> * In the case of recovery, we can't expect flushing the cache to work
> @@ -2151,7 +2334,15 @@ static int _mmc_hw_reset(struct mmc_host *host)
> mmc_power_cycle(host, card->ocr);
> mmc_pwrseq_reset(host);
> }
> - return mmc_init_card(host, card->ocr, card);
> +
> + ret = mmc_init_card(host, card->ocr, card);
> + if (ret) {
> + pr_err("%s: %s: mmc_init_card failed (%d)\n",
> + mmc_hostname(host), __func__, ret);
> + return ret;
> + }
> +
> + return ret;
> }
>
> static const struct mmc_bus_ops mmc_ops = {
> @@ -2164,6 +2355,7 @@ static int _mmc_hw_reset(struct mmc_host *host)
> .alive = mmc_alive,
> .shutdown = mmc_shutdown,
> .hw_reset = _mmc_hw_reset,
> + .change_bus_speed = mmc_change_bus_speed,
> };
>
> /*
> @@ -2220,6 +2412,12 @@ int mmc_attach_mmc(struct mmc_host *host)
> goto remove_card;
>
> mmc_claim_host(host);
> + err = mmc_init_clk_scaling(host);
> + if (err) {
> + mmc_release_host(host);
> + goto remove_card;
> + }
> +
> return 0;
>
> remove_card:
> diff --git a/drivers/mmc/core/sd.c b/drivers/mmc/core/sd.c
> index d0d9f90..40144c1 100644
> --- a/drivers/mmc/core/sd.c
> +++ b/drivers/mmc/core/sd.c
> @@ -892,7 +892,10 @@ unsigned mmc_sd_get_max_clock(struct mmc_card *card)
> {
> unsigned max_dtr = (unsigned int)-1;
>
> - if (mmc_card_hs(card)) {
> + if (mmc_card_uhs(card)) {
> + if (max_dtr > card->sw_caps.uhs_max_dtr)
> + max_dtr = card->sw_caps.uhs_max_dtr;
> + } else if (mmc_card_hs(card)) {
> if (max_dtr > card->sw_caps.hs_max_dtr)
> max_dtr = card->sw_caps.hs_max_dtr;
> } else if (max_dtr > card->csd.max_dtr) {
> @@ -1059,6 +1062,9 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
> }
> }
>
> + card->clk_scaling_highest = mmc_sd_get_max_clock(card);
> + card->clk_scaling_lowest = host->f_min;
> +
> if (host->caps2 & MMC_CAP2_AVOID_3_3V &&
> host->ios.signal_voltage == MMC_SIGNAL_VOLTAGE_330) {
> pr_err("%s: Host failed to negotiate down from 3.3V\n",
> @@ -1082,6 +1088,7 @@ static int mmc_sd_init_card(struct mmc_host *host, u32 ocr,
> */
> static void mmc_sd_remove(struct mmc_host *host)
> {
> + mmc_exit_clk_scaling(host);
> mmc_remove_card(host->card);
> host->card = NULL;
> }
> @@ -1228,6 +1235,62 @@ static int mmc_sd_hw_reset(struct mmc_host *host)
> return mmc_sd_init_card(host, host->card->ocr, host->card);
> }
>
> +/**
> + * mmc_sd_change_bus_speed() - Change SD card bus frequency at runtime
> + * @host: pointer to mmc host structure
> + * @freq: pointer to desired frequency to be set
> + *
> + * Change the SD card bus frequency at runtime after the card is
> + * initialized. Callers are expected to make sure of the card's
> + * state (DATA/RCV/TRANSFER) beforing changing the frequency at runtime.
> + *
> + * If the frequency to change is greater than max. supported by card,
> + * *freq is changed to max. supported by card and if it is less than min.
> + * supported by host, *freq is changed to min. supported by host.
> + */
> +static int mmc_sd_change_bus_speed(struct mmc_host *host, unsigned long *freq)
> +{
> + int err = 0;
> + struct mmc_card *card;
> +
> + mmc_claim_host(host);
> + /*
> + * Assign card pointer after claiming host to avoid race
> + * conditions that may arise during removal of the card.
> + */
> + card = host->card;
> +
> + /* sanity checks */
> + if (!card || !freq) {
> + err = -EINVAL;
> + goto out;
> + }
> +
> + mmc_set_clock(host, (unsigned int) (*freq));
> +
> + if (!mmc_host_is_spi(card->host) && mmc_card_uhs(card)
> + && card->host->ops->execute_tuning) {
> + /*
> + * We try to probe host driver for tuning for any
> + * frequency, it is host driver responsibility to
> + * perform actual tuning only when required.
> + */
> + err = card->host->ops->execute_tuning(card->host,
> + MMC_SEND_TUNING_BLOCK);
> +
> + if (err) {
> + pr_warn("%s: %s: tuning execution failed %d. Restoring to previous clock %lu\n",
> + mmc_hostname(card->host), __func__, err,
> + host->clk_scaling.curr_freq);
> + mmc_set_clock(host, host->clk_scaling.curr_freq);
> + }
> + }
> +
> +out:
> + mmc_release_host(host);
> + return err;
> +}
> +
> static const struct mmc_bus_ops mmc_sd_ops = {
> .remove = mmc_sd_remove,
> .detect = mmc_sd_detect,
> @@ -1238,6 +1301,7 @@ static int mmc_sd_hw_reset(struct mmc_host *host)
> .alive = mmc_sd_alive,
> .shutdown = mmc_sd_suspend,
> .hw_reset = mmc_sd_hw_reset,
> + .change_bus_speed = mmc_sd_change_bus_speed,
> };
>
> /*
> @@ -1292,6 +1356,12 @@ int mmc_attach_sd(struct mmc_host *host)
> goto remove_card;
>
> mmc_claim_host(host);
> + err = mmc_init_clk_scaling(host);
> + if (err) {
> + mmc_release_host(host);
> + goto remove_card;
> + }
> +
> return 0;
>
> remove_card:
> diff --git a/drivers/mmc/host/sdhci-msm.c b/drivers/mmc/host/sdhci-msm.c
> index b5519a5..e9fe8c6 100644
> --- a/drivers/mmc/host/sdhci-msm.c
> +++ b/drivers/mmc/host/sdhci-msm.c
> @@ -1705,6 +1705,43 @@ static int sdhci_msm_register_vreg(struct sdhci_msm_host *msm_host)
>
> MODULE_DEVICE_TABLE(of, sdhci_msm_dt_match);
>
> +int sdhci_msm_dt_get_array(struct device *dev, const char *prop_name,
> + u32 **out, int *len, u32 size)
> +{
> + int ret = 0;
> + struct device_node *np = dev->of_node;
> + size_t sz;
> + u32 *arr = NULL;
> +
> + if (!of_get_property(np, prop_name, len)) {
> + ret = -EINVAL;
> + goto out;
> + }
> + sz = *len = *len / sizeof(*arr);
> + if (sz <= 0 || (size > 0 && (sz > size))) {
> + dev_err(dev, "%s invalid size\n", prop_name);
> + ret = -EINVAL;
> + goto out;
> + }
> +
> + arr = devm_kzalloc(dev, sz * sizeof(*arr), GFP_KERNEL);
> + if (!arr) {
> + ret = -ENOMEM;
> + goto out;
> + }
> +
> + ret = of_property_read_u32_array(np, prop_name, arr, sz);
> + if (ret < 0) {
> + dev_err(dev, "%s failed reading array %d\n", prop_name, ret);
> + goto out;
> + }
> + *out = arr;
> +out:
> + if (ret)
> + *len = 0;
> + return ret;
> +}
> +
> static const struct sdhci_ops sdhci_msm_ops = {
> .reset = sdhci_reset,
> .set_clock = sdhci_msm_set_clock,
> diff --git a/drivers/mmc/host/sdhci-pltfm.c b/drivers/mmc/host/sdhci-pltfm.c
> index 02bea61..354fc68 100644
> --- a/drivers/mmc/host/sdhci-pltfm.c
> +++ b/drivers/mmc/host/sdhci-pltfm.c
> @@ -36,6 +36,9 @@
> #endif
> #include "sdhci-pltfm.h"
>
> +int sdhci_msm_dt_get_array(struct device *dev, const char *prop_name,
> + u32 **out, int *len, u32 size);
> +
> unsigned int sdhci_pltfm_clk_get_max_clock(struct sdhci_host *host)
> {
> struct sdhci_pltfm_host *pltfm_host = sdhci_priv(host);
> @@ -101,6 +104,14 @@ void sdhci_get_of_property(struct platform_device *pdev)
>
> of_property_read_u32(np, "clock-frequency", &pltfm_host->clock);
>
> + if (sdhci_msm_dt_get_array(&pdev->dev, "qcom,devfreq,freq-table",
> + &host->mmc->clk_scaling.pltfm_freq_table,
> + &host->mmc->clk_scaling.pltfm_freq_table_sz, 0))
> + pr_debug("no clock scaling frequencies were supplied\n");
> + else if (!host->mmc->clk_scaling.pltfm_freq_table ||
> + !host->mmc->clk_scaling.pltfm_freq_table_sz)
> + pr_err("bad dts clock scaling frequencies\n");
> +
> if (of_find_property(np, "keep-power-in-suspend", NULL))
> host->mmc->pm_caps |= MMC_PM_KEEP_POWER;
>
> diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
> index 162b9af..f0aafab 100644
> --- a/drivers/mmc/host/sdhci.c
> +++ b/drivers/mmc/host/sdhci.c
> @@ -2427,6 +2427,32 @@ static void sdhci_card_event(struct mmc_host *mmc)
> spin_unlock_irqrestore(&host->lock, flags);
> }
>
> +static inline void sdhci_update_power_policy(struct sdhci_host *host,
> + enum sdhci_power_policy policy)
> +{
> + host->power_policy = policy;
> +}
> +
> +static int sdhci_notify_load(struct mmc_host *mmc, enum mmc_load state)
> +{
> + int err = 0;
> + struct sdhci_host *host = mmc_priv(mmc);
> +
> + switch (state) {
> + case MMC_LOAD_HIGH:
> + sdhci_update_power_policy(host, SDHCI_PERFORMANCE_MODE);
> + break;
> + case MMC_LOAD_LOW:
> + sdhci_update_power_policy(host, SDHCI_POWER_SAVE_MODE);
> + break;
> + default:
> + err = -EINVAL;
> + break;
> + }
> +
> + return err;
> +}
> +
> static const struct mmc_host_ops sdhci_ops = {
> .request = sdhci_request,
> .post_req = sdhci_post_req,
> @@ -2441,6 +2467,7 @@ static void sdhci_card_event(struct mmc_host *mmc)
> .execute_tuning = sdhci_execute_tuning,
> .card_event = sdhci_card_event,
> .card_busy = sdhci_card_busy,
> + .notify_load = sdhci_notify_load,
> };
>
> /*****************************************************************************\
> diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
> index 3b0c97a..740471f 100644
> --- a/drivers/mmc/host/sdhci.h
> +++ b/drivers/mmc/host/sdhci.h
> @@ -346,6 +346,12 @@ enum sdhci_cookie {
> COOKIE_MAPPED, /* mapped by sdhci_prepare_data() */
> };
>
> +enum sdhci_power_policy {
> + SDHCI_PERFORMANCE_MODE,
> + SDHCI_POWER_SAVE_MODE,
> + SDHCI_POWER_POLICY_NUM /* Always keep this one last */
> +};
> +
> struct sdhci_host {
> /* Data set by hardware interface driver */
> const char *hw_name; /* Hardware bus name */
> @@ -562,6 +568,8 @@ struct sdhci_host {
> /* Delay (ms) between tuning commands */
> int tuning_delay;
>
> + enum sdhci_power_policy power_policy;
> +
> /* Host SDMA buffer boundary. */
> u32 sdma_boundary;
>
> diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
> index de73778..c713581 100644
> --- a/include/linux/mmc/card.h
> +++ b/include/linux/mmc/card.h
> @@ -245,6 +245,10 @@ struct mmc_card {
> struct mmc_host *host; /* the host this device belongs to */
> struct device dev; /* the device */
> u32 ocr; /* the current OCR setting */
> + unsigned long clk_scaling_lowest; /* lowest scaleable*/
> + /* frequency */
> + unsigned long clk_scaling_highest; /* highest scaleable */
> +
> unsigned int rca; /* relative card address of device */
> unsigned int type; /* card type */
> #define MMC_TYPE_MMC 0 /* MMC card */
> @@ -308,6 +312,7 @@ struct mmc_card {
> unsigned int nr_parts;
>
> unsigned int bouncesz; /* Bounce buffer size */
> + unsigned int part_curr;
> };
>
> static inline bool mmc_large_sector(struct mmc_card *card)
> diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
> index 64300a4..321ab39 100644
> --- a/include/linux/mmc/host.h
> +++ b/include/linux/mmc/host.h
> @@ -12,6 +12,7 @@
>
> #include <linux/sched.h>
> #include <linux/device.h>
> +#include <linux/devfreq.h>
> #include <linux/fault-inject.h>
>
> #include <linux/mmc/core.h>
> @@ -82,6 +83,12 @@ struct mmc_ios {
>
> struct mmc_host;
>
> +/* states to represent load on the host */
> +enum mmc_load {
> + MMC_LOAD_HIGH,
> + MMC_LOAD_LOW,
> +};
> +
> struct mmc_host_ops {
> /*
> * It is optional for the host to implement pre_req and post_req in
> @@ -161,6 +168,7 @@ struct mmc_host_ops {
> */
> int (*multi_io_quirk)(struct mmc_card *card,
> unsigned int direction, int blk_size);
> + int (*notify_load)(struct mmc_host *, enum mmc_load);
> };
>
> struct mmc_cqe_ops {
> @@ -260,9 +268,60 @@ struct mmc_ctx {
> struct task_struct *task;
> };
>
> +/**
> + * struct mmc_devfeq_clk_scaling - main context for MMC clock scaling logic
> + *
> + * @lock: spinlock to protect statistics
> + * @devfreq: struct that represent mmc-host as a client for devfreq
> + * @devfreq_profile: MMC device profile, mostly polling interval and callbacks
> + * @ondemand_gov_data: struct supplied to ondemmand governor (thresholds)
> + * @state: load state, can be HIGH or LOW. used to notify mmc_host_ops callback
> + * @start_busy: timestamped armed once a data request is started
> + * @measure_interval_start: timestamped armed once a measure interval started
> + * @devfreq_abort: flag to sync between different contexts relevant to devfreq
> + * @skip_clk_scale_freq_update: flag that enable/disable frequency change
> + * @freq_table_sz: table size of frequencies supplied to devfreq
> + * @freq_table: frequencies table supplied to devfreq
> + * @curr_freq: current frequency
> + * @polling_delay_ms: polling interval for status collection used by devfreq
> + * @upthreshold: up-threshold supplied to ondemand governor
> + * @downthreshold: down-threshold supplied to ondemand governor
> + * @need_freq_change: flag indicating if a frequency change is required
> + * @clk_scaling_in_progress: flag indicating if there's ongoing frequency change
> + * @is_busy_started: flag indicating if a request is handled by the HW
> + * @enable: flag indicating if the clock scaling logic is enabled for this host
> + */
> +struct mmc_devfeq_clk_scaling {
> + spinlock_t lock;
> + struct devfreq *devfreq;
> + struct devfreq_dev_profile devfreq_profile;
> + struct devfreq_simple_ondemand_data ondemand_gov_data;
> + enum mmc_load state;
> + ktime_t start_busy;
> + ktime_t measure_interval_start;
> + atomic_t devfreq_abort;
> + bool skip_clk_scale_freq_update;
> + int freq_table_sz;
> + int pltfm_freq_table_sz;
> + u32 *freq_table;
> + u32 *pltfm_freq_table;
> + unsigned long total_busy_time_us;
> + unsigned long target_freq;
> + unsigned long curr_freq;
> + unsigned long polling_delay_ms;
> + unsigned int upthreshold;
> + unsigned int downthreshold;
> + bool need_freq_change;
> + bool clk_scaling_in_progress;
> + bool is_busy_started;
> + bool enable;
> +};
> +
> +
> struct mmc_host {
> struct device *parent;
> struct device class_dev;
> + struct mmc_devfeq_clk_scaling clk_scaling;
> int index;
> const struct mmc_host_ops *ops;
> struct mmc_pwrseq *pwrseq;
> @@ -360,6 +419,7 @@ struct mmc_host {
> #define MMC_CAP2_CQE (1 << 23) /* Has eMMC command queue engine */
> #define MMC_CAP2_CQE_DCMD (1 << 24) /* CQE can issue a direct command */
> #define MMC_CAP2_AVOID_3_3V (1 << 25) /* Host must negotiate down from 3.3V */
> +#define MMC_CAP2_CLK_SCALE (1 << 26) /* Allow dynamic clk scaling */
>
> int fixed_drv_type; /* fixed driver type for non-removable media */
>
> @@ -523,6 +583,16 @@ static inline int mmc_regulator_set_vqmmc(struct mmc_host *mmc,
> u32 mmc_vddrange_to_ocrmask(int vdd_min, int vdd_max);
> int mmc_regulator_get_supply(struct mmc_host *mmc);
>
> +static inline void mmc_host_clear_sdr104(struct mmc_host *host)
> +{
> + host->caps &= ~MMC_CAP_UHS_SDR104;
> +}
> +
> +static inline void mmc_host_set_sdr104(struct mmc_host *host)
> +{
> + host->caps |= MMC_CAP_UHS_SDR104;
> +}
> +
> static inline int mmc_card_is_removable(struct mmc_host *host)
> {
> return !(host->caps & MMC_CAP_NONREMOVABLE);
>
Thanks,
Vijay
Powered by blists - more mailing lists