Linux 4.1.16

[linux/fpc-iii.git] / drivers / power / avs / rockchip-io-domain.c

/*
 * Rockchip IO Voltage Domain driver
 *
 * Copyright 2014 MundoReader S.L.
 * Copyright 2014 Google, Inc.
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/err.h>
#include <linux/mfd/syscon.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/regulator/consumer.h>

#define MAX_SUPPLIES            16

/*
 * The max voltage for 1.8V and 3.3V come from the Rockchip datasheet under
 * "Recommended Operating Conditions" for "Digital GPIO".   When the typical
 * is 3.3V the max is 3.6V.  When the typical is 1.8V the max is 1.98V.
 *
 * They are used like this:
 * - If the voltage on a rail is above the "1.8" voltage (1.98V) we'll tell the
 *   SoC we're at 3.3.
 * - If the voltage on a rail is above the "3.3" voltage (3.6V) we'll consider
 *   that to be an error.
 */
#define MAX_VOLTAGE_1_8         1980000
#define MAX_VOLTAGE_3_3         3600000

#define RK3288_SOC_CON2                 0x24c
#define RK3288_SOC_CON2_FLASH0          BIT(7)
#define RK3288_SOC_FLASH_SUPPLY_NUM     2

struct rockchip_iodomain;

/**
 * @supplies: voltage settings matching the register bits.
 */
struct rockchip_iodomain_soc_data {
        int grf_offset;
        const char *supply_names[MAX_SUPPLIES];
        void (*init)(struct rockchip_iodomain *iod);
};

struct rockchip_iodomain_supply {
        struct rockchip_iodomain *iod;
        struct regulator *reg;
        struct notifier_block nb;
        int idx;
};

struct rockchip_iodomain {
        struct device *dev;
        struct regmap *grf;
        struct rockchip_iodomain_soc_data *soc_data;
        struct rockchip_iodomain_supply supplies[MAX_SUPPLIES];
};

static int rockchip_iodomain_write(struct rockchip_iodomain_supply *supply,
                                   int uV)
{
        struct rockchip_iodomain *iod = supply->iod;
        u32 val;
        int ret;

        /* set value bit */
        val = (uV > MAX_VOLTAGE_1_8) ? 0 : 1;
        val <<= supply->idx;

        /* apply hiword-mask */
        val |= (BIT(supply->idx) << 16);

        ret = regmap_write(iod->grf, iod->soc_data->grf_offset, val);
        if (ret)
                dev_err(iod->dev, "Couldn't write to GRF\n");

        return ret;
}

static int rockchip_iodomain_notify(struct notifier_block *nb,
                                    unsigned long event,
                                    void *data)
{
        struct rockchip_iodomain_supply *supply =
                        container_of(nb, struct rockchip_iodomain_supply, nb);
        int uV;
        int ret;

        /*
         * According to Rockchip it's important to keep the SoC IO domain
         * higher than (or equal to) the external voltage.  That means we need
         * to change it before external voltage changes happen in the case
         * of an increase.
         *
         * Note that in the "pre" change we pick the max possible voltage that
         * the regulator might end up at (the client requests a range and we
         * don't know for certain the exact voltage).  Right now we rely on the
         * slop in MAX_VOLTAGE_1_8 and MAX_VOLTAGE_3_3 to save us if clients
         * request something like a max of 3.6V when they really want 3.3V.
         * We could attempt to come up with better rules if this fails.
         */
        if (event & REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) {
                struct pre_voltage_change_data *pvc_data = data;

                uV = max_t(unsigned long, pvc_data->old_uV, pvc_data->max_uV);
        } else if (event & (REGULATOR_EVENT_VOLTAGE_CHANGE |
                            REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE)) {
                uV = (unsigned long)data;
        } else {
                return NOTIFY_OK;
        }

        dev_dbg(supply->iod->dev, "Setting to %d\n", uV);

        if (uV > MAX_VOLTAGE_3_3) {
                dev_err(supply->iod->dev, "Voltage too high: %d\n", uV);

                if (event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE)
                        return NOTIFY_BAD;
        }

        ret = rockchip_iodomain_write(supply, uV);
        if (ret && event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE)
                return NOTIFY_BAD;

        dev_info(supply->iod->dev, "Setting to %d done\n", uV);
        return NOTIFY_OK;
}

static void rk3288_iodomain_init(struct rockchip_iodomain *iod)
{
        int ret;
        u32 val;

        /* if no flash supply we should leave things alone */
        if (!iod->supplies[RK3288_SOC_FLASH_SUPPLY_NUM].reg)
                return;

        /*
         * set flash0 iodomain to also use this framework
         * instead of a special gpio.
         */
        val = RK3288_SOC_CON2_FLASH0 | (RK3288_SOC_CON2_FLASH0 << 16);
        ret = regmap_write(iod->grf, RK3288_SOC_CON2, val);
        if (ret < 0)
                dev_warn(iod->dev, "couldn't update flash0 ctrl\n");
}

/*
 * On the rk3188 the io-domains are handled by a shared register with the
 * lower 8 bits being still being continuing drive-strength settings.
 */
