linux/drivers/mmc/core/regulator.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Helper functions for MMC regulators.
   4 */
   5
   6#include <linux/device.h>
   7#include <linux/err.h>
   8#include <linux/log2.h>
   9#include <linux/regulator/consumer.h>
  10
  11#include <linux/mmc/host.h>
  12
  13#include "core.h"
  14#include "host.h"
  15
  16#ifdef CONFIG_REGULATOR
  17
  18/**
  19 * mmc_ocrbitnum_to_vdd - Convert a OCR bit number to its voltage
  20 * @vdd_bit:    OCR bit number
  21 * @min_uV:     minimum voltage value (mV)
  22 * @max_uV:     maximum voltage value (mV)
  23 *
  24 * This function returns the voltage range according to the provided OCR
  25 * bit number. If conversion is not possible a negative errno value returned.
  26 */
  27static int mmc_ocrbitnum_to_vdd(int vdd_bit, int *min_uV, int *max_uV)
  28{
  29        int             tmp;
  30
  31        if (!vdd_bit)
  32                return -EINVAL;
  33
  34        /*
  35         * REVISIT mmc_vddrange_to_ocrmask() may have set some
  36         * bits this regulator doesn't quite support ... don't
  37         * be too picky, most cards and regulators are OK with
  38         * a 0.1V range goof (it's a small error percentage).
  39         */
  40        tmp = vdd_bit - ilog2(MMC_VDD_165_195);
  41        if (tmp == 0) {
  42                *min_uV = 1650 * 1000;
  43                *max_uV = 1950 * 1000;
  44        } else {
  45                *min_uV = 1900 * 1000 + tmp * 100 * 1000;
  46                *max_uV = *min_uV + 100 * 1000;
  47        }
  48
  49        return 0;
  50}
  51
  52/**
  53 * mmc_regulator_get_ocrmask - return mask of supported voltages
  54 * @supply: regulator to use
  55 *
  56 * This returns either a negative errno, or a mask of voltages that
  57 * can be provided to MMC/SD/SDIO devices using the specified voltage
  58 * regulator.  This would normally be called before registering the
  59 * MMC host adapter.
  60 */
  61static int mmc_regulator_get_ocrmask(struct regulator *supply)
  62{
  63        int                     result = 0;
  64        int                     count;
  65        int                     i;
  66        int                     vdd_uV;
  67        int                     vdd_mV;
  68
  69        count = regulator_count_voltages(supply);
  70        if (count < 0)
  71                return count;
  72
  73        for (i = 0; i < count; i++) {
  74                vdd_uV = regulator_list_voltage(supply, i);
  75                if (vdd_uV <= 0)
  76                        continue;
  77
  78                vdd_mV = vdd_uV / 1000;
  79                result |= mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
  80        }
  81
  82        if (!result) {
  83                vdd_uV = regulator_get_voltage(supply);
  84                if (vdd_uV <= 0)
  85                        return vdd_uV;
  86
  87                vdd_mV = vdd_uV / 1000;
  88                result = mmc_vddrange_to_ocrmask(vdd_mV, vdd_mV);
  89        }
  90
  91        return result;
  92}
  93
  94/**
  95 * mmc_regulator_set_ocr - set regulator to match host->ios voltage
  96 * @mmc: the host to regulate
  97 * @supply: regulator to use
  98 * @vdd_bit: zero for power off, else a bit number (host->ios.vdd)
  99 *
 100 * Returns zero on success, else negative errno.
 101 *
 102 * MMC host drivers may use this to enable or disable a regulator using
 103 * a particular supply voltage.  This would normally be called from the
 104 * set_ios() method.
 105 */
 106int mmc_regulator_set_ocr(struct mmc_host *mmc,
 107                        struct regulator *supply,
 108                        unsigned short vdd_bit)
 109{
 110        int                     result = 0;
 111        int                     min_uV, max_uV;
 112
 113        if (vdd_bit) {
 114                mmc_ocrbitnum_to_vdd(vdd_bit, &min_uV, &max_uV);
 115
 116                result = regulator_set_voltage(supply, min_uV, max_uV);
 117                if (result == 0 && !mmc->regulator_enabled) {
 118                        result = regulator_enable(supply);
 119                        if (!result)
 120                                mmc->regulator_enabled = true;
 121                }
 122        } else if (mmc->regulator_enabled) {
 123                result = regulator_disable(supply);
 124                if (result == 0)
 125                        mmc->regulator_enabled = false;
 126        }
 127
 128        if (result)
 129                dev_err(mmc_dev(mmc),
 130                        "could not set regulator OCR (%d)\n", result);
 131        return result;
 132}
 133EXPORT_SYMBOL_GPL(mmc_regulator_set_ocr);
 134
 135static int mmc_regulator_set_voltage_if_supported(struct regulator *regulator,
 136                                                  int min_uV, int target_uV,
 137                                                  int max_uV)
 138{
 139        int current_uV;
 140
 141        /*
 142         * Check if supported first to avoid errors since we may try several
 143         * signal levels during power up and don't want to show errors.
 144         */
 145        if (!regulator_is_supported_voltage(regulator, min_uV, max_uV))
 146                return -EINVAL;
 147
 148        /*
 149         * The voltage is already set, no need to switch.
 150         * Return 1 to indicate that no switch happened.
 151         */
 152        current_uV = regulator_get_voltage(regulator);
 153        if (current_uV == target_uV)
 154                return 1;
 155
 156        return regulator_set_voltage_triplet(regulator, min_uV, target_uV,
 157                                             max_uV);
 158}
 159
 160/**
 161 * mmc_regulator_set_vqmmc - Set VQMMC as per the ios
 162 * @mmc: the host to regulate
 163 * @ios: io bus settings
 164 *
 165 * For 3.3V signaling, we try to match VQMMC to VMMC as closely as possible.
 166 * That will match the behavior of old boards where VQMMC and VMMC were supplied
 167 * by the same supply.  The Bus Operating conditions for 3.3V signaling in the
 168 * SD card spec also define VQMMC in terms of VMMC.
 169 * If this is not possible we'll try the full 2.7-3.6V of the spec.
 170 *
 171 * For 1.2V and 1.8V signaling we'll try to get as close as possible to the
 172 * requested voltage.  This is definitely a good idea for UHS where there's a
 173 * separate regulator on the card that's trying to make 1.8V and it's best if
 174 * we match.
 175 *
 176 * This function is expected to be used by a controller's
 177 * start_signal_voltage_switch() function.
 178 */
 179int mmc_regulator_set_vqmmc(struct mmc_host *mmc, struct mmc_ios *ios)
 180{
 181        struct device *dev = mmc_dev(mmc);
 182        int ret, volt, min_uV, max_uV;
 183
 184        /* If no vqmmc supply then we can't change the voltage */
 185        if (IS_ERR(mmc->supply.vqmmc))
 186                return -EINVAL;
 187
 188        switch (ios->signal_voltage) {
 189        case MMC_SIGNAL_VOLTAGE_120:
 190                return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
 191                                                1100000, 1200000, 1300000);
 192        case MMC_SIGNAL_VOLTAGE_180:
 193                return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
 194                                                1700000, 1800000, 1950000);
 195        case MMC_SIGNAL_VOLTAGE_330:
 196                ret = mmc_ocrbitnum_to_vdd(mmc->ios.vdd, &volt, &max_uV);
 197                if (ret < 0)
 198                        return ret;
 199
 200                dev_dbg(dev, "%s: found vmmc voltage range of %d-%duV\n",
 201                        __func__, volt, max_uV);
 202
 203                min_uV = max(volt - 300000, 2700000);
 204                max_uV = min(max_uV + 200000, 3600000);
 205
 206                /*
 207                 * Due to a limitation in the current implementation of
 208                 * regulator_set_voltage_triplet() which is taking the lowest
 209                 * voltage possible if below the target, search for a suitable
 210                 * voltage in two steps and try to stay close to vmmc
 211                 * with a 0.3V tolerance at first.
 212                 */
 213                ret = mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
 214                                                        min_uV, volt, max_uV);
 215                if (ret >= 0)
 216                        return ret;
 217
 218                return mmc_regulator_set_voltage_if_supported(mmc->supply.vqmmc,
 219                                                2700000, volt, 3600000);
 220        default:
 221                return -EINVAL;
 222        }
 223}
 224EXPORT_SYMBOL_GPL(mmc_regulator_set_vqmmc);
 225
 226#else
 227
 228static inline int mmc_regulator_get_ocrmask(struct regulator *supply)
 229{
 230        return 0;
 231}
 232
 233#endif /* CONFIG_REGULATOR */
 234
 235/**
 236 * mmc_regulator_get_supply - try to get VMMC and VQMMC regulators for a host
 237 * @mmc: the host to regulate
 238 *
 239 * Returns 0 or errno. errno should be handled, it is either a critical error
 240 * or -EPROBE_DEFER. 0 means no critical error but it does not mean all
 241 * regulators have been found because they all are optional. If you require
 242 * certain regulators, you need to check separately in your driver if they got
 243 * populated after calling this function.
 244 */
 245int mmc_regulator_get_supply(struct mmc_host *mmc)
 246{
 247        struct device *dev = mmc_dev(mmc);
 248        int ret;
 249
 250        mmc->supply.vmmc = devm_regulator_get_optional(dev, "vmmc");
 251        mmc->supply.vqmmc = devm_regulator_get_optional(dev, "vqmmc");
 252
 253        if (IS_ERR(mmc->supply.vmmc)) {
 254                if (PTR_ERR(mmc->supply.vmmc) == -EPROBE_DEFER)
 255                        return -EPROBE_DEFER;
 256                dev_dbg(dev, "No vmmc regulator found\n");
 257        } else {
 258                ret = mmc_regulator_get_ocrmask(mmc->supply.vmmc);
 259                if (ret > 0)
 260                        mmc->ocr_avail = ret;
 261                else
 262                        dev_warn(dev, "Failed getting OCR mask: %d\n", ret);
 263        }
 264
 265        if (IS_ERR(mmc->supply.vqmmc)) {
 266                if (PTR_ERR(mmc->supply.vqmmc) == -EPROBE_DEFER)
 267                        return -EPROBE_DEFER;
 268                dev_dbg(dev, "No vqmmc regulator found\n");
 269        }
 270
 271        return 0;
 272}
 273EXPORT_SYMBOL_GPL(mmc_regulator_get_supply);
 274