[mirror_ubuntu-artful-kernel.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

#define RK3328_SOC_CON4			0x410
#define RK3328_SOC_CON4_VCCIO2		BIT(7)
#define RK3328_SOC_VCCIO2_SUPPLY_NUM	1

#define RK3368_SOC_CON15		0x43c
#define RK3368_SOC_CON15_FLASH0		BIT(14)
#define RK3368_SOC_FLASH_SUPPLY_NUM	2

#define RK3399_PMUGRF_CON0		0x180
#define RK3399_PMUGRF_CON0_VSEL		BIT(8)
#define RK3399_PMUGRF_VSEL_SUPPLY_NUM	9

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_dbg(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");
}

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

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

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

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

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

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

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

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

	/*
	 * set pmu io iodomain to also use this framework
	 * instead of a special gpio.
	 */
	val = RK3399_PMUGRF_CON0_VSEL | (RK3399_PMUGRF_CON0_VSEL << 16);
	ret = regmap_write(iod->grf, RK3399_PMUGRF_CON0, val);
	if (ret < 0)
		dev_warn(iod->dev, "couldn't update pmu io iodomain 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_rk3228 = {
	.grf_offset = 0x418,
	.supply_names = {
		"vccio1",
		"vccio2",
		"vccio3",
		"vccio4",
	},
};

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 rockchip_iodomain_soc_data soc_data_rk3328 = {
	.grf_offset = 0x410,
	.supply_names = {
		"vccio1",
		"vccio2",
		"vccio3",
		"vccio4",
		"vccio5",
		"vccio6",
		"pmuio",
	},
	.init = rk3328_iodomain_init,
};

static const struct rockchip_iodomain_soc_data soc_data_rk3368 = {
	.grf_offset = 0x900,
	.supply_names = {
		NULL,		/* reserved */
		"dvp",		/* DVPIO_VDD */
		"flash0",	/* FLASH0_VDD (emmc) */
		"wifi",		/* APIO2_VDD (sdio0) */
		NULL,
		"audio",	/* APIO3_VDD */
		"sdcard",	/* SDMMC0_VDD (sdmmc) */
		"gpio30",	/* APIO1_VDD */
		"gpio1830",	/* APIO4_VDD (gpujtag) */
	},
	.init = rk3368_iodomain_init,
};

static const struct rockchip_iodomain_soc_data soc_data_rk3368_pmu = {
	.grf_offset = 0x100,
	.supply_names = {
		NULL,
		NULL,
		NULL,
		NULL,
		"pmu",	        /*PMU IO domain*/
		"vop",	        /*LCDC IO domain*/
	},
};

static const struct rockchip_iodomain_soc_data soc_data_rk3399 = {
	.grf_offset = 0xe640,
	.supply_names = {
		"bt656",		/* APIO2_VDD */
		"audio",		/* APIO5_VDD */
		"sdmmc",		/* SDMMC0_VDD */
		"gpio1830",		/* APIO4_VDD */
	},
};

static const struct rockchip_iodomain_soc_data soc_data_rk3399_pmu = {
	.grf_offset = 0x180,
	.supply_names = {
		NULL,
		NULL,
		NULL,
		NULL,
		NULL,
		NULL,
		NULL,
		NULL,
		NULL,
		"pmu1830",		/* PMUIO2_VDD */
	},
	.init = rk3399_pmu_iodomain_init,
};

static const struct of_device_id rockchip_iodomain_match[] = {
	{
		.compatible = "rockchip,rk3188-io-voltage-domain",
		.data = (void *)&soc_data_rk3188
	},
	{
		.compatible = "rockchip,rk3228-io-voltage-domain",
		.data = (void *)&soc_data_rk3228
	},
	{
		.compatible = "rockchip,rk3288-io-voltage-domain",
		.data = (void *)&soc_data_rk3288
	},
	{
		.compatible = "rockchip,rk3328-io-voltage-domain",
		.data = (void *)&soc_data_rk3328
	},
	{
		.compatible = "rockchip,rk3368-io-voltage-domain",
		.data = (void *)&soc_data_rk3368
	},
	{
		.compatible = "rockchip,rk3368-pmu-io-voltage-domain",
		.data = (void *)&soc_data_rk3368_pmu
	},
	{
		.compatible = "rockchip,rk3399-io-voltage-domain",
		.data = (void *)&soc_data_rk3399
	},
	{
		.compatible = "rockchip,rk3399-pmu-io-voltage-domain",
		.data = (void *)&soc_data_rk3399_pmu
	},
	{ /* sentinel */ },
};
MODULE_DEVICE_TABLE(of, rockchip_iodomain_match);

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;
	struct device *parent;
	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;

	parent = pdev->dev.parent;
	if (parent && parent->of_node) {
		iod->grf = syscon_node_to_regmap(parent->of_node);
	} else {
		dev_dbg(&pdev->dev, "falling back to old binding\n");
		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");
Commit	Line	Data
662a9586 HS	1	/*
	2	* Rockchip IO Voltage Domain driver
	3	*
	4	* Copyright 2014 MundoReader S.L.
	5	* Copyright 2014 Google, Inc.
	6	*
	7	* This software is licensed under the terms of the GNU General Public
	8	* License version 2, as published by the Free Software Foundation, and
	9	* may be copied, distributed, and modified under those terms.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*/
	16
	17	#include <linux/kernel.h>
	18	#include <linux/module.h>
	19	#include <linux/err.h>
	20	#include <linux/mfd/syscon.h>
	21	#include <linux/of.h>
	22	#include <linux/platform_device.h>
	23	#include <linux/regmap.h>
	24	#include <linux/regulator/consumer.h>
	25
	26	#define MAX_SUPPLIES 16
	27
	28	/*
	29	* The max voltage for 1.8V and 3.3V come from the Rockchip datasheet under
	30	* "Recommended Operating Conditions" for "Digital GPIO". When the typical
	31	* is 3.3V the max is 3.6V. When the typical is 1.8V the max is 1.98V.
	32	*
	33	* They are used like this:
	34	* - If the voltage on a rail is above the "1.8" voltage (1.98V) we'll tell the
	35	* SoC we're at 3.3.
	36	* - If the voltage on a rail is above the "3.3" voltage (3.6V) we'll consider
	37	* that to be an error.
	38	*/
	39	#define MAX_VOLTAGE_1_8 1980000
	40	#define MAX_VOLTAGE_3_3 3600000
	41
	42	#define RK3288_SOC_CON2 0x24c
	43	#define RK3288_SOC_CON2_FLASH0 BIT(7)
	44	#define RK3288_SOC_FLASH_SUPPLY_NUM 2
	45
7db36b1c DW	46	#define RK3328_SOC_CON4 0x410
	47	#define RK3328_SOC_CON4_VCCIO2 BIT(7)
	48	#define RK3328_SOC_VCCIO2_SUPPLY_NUM 1
	49
3fc147e9 HS	50	#define RK3368_SOC_CON15 0x43c
	51	#define RK3368_SOC_CON15_FLASH0 BIT(14)
	52	#define RK3368_SOC_FLASH_SUPPLY_NUM 2
	53
f447671b DW	54	#define RK3399_PMUGRF_CON0 0x180
	55	#define RK3399_PMUGRF_CON0_VSEL BIT(8)
	56	#define RK3399_PMUGRF_VSEL_SUPPLY_NUM 9
	57
662a9586 HS	58	struct rockchip_iodomain;
	59
	60	/**
	61	* @supplies: voltage settings matching the register bits.
	62	*/
	63	struct rockchip_iodomain_soc_data {
	64	int grf_offset;
	65	const char *supply_names[MAX_SUPPLIES];
	66	void (init)(struct rockchip_iodomain iod);
	67	};
	68
	69	struct rockchip_iodomain_supply {
	70	struct rockchip_iodomain *iod;
	71	struct regulator *reg;
	72	struct notifier_block nb;
	73	int idx;
	74	};
	75
	76	struct rockchip_iodomain {
	77	struct device *dev;
	78	struct regmap *grf;
	79	struct rockchip_iodomain_soc_data *soc_data;
	80	struct rockchip_iodomain_supply supplies[MAX_SUPPLIES];
	81	};
	82
	83	static int rockchip_iodomain_write(struct rockchip_iodomain_supply *supply,
	84	int uV)
	85	{
	86	struct rockchip_iodomain *iod = supply->iod;
	87	u32 val;
	88	int ret;
	89
	90	/* set value bit */
	91	val = (uV > MAX_VOLTAGE_1_8) ? 0 : 1;
	92	val <<= supply->idx;
	93
	94	/* apply hiword-mask */
	95	val \|= (BIT(supply->idx) << 16);
	96
	97	ret = regmap_write(iod->grf, iod->soc_data->grf_offset, val);
	98	if (ret)
	99	dev_err(iod->dev, "Couldn't write to GRF\n");
	100
	101	return ret;
	102	}
	103
	104	static int rockchip_iodomain_notify(struct notifier_block *nb,
	105	unsigned long event,
	106	void *data)
	107	{
	108	struct rockchip_iodomain_supply *supply =
	109	container_of(nb, struct rockchip_iodomain_supply, nb);
	110	int uV;
	111	int ret;
	112
	113	/*
	114	* According to Rockchip it's important to keep the SoC IO domain
	115	* higher than (or equal to) the external voltage. That means we need
	116	* to change it before external voltage changes happen in the case
	117	* of an increase.
	118	*
	119	* Note that in the "pre" change we pick the max possible voltage that
	120	* the regulator might end up at (the client requests a range and we
	121	* don't know for certain the exact voltage). Right now we rely on the
122	* slop in MAX_VOLTAGE_1_8 and MAX_VOLTAGE_3_3 to save us if clients
123	* request something like a max of 3.6V when they really want 3.3V.
124	* We could attempt to come up with better rules if this fails.
125	*/
126	if (event & REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) {
127	struct pre_voltage_change_data *pvc_data = data;
128
129	uV = max_t(unsigned long, pvc_data->old_uV, pvc_data->max_uV);
130	} else if (event & (REGULATOR_EVENT_VOLTAGE_CHANGE \|
131	REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE)) {
132	uV = (unsigned long)data;
133	} else {
134	return NOTIFY_OK;
135	}
136
137	dev_dbg(supply->iod->dev, "Setting to %d\n", uV);
138
139	if (uV > MAX_VOLTAGE_3_3) {
140	dev_err(supply->iod->dev, "Voltage too high: %d\n", uV);
141
142	if (event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE)
143	return NOTIFY_BAD;
144	}
145
146	ret = rockchip_iodomain_write(supply, uV);
147	if (ret && event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE)
148	return NOTIFY_BAD;
149
f5261402	150	dev_dbg(supply->iod->dev, "Setting to %d done\n", uV);
662a9586 HS	151	return NOTIFY_OK;
	152	}
	153
	154	static void rk3288_iodomain_init(struct rockchip_iodomain *iod)
	155	{
	156	int ret;
	157	u32 val;
	158
	159	/* if no flash supply we should leave things alone */
	160	if (!iod->supplies[RK3288_SOC_FLASH_SUPPLY_NUM].reg)
	161	return;
	162
	163	/*
	164	* set flash0 iodomain to also use this framework
	165	* instead of a special gpio.
	166	*/
	167	val = RK3288_SOC_CON2_FLASH0 \| (RK3288_SOC_CON2_FLASH0 << 16);
	168	ret = regmap_write(iod->grf, RK3288_SOC_CON2, val);
	169	if (ret < 0)
	170	dev_warn(iod->dev, "couldn't update flash0 ctrl\n");
	171	}
	172
7db36b1c DW	173	static void rk3328_iodomain_init(struct rockchip_iodomain *iod)
	174	{
	175	int ret;
	176	u32 val;
	177
	178	/* if no vccio2 supply we should leave things alone */
	179	if (!iod->supplies[RK3328_SOC_VCCIO2_SUPPLY_NUM].reg)
	180	return;
	181
	182	/*
	183	* set vccio2 iodomain to also use this framework
	184	* instead of a special gpio.
	185	*/
	186	val = RK3328_SOC_CON4_VCCIO2 \| (RK3328_SOC_CON4_VCCIO2 << 16);
	187	ret = regmap_write(iod->grf, RK3328_SOC_CON4, val);
	188	if (ret < 0)
	189	dev_warn(iod->dev, "couldn't update vccio2 vsel ctrl\n");
	190	}
	191
3fc147e9 HS	192	static void rk3368_iodomain_init(struct rockchip_iodomain *iod)
	193	{
	194	int ret;
	195	u32 val;
	196
	197	/* if no flash supply we should leave things alone */
	198	if (!iod->supplies[RK3368_SOC_FLASH_SUPPLY_NUM].reg)
	199	return;
	200
	201	/*
	202	* set flash0 iodomain to also use this framework
	203	* instead of a special gpio.
	204	*/
	205	val = RK3368_SOC_CON15_FLASH0 \| (RK3368_SOC_CON15_FLASH0 << 16);
	206	ret = regmap_write(iod->grf, RK3368_SOC_CON15, val);
	207	if (ret < 0)
	208	dev_warn(iod->dev, "couldn't update flash0 ctrl\n");
	209	}
	210
f447671b DW	211	static void rk3399_pmu_iodomain_init(struct rockchip_iodomain *iod)
	212	{
	213	int ret;
	214	u32 val;
	215
	216	/* if no pmu io supply we should leave things alone */
	217	if (!iod->supplies[RK3399_PMUGRF_VSEL_SUPPLY_NUM].reg)
	218	return;
	219
	220	/*
	221	* set pmu io iodomain to also use this framework
	222	* instead of a special gpio.
	223	*/
	224	val = RK3399_PMUGRF_CON0_VSEL \| (RK3399_PMUGRF_CON0_VSEL << 16);
	225	ret = regmap_write(iod->grf, RK3399_PMUGRF_CON0, val);
	226	if (ret < 0)
	227	dev_warn(iod->dev, "couldn't update pmu io iodomain ctrl\n");
	228	}
	229
662a9586 HS	230	/*
	231	* On the rk3188 the io-domains are handled by a shared register with the
	232	* lower 8 bits being still being continuing drive-strength settings.
	233	*/
	234	static const struct rockchip_iodomain_soc_data soc_data_rk3188 = {
	235	.grf_offset = 0x104,
	236	.supply_names = {
	237	NULL,
	238	NULL,
	239	NULL,
	240	NULL,
	241	NULL,
	242	NULL,
	243	NULL,
	244	NULL,
	245	"ap0",
	246	"ap1",
	247	"cif",
	248	"flash",
	249	"vccio0",
	250	"vccio1",
	251	"lcdc0",
	252	"lcdc1",
	253	},
	254	};
	255
1a99d0c7 DW	256	static const struct rockchip_iodomain_soc_data soc_data_rk3228 = {
	257	.grf_offset = 0x418,
	258	.supply_names = {
	259	"vccio1",
	260	"vccio2",
	261	"vccio3",
	262	"vccio4",
	263	},
	264	};
	265
662a9586 HS	266	static const struct rockchip_iodomain_soc_data soc_data_rk3288 = {
	267	.grf_offset = 0x380,
	268	.supply_names = {
	269	"lcdc", /* LCDC_VDD */
	270	"dvp", /* DVPIO_VDD */
	271	"flash0", /* FLASH0_VDD (emmc) */
	272	"flash1", /* FLASH1_VDD (sdio1) */
	273	"wifi", /* APIO3_VDD (sdio0) */
	274	"bb", /* APIO5_VDD */
	275	"audio", /* APIO4_VDD */
	276	"sdcard", /* SDMMC0_VDD (sdmmc) */
	277	"gpio30", /* APIO1_VDD */
	278	"gpio1830", /* APIO2_VDD */
	279	},
	280	.init = rk3288_iodomain_init,
	281	};
	282
7db36b1c DW	283	static const struct rockchip_iodomain_soc_data soc_data_rk3328 = {
	284	.grf_offset = 0x410,
	285	.supply_names = {
	286	"vccio1",
	287	"vccio2",
	288	"vccio3",
	289	"vccio4",
	290	"vccio5",
	291	"vccio6",
	292	"pmuio",
	293	},
	294	.init = rk3328_iodomain_init,
	295	};
	296
3fc147e9 HS	297	static const struct rockchip_iodomain_soc_data soc_data_rk3368 = {
	298	.grf_offset = 0x900,
	299	.supply_names = {
	300	NULL, /* reserved */
	301	"dvp", /* DVPIO_VDD */
	302	"flash0", /* FLASH0_VDD (emmc) */
	303	"wifi", /* APIO2_VDD (sdio0) */
	304	NULL,
	305	"audio", /* APIO3_VDD */
	306	"sdcard", /* SDMMC0_VDD (sdmmc) */
	307	"gpio30", /* APIO1_VDD */
	308	"gpio1830", /* APIO4_VDD (gpujtag) */
	309	},
	310	.init = rk3368_iodomain_init,
	311	};
	312
	313	static const struct rockchip_iodomain_soc_data soc_data_rk3368_pmu = {
	314	.grf_offset = 0x100,
	315	.supply_names = {
	316	NULL,
	317	NULL,
	318	NULL,
	319	NULL,
	320	"pmu", /PMU IO domain/
	321	"vop", /LCDC IO domain/
	322	},
	323	};
	324
f447671b DW	325	static const struct rockchip_iodomain_soc_data soc_data_rk3399 = {
	326	.grf_offset = 0xe640,
	327	.supply_names = {
	328	"bt656", /* APIO2_VDD */
	329	"audio", /* APIO5_VDD */
	330	"sdmmc", /* SDMMC0_VDD */
	331	"gpio1830", /* APIO4_VDD */
	332	},
	333	};
	334
	335	static const struct rockchip_iodomain_soc_data soc_data_rk3399_pmu = {
	336	.grf_offset = 0x180,
	337	.supply_names = {
	338	NULL,
	339	NULL,
	340	NULL,
	341	NULL,
	342	NULL,
	343	NULL,
	344	NULL,
	345	NULL,
	346	NULL,
	347	"pmu1830", /* PMUIO2_VDD */
	348	},
	349	.init = rk3399_pmu_iodomain_init,
	350	};
	351
662a9586 HS	352	static const struct of_device_id rockchip_iodomain_match[] = {
	353	{
	354	.compatible = "rockchip,rk3188-io-voltage-domain",
	355	.data = (void *)&soc_data_rk3188
	356	},
1a99d0c7 DW	357	{
	358	.compatible = "rockchip,rk3228-io-voltage-domain",
	359	.data = (void *)&soc_data_rk3228
	360	},
662a9586 HS	361	{
	362	.compatible = "rockchip,rk3288-io-voltage-domain",
	363	.data = (void *)&soc_data_rk3288
	364	},
7db36b1c DW	365	{
	366	.compatible = "rockchip,rk3328-io-voltage-domain",
	367	.data = (void *)&soc_data_rk3328
	368	},
3fc147e9 HS	369	{
	370	.compatible = "rockchip,rk3368-io-voltage-domain",
	371	.data = (void *)&soc_data_rk3368
	372	},
	373	{
	374	.compatible = "rockchip,rk3368-pmu-io-voltage-domain",
	375	.data = (void *)&soc_data_rk3368_pmu
	376	},
f447671b DW	377	{
	378	.compatible = "rockchip,rk3399-io-voltage-domain",
	379	.data = (void *)&soc_data_rk3399
	380	},
	381	{
	382	.compatible = "rockchip,rk3399-pmu-io-voltage-domain",
	383	.data = (void *)&soc_data_rk3399_pmu
	384	},
662a9586 HS	385	{ /* sentinel */ },
662a9586 HS	386	};
fa743d96	387	MODULE_DEVICE_TABLE(of, rockchip_iodomain_match);
662a9586 HS	388
	389	static int rockchip_iodomain_probe(struct platform_device *pdev)
	390	{
	391	struct device_node *np = pdev->dev.of_node;
	392	const struct of_device_id *match;
	393	struct rockchip_iodomain *iod;
bc19b9a8	394	struct device *parent;
662a9586 HS	395	int i, ret = 0;
	396
	397	if (!np)
	398	return -ENODEV;
	399
	400	iod = devm_kzalloc(&pdev->dev, sizeof(*iod), GFP_KERNEL);
	401	if (!iod)
	402	return -ENOMEM;
	403
	404	iod->dev = &pdev->dev;
	405	platform_set_drvdata(pdev, iod);
	406
	407	match = of_match_node(rockchip_iodomain_match, np);
	408	iod->soc_data = (struct rockchip_iodomain_soc_data *)match->data;
	409
bc19b9a8 HS	410	parent = pdev->dev.parent;
	411	if (parent && parent->of_node) {
	412	iod->grf = syscon_node_to_regmap(parent->of_node);
	413	} else {
	414	dev_dbg(&pdev->dev, "falling back to old binding\n");
	415	iod->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
	416	}
	417
662a9586 HS	418	if (IS_ERR(iod->grf)) {
	419	dev_err(&pdev->dev, "couldn't find grf regmap\n");
	420	return PTR_ERR(iod->grf);
	421	}
	422
	423	for (i = 0; i < MAX_SUPPLIES; i++) {
	424	const char *supply_name = iod->soc_data->supply_names[i];
	425	struct rockchip_iodomain_supply *supply = &iod->supplies[i];
	426	struct regulator *reg;
	427	int uV;
	428
	429	if (!supply_name)
	430	continue;
	431
	432	reg = devm_regulator_get_optional(iod->dev, supply_name);
	433	if (IS_ERR(reg)) {
	434	ret = PTR_ERR(reg);
	435
	436	/* If a supply wasn't specified, that's OK */
	437	if (ret == -ENODEV)
	438	continue;
	439	else if (ret != -EPROBE_DEFER)
	440	dev_err(iod->dev, "couldn't get regulator %s\n",
	441	supply_name);
	442	goto unreg_notify;
	443	}
	444
	445	/* set initial correct value */
	446	uV = regulator_get_voltage(reg);
	447
	448	/* must be a regulator we can get the voltage of */
	449	if (uV < 0) {
	450	dev_err(iod->dev, "Can't determine voltage: %s\n",
	451	supply_name);
	452	goto unreg_notify;
	453	}
	454
	455	if (uV > MAX_VOLTAGE_3_3) {
	456	dev_crit(iod->dev,
	457	"%d uV is too high. May damage SoC!\n",
	458	uV);
	459	ret = -EINVAL;
	460	goto unreg_notify;
	461	}
	462
	463	/* setup our supply */
	464	supply->idx = i;
	465	supply->iod = iod;
	466	supply->reg = reg;
	467	supply->nb.notifier_call = rockchip_iodomain_notify;
	468
	469	ret = rockchip_iodomain_write(supply, uV);
	470	if (ret) {
	471	supply->reg = NULL;
	472	goto unreg_notify;
	473	}
	474
	475	/* register regulator notifier */
	476	ret = regulator_register_notifier(reg, &supply->nb);
	477	if (ret) {
	478	dev_err(&pdev->dev,
	479	"regulator notifier request failed\n");
	480	supply->reg = NULL;
	481	goto unreg_notify;
482	}
483	}
484
485	if (iod->soc_data->init)
486	iod->soc_data->init(iod);
487
488	return 0;
489
490	unreg_notify:
491	for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
492	struct rockchip_iodomain_supply *io_supply = &iod->supplies[i];
493
494	if (io_supply->reg)
495	regulator_unregister_notifier(io_supply->reg,
496	&io_supply->nb);
497	}
498
499	return ret;
500	}
501
502	static int rockchip_iodomain_remove(struct platform_device *pdev)
503	{
504	struct rockchip_iodomain *iod = platform_get_drvdata(pdev);
505	int i;
506
507	for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
508	struct rockchip_iodomain_supply *io_supply = &iod->supplies[i];
509
510	if (io_supply->reg)
511	regulator_unregister_notifier(io_supply->reg,
512	&io_supply->nb);
513	}
514
515	return 0;
516	}
517
518	static struct platform_driver rockchip_iodomain_driver = {
519	.probe = rockchip_iodomain_probe,
520	.remove = rockchip_iodomain_remove,
521	.driver = {
522	.name = "rockchip-iodomain",
523	.of_match_table = rockchip_iodomain_match,
524	},
525	};
526
527	module_platform_driver(rockchip_iodomain_driver);
528
529	MODULE_DESCRIPTION("Rockchip IO-domain driver");
530	MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
531	MODULE_AUTHOR("Doug Anderson <dianders@chromium.org>");
532	MODULE_LICENSE("GPL v2");