static const struct rockchip_iodomain_soc_data soc_data_rk3188 = {
        .grf_offset = 0x104,
        .supply_names = {
                NULL,
                NULL,
                NULL,
                NULL,
                NULL,
                NULL,
                NULL,
                NULL,
                "ap0",
                "ap1",
                "cif",
                "flash",
                "vccio0",
                "vccio1",
                "lcdc0",
                "lcdc1",
        },
};

static const struct rockchip_iodomain_soc_data soc_data_rk3288 = {
        .grf_offset = 0x380,
        .supply_names = {
                "lcdc",         /* LCDC_VDD */
                "dvp",          /* DVPIO_VDD */
                "flash0",       /* FLASH0_VDD (emmc) */
                "flash1",       /* FLASH1_VDD (sdio1) */
                "wifi",         /* APIO3_VDD  (sdio0) */
                "bb",           /* APIO5_VDD */
                "audio",        /* APIO4_VDD */
                "sdcard",       /* SDMMC0_VDD (sdmmc) */
                "gpio30",       /* APIO1_VDD */
                "gpio1830",     /* APIO2_VDD */
        },
        .init = rk3288_iodomain_init,
};

static const struct of_device_id rockchip_iodomain_match[] = {
        {
                .compatible = "rockchip,rk3188-io-voltage-domain",
                .data = (void *)&soc_data_rk3188
        },
        {
                .compatible = "rockchip,rk3288-io-voltage-domain",
                .data = (void *)&soc_data_rk3288
        },
        { /* sentinel */ },
};

static int rockchip_iodomain_probe(struct platform_device *pdev)
{
        struct device_node *np = pdev->dev.of_node;
        const struct of_device_id *match;
        struct rockchip_iodomain *iod;
        int i, ret = 0;

        if (!np)
                return -ENODEV;

        iod = devm_kzalloc(&pdev->dev, sizeof(*iod), GFP_KERNEL);
        if (!iod)
                return -ENOMEM;

        iod->dev = &pdev->dev;
        platform_set_drvdata(pdev, iod);

        match = of_match_node(rockchip_iodomain_match, np);
        iod->soc_data = (struct rockchip_iodomain_soc_data *)match->data;

        iod->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
        if (IS_ERR(iod->grf)) {
                dev_err(&pdev->dev, "couldn't find grf regmap\n");
                return PTR_ERR(iod->grf);
        }

        for (i = 0; i < MAX_SUPPLIES; i++) {
                const char *supply_name = iod->soc_data->supply_names[i];
                struct rockchip_iodomain_supply *supply = &iod->supplies[i];
                struct regulator *reg;
                int uV;

                if (!supply_name)
                        continue;

                reg = devm_regulator_get_optional(iod->dev, supply_name);
                if (IS_ERR(reg)) {
                        ret = PTR_ERR(reg);

                        /* If a supply wasn't specified, that's OK */
                        if (ret == -ENODEV)
                                continue;
                        else if (ret != -EPROBE_DEFER)
                                dev_err(iod->dev, "couldn't get regulator %s\n",
                                        supply_name);
                        goto unreg_notify;
                }

                /* set initial correct value */
                uV = regulator_get_voltage(reg);

                /* must be a regulator we can get the voltage of */
                if (uV < 0) {
                        dev_err(iod->dev, "Can't determine voltage: %s\n",
                                supply_name);
                        goto unreg_notify;
                }

                if (uV > MAX_VOLTAGE_3_3) {
                        dev_crit(iod->dev,
                                 "%d uV is too high. May damage SoC!\n",
                                 uV);
                        ret = -EINVAL;
                        goto unreg_notify;
                }

                /* setup our supply */
                supply->idx = i;
                supply->iod = iod;
                supply->reg = reg;
                supply->nb.notifier_call = rockchip_iodomain_notify;

                ret = rockchip_iodomain_write(supply, uV);
                if (ret) {
                        supply->reg = NULL;
                        goto unreg_notify;
                }

                /* register regulator notifier */
                ret = regulator_register_notifier(reg, &supply->nb);
                if (ret) {
                        dev_err(&pdev->dev,
                                "regulator notifier request failed\n");
                        supply->reg = NULL;
                        goto unreg_notify;
                }
        }

        if (iod->soc_data->init)
                iod->soc_data->init(iod);

        return 0;

unreg_notify:
        for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
                struct rockchip_iodomain_supply *io_supply = &iod->supplies[i];

                if (io_supply->reg)
                        regulator_unregister_notifier(io_supply->reg,
                                                      &io_supply->nb);
        }

        return ret;
}

static int rockchip_iodomain_remove(struct platform_device *pdev)
{
        struct rockchip_iodomain *iod = platform_get_drvdata(pdev);
        int i;

        for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
                struct rockchip_iodomain_supply *io_supply = &iod->supplies[i];

                if (io_supply->reg)
                        regulator_unregister_notifier(io_supply->reg,
                                                      &io_supply->nb);
        }

        return 0;
}

static struct platform_driver rockchip_iodomain_driver = {
        .probe   = rockchip_iodomain_probe,
        .remove  = rockchip_iodomain_remove,
        .driver  = {
                .name  = "rockchip-iodomain",
                .of_match_table = rockchip_iodomain_match,
        },
};

module_platform_driver(rockchip_iodomain_driver);

MODULE_DESCRIPTION("Rockchip IO-domain driver");
MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
MODULE_AUTHOR("Doug Anderson <dianders@chromium.org>");
MODULE_LICENSE("GPL v2");