[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / regulator / db8500-prcmu.c

/*
 * Copyright (C) ST-Ericsson SA 2010
 *
 * License Terms: GNU General Public License v2
 * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
 *          Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
 *
 * Power domain regulators on DB8500
 */

#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/err.h>
#include <linux/spinlock.h>
#include <linux/platform_device.h>
#include <linux/mfd/dbx500-prcmu.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/db8500-prcmu.h>
#include <linux/regulator/of_regulator.h>
#include <linux/of.h>
#include <linux/module.h>
#include "dbx500-prcmu.h"

static int db8500_regulator_enable(struct regulator_dev *rdev)
{
	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);

	if (info == NULL)
		return -EINVAL;

	dev_vdbg(rdev_get_dev(rdev), "regulator-%s-enable\n",
		info->desc.name);

	if (!info->is_enabled) {
		info->is_enabled = true;
		if (!info->exclude_from_power_state)
			power_state_active_enable();
	}

	return 0;
}

static int db8500_regulator_disable(struct regulator_dev *rdev)
{
	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
	int ret = 0;

	if (info == NULL)
		return -EINVAL;

	dev_vdbg(rdev_get_dev(rdev), "regulator-%s-disable\n",
		info->desc.name);

	if (info->is_enabled) {
		info->is_enabled = false;
		if (!info->exclude_from_power_state)
			ret = power_state_active_disable();
	}

	return ret;
}

static int db8500_regulator_is_enabled(struct regulator_dev *rdev)
{
	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);

	if (info == NULL)
		return -EINVAL;

	dev_vdbg(rdev_get_dev(rdev), "regulator-%s-is_enabled (is_enabled):"
		" %i\n", info->desc.name, info->is_enabled);

	return info->is_enabled;
}

/* db8500 regulator operations */
static struct regulator_ops db8500_regulator_ops = {
	.enable			= db8500_regulator_enable,
	.disable		= db8500_regulator_disable,
	.is_enabled		= db8500_regulator_is_enabled,
};

/*
 * EPOD control
 */
static bool epod_on[NUM_EPOD_ID];
static bool epod_ramret[NUM_EPOD_ID];

static int enable_epod(u16 epod_id, bool ramret)
{
	int ret;

	if (ramret) {
		if (!epod_on[epod_id]) {
			ret = prcmu_set_epod(epod_id, EPOD_STATE_RAMRET);
			if (ret < 0)
				return ret;
		}
		epod_ramret[epod_id] = true;
	} else {
		ret = prcmu_set_epod(epod_id, EPOD_STATE_ON);
		if (ret < 0)
			return ret;
		epod_on[epod_id] = true;
	}

	return 0;
}

static int disable_epod(u16 epod_id, bool ramret)
{
	int ret;

	if (ramret) {
		if (!epod_on[epod_id]) {
			ret = prcmu_set_epod(epod_id, EPOD_STATE_OFF);
			if (ret < 0)
				return ret;
		}
		epod_ramret[epod_id] = false;
	} else {
		if (epod_ramret[epod_id]) {
			ret = prcmu_set_epod(epod_id, EPOD_STATE_RAMRET);
			if (ret < 0)
				return ret;
		} else {
			ret = prcmu_set_epod(epod_id, EPOD_STATE_OFF);
			if (ret < 0)
				return ret;
		}
		epod_on[epod_id] = false;
	}

	return 0;
}

/*
 * Regulator switch
 */
static int db8500_regulator_switch_enable(struct regulator_dev *rdev)
{
	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
	int ret;

	if (info == NULL)
		return -EINVAL;

	dev_vdbg(rdev_get_dev(rdev), "regulator-switch-%s-enable\n",
		info->desc.name);

	ret = enable_epod(info->epod_id, info->is_ramret);
	if (ret < 0) {
		dev_err(rdev_get_dev(rdev),
			"regulator-switch-%s-enable: prcmu call failed\n",
			info->desc.name);
		goto out;
	}

	info->is_enabled = true;
out:
	return ret;
}

static int db8500_regulator_switch_disable(struct regulator_dev *rdev)
{
	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
	int ret;

	if (info == NULL)
		return -EINVAL;

	dev_vdbg(rdev_get_dev(rdev), "regulator-switch-%s-disable\n",
		info->desc.name);

	ret = disable_epod(info->epod_id, info->is_ramret);
	if (ret < 0) {
		dev_err(rdev_get_dev(rdev),
			"regulator_switch-%s-disable: prcmu call failed\n",
			info->desc.name);
		goto out;
	}

	info->is_enabled = 0;
out:
	return ret;
}

static int db8500_regulator_switch_is_enabled(struct regulator_dev *rdev)
{
	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);

	if (info == NULL)
		return -EINVAL;

	dev_vdbg(rdev_get_dev(rdev),
		"regulator-switch-%s-is_enabled (is_enabled): %i\n",
		info->desc.name, info->is_enabled);

	return info->is_enabled;
}

static struct regulator_ops db8500_regulator_switch_ops = {
	.enable			= db8500_regulator_switch_enable,
	.disable		= db8500_regulator_switch_disable,
	.is_enabled		= db8500_regulator_switch_is_enabled,
};

/*
 * Regulator information
 */
static struct dbx500_regulator_info
dbx500_regulator_info[DB8500_NUM_REGULATORS] = {
	[DB8500_REGULATOR_VAPE] = {
		.desc = {
			.name	= "db8500-vape",
			.id	= DB8500_REGULATOR_VAPE,
			.ops	= &db8500_regulator_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
	},
	[DB8500_REGULATOR_VARM] = {
		.desc = {
			.name	= "db8500-varm",
			.id	= DB8500_REGULATOR_VARM,
			.ops	= &db8500_regulator_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
	},
	[DB8500_REGULATOR_VMODEM] = {
		.desc = {
			.name	= "db8500-vmodem",
			.id	= DB8500_REGULATOR_VMODEM,
			.ops	= &db8500_regulator_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
	},
	[DB8500_REGULATOR_VPLL] = {
		.desc = {
			.name	= "db8500-vpll",
			.id	= DB8500_REGULATOR_VPLL,
			.ops	= &db8500_regulator_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
	},
	[DB8500_REGULATOR_VSMPS1] = {
		.desc = {
			.name	= "db8500-vsmps1",
			.id	= DB8500_REGULATOR_VSMPS1,
			.ops	= &db8500_regulator_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
	},
	[DB8500_REGULATOR_VSMPS2] = {
		.desc = {
			.name	= "db8500-vsmps2",
			.id	= DB8500_REGULATOR_VSMPS2,
			.ops	= &db8500_regulator_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.exclude_from_power_state = true,
	},
	[DB8500_REGULATOR_VSMPS3] = {
		.desc = {
			.name	= "db8500-vsmps3",
			.id	= DB8500_REGULATOR_VSMPS3,
			.ops	= &db8500_regulator_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
	},
	[DB8500_REGULATOR_VRF1] = {
		.desc = {
			.name	= "db8500-vrf1",
			.id	= DB8500_REGULATOR_VRF1,
			.ops	= &db8500_regulator_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
	},
	[DB8500_REGULATOR_SWITCH_SVAMMDSP] = {
		.desc = {
			.name	= "db8500-sva-mmdsp",
			.id	= DB8500_REGULATOR_SWITCH_SVAMMDSP,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_SVAMMDSP,
	},
	[DB8500_REGULATOR_SWITCH_SVAMMDSPRET] = {
		.desc = {
			.name	= "db8500-sva-mmdsp-ret",
			.id	= DB8500_REGULATOR_SWITCH_SVAMMDSPRET,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_SVAMMDSP,
		.is_ramret = true,
	},
	[DB8500_REGULATOR_SWITCH_SVAPIPE] = {
		.desc = {
			.name	= "db8500-sva-pipe",
			.id	= DB8500_REGULATOR_SWITCH_SVAPIPE,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_SVAPIPE,
	},
	[DB8500_REGULATOR_SWITCH_SIAMMDSP] = {
		.desc = {
			.name	= "db8500-sia-mmdsp",
			.id	= DB8500_REGULATOR_SWITCH_SIAMMDSP,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_SIAMMDSP,
	},
	[DB8500_REGULATOR_SWITCH_SIAMMDSPRET] = {
		.desc = {
			.name	= "db8500-sia-mmdsp-ret",
			.id	= DB8500_REGULATOR_SWITCH_SIAMMDSPRET,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_SIAMMDSP,
		.is_ramret = true,
	},
	[DB8500_REGULATOR_SWITCH_SIAPIPE] = {
		.desc = {
			.name	= "db8500-sia-pipe",
			.id	= DB8500_REGULATOR_SWITCH_SIAPIPE,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_SIAPIPE,
	},
	[DB8500_REGULATOR_SWITCH_SGA] = {
		.desc = {
			.name	= "db8500-sga",
			.id	= DB8500_REGULATOR_SWITCH_SGA,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_SGA,
	},
	[DB8500_REGULATOR_SWITCH_B2R2_MCDE] = {
		.desc = {
			.name	= "db8500-b2r2-mcde",
			.id	= DB8500_REGULATOR_SWITCH_B2R2_MCDE,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_B2R2_MCDE,
	},
	[DB8500_REGULATOR_SWITCH_ESRAM12] = {
		.desc = {
			.name	= "db8500-esram12",
			.id	= DB8500_REGULATOR_SWITCH_ESRAM12,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id	= EPOD_ID_ESRAM12,
		.is_enabled	= true,
	},
	[DB8500_REGULATOR_SWITCH_ESRAM12RET] = {
		.desc = {
			.name	= "db8500-esram12-ret",
			.id	= DB8500_REGULATOR_SWITCH_ESRAM12RET,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_ESRAM12,
		.is_ramret = true,
	},
	[DB8500_REGULATOR_SWITCH_ESRAM34] = {
		.desc = {
			.name	= "db8500-esram34",
			.id	= DB8500_REGULATOR_SWITCH_ESRAM34,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id	= EPOD_ID_ESRAM34,
		.is_enabled	= true,
	},
	[DB8500_REGULATOR_SWITCH_ESRAM34RET] = {
		.desc = {
			.name	= "db8500-esram34-ret",
			.id	= DB8500_REGULATOR_SWITCH_ESRAM34RET,
			.ops	= &db8500_regulator_switch_ops,
			.type	= REGULATOR_VOLTAGE,
			.owner	= THIS_MODULE,
		},
		.epod_id = EPOD_ID_ESRAM34,
		.is_ramret = true,
	},
};

static int db8500_regulator_register(struct platform_device *pdev,
					struct regulator_init_data *init_data,
					int id,
					struct device_node *np)
{
	struct dbx500_regulator_info *info;
	struct regulator_config config = { };
	int err;

	/* assign per-regulator data */
	info = &dbx500_regulator_info[id];
	info->dev = &pdev->dev;

	config.dev = &pdev->dev;
	config.init_data = init_data;
	config.driver_data = info;
	config.of_node = np;

	/* register with the regulator framework */
	info->rdev = regulator_register(&info->desc, &config);
	if (IS_ERR(info->rdev)) {
		err = PTR_ERR(info->rdev);
		dev_err(&pdev->dev, "failed to register %s: err %i\n",
			info->desc.name, err);

		/* if failing, unregister all earlier regulators */
		while (--id >= 0) {
			info = &dbx500_regulator_info[id];
			regulator_unregister(info->rdev);
		}
		return err;
	}

	dev_dbg(rdev_get_dev(info->rdev),
		"regulator-%s-probed\n", info->desc.name);

	return 0;
}

static struct of_regulator_match db8500_regulator_matches[] = {
	{ .name	= "db8500_vape",          .driver_data = (void *) DB8500_REGULATOR_VAPE, },
	{ .name	= "db8500_varm",          .driver_data = (void *) DB8500_REGULATOR_VARM, },
	{ .name	= "db8500_vmodem",        .driver_data = (void *) DB8500_REGULATOR_VMODEM, },
	{ .name	= "db8500_vpll",          .driver_data = (void *) DB8500_REGULATOR_VPLL, },
	{ .name	= "db8500_vsmps1",        .driver_data = (void *) DB8500_REGULATOR_VSMPS1, },
	{ .name	= "db8500_vsmps2",        .driver_data = (void *) DB8500_REGULATOR_VSMPS2, },
	{ .name	= "db8500_vsmps3",        .driver_data = (void *) DB8500_REGULATOR_VSMPS3, },
	{ .name	= "db8500_vrf1",          .driver_data = (void *) DB8500_REGULATOR_VRF1, },
	{ .name	= "db8500_sva_mmdsp",     .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAMMDSP, },
	{ .name	= "db8500_sva_mmdsp_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAMMDSPRET, },
	{ .name	= "db8500_sva_pipe",      .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAPIPE, },
	{ .name	= "db8500_sia_mmdsp",     .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAMMDSP, },
	{ .name	= "db8500_sia_mmdsp_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAMMDSPRET, },
	{ .name	= "db8500_sia_pipe",      .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAPIPE, },
	{ .name	= "db8500_sga",           .driver_data = (void *) DB8500_REGULATOR_SWITCH_SGA, },
	{ .name	= "db8500_b2r2_mcde",     .driver_data = (void *) DB8500_REGULATOR_SWITCH_B2R2_MCDE, },
	{ .name	= "db8500_esram12",       .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM12, },
	{ .name	= "db8500_esram12_ret",   .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM12RET, },
	{ .name	= "db8500_esram34",       .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM34, },
	{ .name	= "db8500_esram34_ret",   .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM34RET, },
};

static int
db8500_regulator_of_probe(struct platform_device *pdev,
			struct device_node *np)
{
	int i, err;

	for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
		err = db8500_regulator_register(
			pdev, db8500_regulator_matches[i].init_data,
			i, db8500_regulator_matches[i].of_node);
		if (err)
			return err;
	}

	return 0;
}

static int db8500_regulator_probe(struct platform_device *pdev)
{
	struct regulator_init_data *db8500_init_data =
					dev_get_platdata(&pdev->dev);
	struct device_node *np = pdev->dev.of_node;
	int i, err;

	/* register all regulators */
	if (np) {
		err = of_regulator_match(&pdev->dev, np,
					db8500_regulator_matches,
					ARRAY_SIZE(db8500_regulator_matches));
		if (err < 0) {
			dev_err(&pdev->dev,
				"Error parsing regulator init data: %d\n", err);
			return err;
		}

		err = db8500_regulator_of_probe(pdev, np);
		if (err)
			return err;
	} else {
		for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
			err = db8500_regulator_register(pdev,
							&db8500_init_data[i],
							i, NULL);
			if (err)
				return err;
		}
	}

	err = ux500_regulator_debug_init(pdev,
					 dbx500_regulator_info,
					 ARRAY_SIZE(dbx500_regulator_info));
	return 0;
}

static int db8500_regulator_remove(struct platform_device *pdev)
{
	int i;

	ux500_regulator_debug_exit();

	for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
		struct dbx500_regulator_info *info;
		info = &dbx500_regulator_info[i];

		dev_vdbg(rdev_get_dev(info->rdev),
			"regulator-%s-remove\n", info->desc.name);

		regulator_unregister(info->rdev);
	}

	return 0;
}

static struct platform_driver db8500_regulator_driver = {
	.driver = {
		.name = "db8500-prcmu-regulators",
		.owner = THIS_MODULE,
	},
	.probe = db8500_regulator_probe,
	.remove = db8500_regulator_remove,
};

static int __init db8500_regulator_init(void)
{
	return platform_driver_register(&db8500_regulator_driver);
}

static void __exit db8500_regulator_exit(void)
{
	platform_driver_unregister(&db8500_regulator_driver);
}

arch_initcall(db8500_regulator_init);
module_exit(db8500_regulator_exit);

MODULE_AUTHOR("STMicroelectronics/ST-Ericsson");
MODULE_DESCRIPTION("DB8500 regulator driver");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
1032fbfd BJ	1	/*
	2	* Copyright (C) ST-Ericsson SA 2010
	3	*
	4	* License Terms: GNU General Public License v2
	5	* Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
	6	* Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
	7	*
	8	* Power domain regulators on DB8500
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/init.h>
	13	#include <linux/err.h>
	14	#include <linux/spinlock.h>
	15	#include <linux/platform_device.h>
73180f85	16	#include <linux/mfd/dbx500-prcmu.h>
1032fbfd BJ	17	#include <linux/regulator/driver.h>
	18	#include <linux/regulator/machine.h>
	19	#include <linux/regulator/db8500-prcmu.h>
1bdd670a LJ	20	#include <linux/regulator/of_regulator.h>
1bdd670a LJ	21	#include <linux/of.h>
65602c32	22	#include <linux/module.h>
38e96838	23	#include "dbx500-prcmu.h"
1032fbfd BJ	24
	25	static int db8500_regulator_enable(struct regulator_dev *rdev)
	26	{
38e96838	27	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
1032fbfd BJ	28
	29	if (info == NULL)
	30	return -EINVAL;
	31
	32	dev_vdbg(rdev_get_dev(rdev), "regulator-%s-enable\n",
	33	info->desc.name);
	34
38e96838 BJ	35	if (!info->is_enabled) {
	36	info->is_enabled = true;
	37	if (!info->exclude_from_power_state)
	38	power_state_active_enable();
	39	}
1032fbfd BJ	40
	41	return 0;
	42	}
	43
	44	static int db8500_regulator_disable(struct regulator_dev *rdev)
	45	{
38e96838	46	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
1032fbfd BJ	47	int ret = 0;
	48
	49	if (info == NULL)
	50	return -EINVAL;
	51
	52	dev_vdbg(rdev_get_dev(rdev), "regulator-%s-disable\n",
	53	info->desc.name);
	54
38e96838 BJ	55	if (info->is_enabled) {
	56	info->is_enabled = false;
	57	if (!info->exclude_from_power_state)
	58	ret = power_state_active_disable();
	59	}
1032fbfd BJ	60
	61	return ret;
	62	}
	63
	64	static int db8500_regulator_is_enabled(struct regulator_dev *rdev)
	65	{
38e96838	66	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
1032fbfd BJ	67
	68	if (info == NULL)
	69	return -EINVAL;
	70
	71	dev_vdbg(rdev_get_dev(rdev), "regulator-%s-is_enabled (is_enabled):"
	72	" %i\n", info->desc.name, info->is_enabled);
	73
	74	return info->is_enabled;
	75	}
	76
	77	/* db8500 regulator operations */
	78	static struct regulator_ops db8500_regulator_ops = {
	79	.enable = db8500_regulator_enable,
	80	.disable = db8500_regulator_disable,
	81	.is_enabled = db8500_regulator_is_enabled,
	82	};
	83
	84	/*
	85	* EPOD control
	86	*/
	87	static bool epod_on[NUM_EPOD_ID];
	88	static bool epod_ramret[NUM_EPOD_ID];
	89
	90	static int enable_epod(u16 epod_id, bool ramret)
	91	{
	92	int ret;
	93
	94	if (ramret) {
	95	if (!epod_on[epod_id]) {
	96	ret = prcmu_set_epod(epod_id, EPOD_STATE_RAMRET);
	97	if (ret < 0)
	98	return ret;
	99	}
	100	epod_ramret[epod_id] = true;
	101	} else {
	102	ret = prcmu_set_epod(epod_id, EPOD_STATE_ON);
	103	if (ret < 0)
	104	return ret;
	105	epod_on[epod_id] = true;
	106	}
	107
	108	return 0;
	109	}
	110
	111	static int disable_epod(u16 epod_id, bool ramret)
	112	{
	113	int ret;
	114
	115	if (ramret) {
	116	if (!epod_on[epod_id]) {
	117	ret = prcmu_set_epod(epod_id, EPOD_STATE_OFF);
	118	if (ret < 0)
	119	return ret;
	120	}
	121	epod_ramret[epod_id] = false;
	122	} else {
	123	if (epod_ramret[epod_id]) {
	124	ret = prcmu_set_epod(epod_id, EPOD_STATE_RAMRET);
	125	if (ret < 0)
	126	return ret;
	127	} else {
	128	ret = prcmu_set_epod(epod_id, EPOD_STATE_OFF);
	129	if (ret < 0)
	130	return ret;
131	}
132	epod_on[epod_id] = false;
133	}
134
135	return 0;
136	}
137
138	/*
139	* Regulator switch
140	*/
141	static int db8500_regulator_switch_enable(struct regulator_dev *rdev)
142	{
38e96838	143	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
1032fbfd BJ	144	int ret;
	145
	146	if (info == NULL)
	147	return -EINVAL;
	148
	149	dev_vdbg(rdev_get_dev(rdev), "regulator-switch-%s-enable\n",
	150	info->desc.name);
	151
	152	ret = enable_epod(info->epod_id, info->is_ramret);
	153	if (ret < 0) {
	154	dev_err(rdev_get_dev(rdev),
	155	"regulator-switch-%s-enable: prcmu call failed\n",
	156	info->desc.name);
	157	goto out;
	158	}
	159
	160	info->is_enabled = true;
	161	out:
	162	return ret;
	163	}
	164
	165	static int db8500_regulator_switch_disable(struct regulator_dev *rdev)
	166	{
38e96838	167	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
1032fbfd BJ	168	int ret;
	169
	170	if (info == NULL)
	171	return -EINVAL;
	172
	173	dev_vdbg(rdev_get_dev(rdev), "regulator-switch-%s-disable\n",
	174	info->desc.name);
	175
	176	ret = disable_epod(info->epod_id, info->is_ramret);
	177	if (ret < 0) {
	178	dev_err(rdev_get_dev(rdev),
	179	"regulator_switch-%s-disable: prcmu call failed\n",
	180	info->desc.name);
	181	goto out;
	182	}
	183
	184	info->is_enabled = 0;
	185	out:
	186	return ret;
	187	}
	188
	189	static int db8500_regulator_switch_is_enabled(struct regulator_dev *rdev)
	190	{
38e96838	191	struct dbx500_regulator_info *info = rdev_get_drvdata(rdev);
1032fbfd BJ	192
	193	if (info == NULL)
	194	return -EINVAL;
	195
	196	dev_vdbg(rdev_get_dev(rdev),
	197	"regulator-switch-%s-is_enabled (is_enabled): %i\n",
	198	info->desc.name, info->is_enabled);
	199
	200	return info->is_enabled;
	201	}
	202
	203	static struct regulator_ops db8500_regulator_switch_ops = {
	204	.enable = db8500_regulator_switch_enable,
	205	.disable = db8500_regulator_switch_disable,
	206	.is_enabled = db8500_regulator_switch_is_enabled,
	207	};
	208
	209	/*
	210	* Regulator information
	211	*/
38e96838 BJ	212	static struct dbx500_regulator_info
38e96838 BJ	213	dbx500_regulator_info[DB8500_NUM_REGULATORS] = {
1032fbfd BJ	214	[DB8500_REGULATOR_VAPE] = {
	215	.desc = {
	216	.name = "db8500-vape",
	217	.id = DB8500_REGULATOR_VAPE,
	218	.ops = &db8500_regulator_ops,
	219	.type = REGULATOR_VOLTAGE,
	220	.owner = THIS_MODULE,
	221	},
	222	},
	223	[DB8500_REGULATOR_VARM] = {
	224	.desc = {
	225	.name = "db8500-varm",
	226	.id = DB8500_REGULATOR_VARM,
	227	.ops = &db8500_regulator_ops,
	228	.type = REGULATOR_VOLTAGE,
	229	.owner = THIS_MODULE,
	230	},
	231	},
	232	[DB8500_REGULATOR_VMODEM] = {
	233	.desc = {
	234	.name = "db8500-vmodem",
	235	.id = DB8500_REGULATOR_VMODEM,
	236	.ops = &db8500_regulator_ops,
	237	.type = REGULATOR_VOLTAGE,
	238	.owner = THIS_MODULE,
	239	},
	240	},
	241	[DB8500_REGULATOR_VPLL] = {
	242	.desc = {
	243	.name = "db8500-vpll",
	244	.id = DB8500_REGULATOR_VPLL,
	245	.ops = &db8500_regulator_ops,
	246	.type = REGULATOR_VOLTAGE,
	247	.owner = THIS_MODULE,
	248	},
	249	},
	250	[DB8500_REGULATOR_VSMPS1] = {
	251	.desc = {
	252	.name = "db8500-vsmps1",
	253	.id = DB8500_REGULATOR_VSMPS1,
	254	.ops = &db8500_regulator_ops,
	255	.type = REGULATOR_VOLTAGE,
	256	.owner = THIS_MODULE,
	257	},
	258	},
	259	[DB8500_REGULATOR_VSMPS2] = {
	260	.desc = {
	261	.name = "db8500-vsmps2",
	262	.id = DB8500_REGULATOR_VSMPS2,
	263	.ops = &db8500_regulator_ops,
	264	.type = REGULATOR_VOLTAGE,
	265	.owner = THIS_MODULE,
	266	},
	267	.exclude_from_power_state = true,
	268	},
	269	[DB8500_REGULATOR_VSMPS3] = {
	270	.desc = {
	271	.name = "db8500-vsmps3",
	272	.id = DB8500_REGULATOR_VSMPS3,
	273	.ops = &db8500_regulator_ops,
	274	.type = REGULATOR_VOLTAGE,
	275	.owner = THIS_MODULE,
	276	},
	277	},
278	[DB8500_REGULATOR_VRF1] = {
279	.desc = {
280	.name = "db8500-vrf1",
281	.id = DB8500_REGULATOR_VRF1,
282	.ops = &db8500_regulator_ops,
283	.type = REGULATOR_VOLTAGE,
284	.owner = THIS_MODULE,
285	},
286	},
287	[DB8500_REGULATOR_SWITCH_SVAMMDSP] = {
288	.desc = {
289	.name = "db8500-sva-mmdsp",
290	.id = DB8500_REGULATOR_SWITCH_SVAMMDSP,
291	.ops = &db8500_regulator_switch_ops,
292	.type = REGULATOR_VOLTAGE,
293	.owner = THIS_MODULE,
294	},
295	.epod_id = EPOD_ID_SVAMMDSP,
296	},
297	[DB8500_REGULATOR_SWITCH_SVAMMDSPRET] = {
298	.desc = {
299	.name = "db8500-sva-mmdsp-ret",
300	.id = DB8500_REGULATOR_SWITCH_SVAMMDSPRET,
301	.ops = &db8500_regulator_switch_ops,
302	.type = REGULATOR_VOLTAGE,
303	.owner = THIS_MODULE,
304	},
305	.epod_id = EPOD_ID_SVAMMDSP,
306	.is_ramret = true,
307	},
308	[DB8500_REGULATOR_SWITCH_SVAPIPE] = {
309	.desc = {
310	.name = "db8500-sva-pipe",
311	.id = DB8500_REGULATOR_SWITCH_SVAPIPE,
312	.ops = &db8500_regulator_switch_ops,
313	.type = REGULATOR_VOLTAGE,
314	.owner = THIS_MODULE,
315	},
316	.epod_id = EPOD_ID_SVAPIPE,
317	},
318	[DB8500_REGULATOR_SWITCH_SIAMMDSP] = {
319	.desc = {
320	.name = "db8500-sia-mmdsp",
321	.id = DB8500_REGULATOR_SWITCH_SIAMMDSP,
322	.ops = &db8500_regulator_switch_ops,
323	.type = REGULATOR_VOLTAGE,
324	.owner = THIS_MODULE,
325	},
326	.epod_id = EPOD_ID_SIAMMDSP,
327	},
328	[DB8500_REGULATOR_SWITCH_SIAMMDSPRET] = {
329	.desc = {
330	.name = "db8500-sia-mmdsp-ret",
331	.id = DB8500_REGULATOR_SWITCH_SIAMMDSPRET,
332	.ops = &db8500_regulator_switch_ops,
333	.type = REGULATOR_VOLTAGE,
334	.owner = THIS_MODULE,
335	},
336	.epod_id = EPOD_ID_SIAMMDSP,
337	.is_ramret = true,
338	},
339	[DB8500_REGULATOR_SWITCH_SIAPIPE] = {
340	.desc = {
341	.name = "db8500-sia-pipe",
342	.id = DB8500_REGULATOR_SWITCH_SIAPIPE,
343	.ops = &db8500_regulator_switch_ops,
344	.type = REGULATOR_VOLTAGE,
345	.owner = THIS_MODULE,
346	},
347	.epod_id = EPOD_ID_SIAPIPE,
348	},
349	[DB8500_REGULATOR_SWITCH_SGA] = {
350	.desc = {
351	.name = "db8500-sga",
352	.id = DB8500_REGULATOR_SWITCH_SGA,
353	.ops = &db8500_regulator_switch_ops,
354	.type = REGULATOR_VOLTAGE,
355	.owner = THIS_MODULE,
356	},
357	.epod_id = EPOD_ID_SGA,
358	},
359	[DB8500_REGULATOR_SWITCH_B2R2_MCDE] = {
360	.desc = {
361	.name = "db8500-b2r2-mcde",
362	.id = DB8500_REGULATOR_SWITCH_B2R2_MCDE,
363	.ops = &db8500_regulator_switch_ops,
364	.type = REGULATOR_VOLTAGE,
365	.owner = THIS_MODULE,
366	},
367	.epod_id = EPOD_ID_B2R2_MCDE,
368	},
369	[DB8500_REGULATOR_SWITCH_ESRAM12] = {
370	.desc = {
371	.name = "db8500-esram12",
372	.id = DB8500_REGULATOR_SWITCH_ESRAM12,
373	.ops = &db8500_regulator_switch_ops,
374	.type = REGULATOR_VOLTAGE,
375	.owner = THIS_MODULE,
376	},
377	.epod_id = EPOD_ID_ESRAM12,
378	.is_enabled = true,
379	},
380	[DB8500_REGULATOR_SWITCH_ESRAM12RET] = {
381	.desc = {
382	.name = "db8500-esram12-ret",
383	.id = DB8500_REGULATOR_SWITCH_ESRAM12RET,
384	.ops = &db8500_regulator_switch_ops,
385	.type = REGULATOR_VOLTAGE,
386	.owner = THIS_MODULE,
387	},
388	.epod_id = EPOD_ID_ESRAM12,
389	.is_ramret = true,
390	},
391	[DB8500_REGULATOR_SWITCH_ESRAM34] = {
392	.desc = {
393	.name = "db8500-esram34",
394	.id = DB8500_REGULATOR_SWITCH_ESRAM34,
395	.ops = &db8500_regulator_switch_ops,
396	.type = REGULATOR_VOLTAGE,
397	.owner = THIS_MODULE,
398	},
399	.epod_id = EPOD_ID_ESRAM34,
400	.is_enabled = true,
401	},
402	[DB8500_REGULATOR_SWITCH_ESRAM34RET] = {
403	.desc = {
404	.name = "db8500-esram34-ret",
405	.id = DB8500_REGULATOR_SWITCH_ESRAM34RET,
406	.ops = &db8500_regulator_switch_ops,
407	.type = REGULATOR_VOLTAGE,
408	.owner = THIS_MODULE,
409	},
410	.epod_id = EPOD_ID_ESRAM34,
411	.is_ramret = true,
412	},
413	};
414
a5023574	415	static int db8500_regulator_register(struct platform_device *pdev,
8986cf88 LJ	416	struct regulator_init_data *init_data,
	417	int id,
	418	struct device_node *np)
	419	{
	420	struct dbx500_regulator_info *info;
	421	struct regulator_config config = { };
	422	int err;
	423
	424	/* assign per-regulator data */
	425	info = &dbx500_regulator_info[id];
	426	info->dev = &pdev->dev;
	427
	428	config.dev = &pdev->dev;
	429	config.init_data = init_data;
	430	config.driver_data = info;
	431	config.of_node = np;
	432
	433	/* register with the regulator framework */
	434	info->rdev = regulator_register(&info->desc, &config);
	435	if (IS_ERR(info->rdev)) {
	436	err = PTR_ERR(info->rdev);
	437	dev_err(&pdev->dev, "failed to register %s: err %i\n",
	438	info->desc.name, err);
	439
	440	/* if failing, unregister all earlier regulators */
	441	while (--id >= 0) {
	442	info = &dbx500_regulator_info[id];
	443	regulator_unregister(info->rdev);
	444	}
	445	return err;
	446	}
	447
	448	dev_dbg(rdev_get_dev(info->rdev),
	449	"regulator-%s-probed\n", info->desc.name);
	450
	451	return 0;
	452	}
	453
1bdd670a	454	static struct of_regulator_match db8500_regulator_matches[] = {
ea851f4f LJ	455	{ .name = "db8500_vape", .driver_data = (void *) DB8500_REGULATOR_VAPE, },
	456	{ .name = "db8500_varm", .driver_data = (void *) DB8500_REGULATOR_VARM, },
	457	{ .name = "db8500_vmodem", .driver_data = (void *) DB8500_REGULATOR_VMODEM, },
	458	{ .name = "db8500_vpll", .driver_data = (void *) DB8500_REGULATOR_VPLL, },
	459	{ .name = "db8500_vsmps1", .driver_data = (void *) DB8500_REGULATOR_VSMPS1, },
	460	{ .name = "db8500_vsmps2", .driver_data = (void *) DB8500_REGULATOR_VSMPS2, },
	461	{ .name = "db8500_vsmps3", .driver_data = (void *) DB8500_REGULATOR_VSMPS3, },
	462	{ .name = "db8500_vrf1", .driver_data = (void *) DB8500_REGULATOR_VRF1, },
	463	{ .name = "db8500_sva_mmdsp", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAMMDSP, },
	464	{ .name = "db8500_sva_mmdsp_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAMMDSPRET, },
	465	{ .name = "db8500_sva_pipe", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SVAPIPE, },
	466	{ .name = "db8500_sia_mmdsp", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAMMDSP, },
	467	{ .name = "db8500_sia_mmdsp_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAMMDSPRET, },
	468	{ .name = "db8500_sia_pipe", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SIAPIPE, },
	469	{ .name = "db8500_sga", .driver_data = (void *) DB8500_REGULATOR_SWITCH_SGA, },
	470	{ .name = "db8500_b2r2_mcde", .driver_data = (void *) DB8500_REGULATOR_SWITCH_B2R2_MCDE, },
	471	{ .name = "db8500_esram12", .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM12, },
	472	{ .name = "db8500_esram12_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM12RET, },
	473	{ .name = "db8500_esram34", .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM34, },
	474	{ .name = "db8500_esram34_ret", .driver_data = (void *) DB8500_REGULATOR_SWITCH_ESRAM34RET, },
1bdd670a LJ	475	};
1bdd670a LJ	476
a5023574	477	static int
1bdd670a LJ	478	db8500_regulator_of_probe(struct platform_device *pdev,
	479	struct device_node *np)
	480	{
	481	int i, err;
	482
	483	for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
	484	err = db8500_regulator_register(
	485	pdev, db8500_regulator_matches[i].init_data,
	486	i, db8500_regulator_matches[i].of_node);
	487	if (err)
	488	return err;
	489	}
	490
	491	return 0;
	492	}
	493
a5023574	494	static int db8500_regulator_probe(struct platform_device *pdev)
1032fbfd	495	{
17cf8b42 SO	496	struct regulator_init_data *db8500_init_data =
17cf8b42 SO	497	dev_get_platdata(&pdev->dev);
1bdd670a	498	struct device_node *np = pdev->dev.of_node;
1032fbfd BJ	499	int i, err;
	500
	501	/* register all regulators */
1bdd670a LJ	502	if (np) {
	503	err = of_regulator_match(&pdev->dev, np,
	504	db8500_regulator_matches,
	505	ARRAY_SIZE(db8500_regulator_matches));
	506	if (err < 0) {
	507	dev_err(&pdev->dev,
	508	"Error parsing regulator init data: %d\n", err);
1032fbfd	509	return err;
1bdd670a	510	}
1032fbfd	511
1bdd670a LJ	512	err = db8500_regulator_of_probe(pdev, np);
	513	if (err)
	514	return err;
	515	} else {
	516	for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
	517	err = db8500_regulator_register(pdev,
	518	&db8500_init_data[i],
	519	i, NULL);
	520	if (err)
	521	return err;
	522	}
1032fbfd	523	}
1bdd670a	524
38e96838 BJ	525	err = ux500_regulator_debug_init(pdev,
	526	dbx500_regulator_info,
	527	ARRAY_SIZE(dbx500_regulator_info));
8986cf88	528	return 0;
1032fbfd BJ	529	}
1032fbfd BJ	530
4ceb73ae	531	static int db8500_regulator_remove(struct platform_device *pdev)
1032fbfd BJ	532	{
	533	int i;
	534
38e96838 BJ	535	ux500_regulator_debug_exit();
	536
	537	for (i = 0; i < ARRAY_SIZE(dbx500_regulator_info); i++) {
	538	struct dbx500_regulator_info *info;
	539	info = &dbx500_regulator_info[i];
1032fbfd BJ	540
	541	dev_vdbg(rdev_get_dev(info->rdev),
	542	"regulator-%s-remove\n", info->desc.name);
	543
	544	regulator_unregister(info->rdev);
	545	}
	546
	547	return 0;
	548	}
	549
	550	static struct platform_driver db8500_regulator_driver = {
	551	.driver = {
	552	.name = "db8500-prcmu-regulators",
	553	.owner = THIS_MODULE,
	554	},
	555	.probe = db8500_regulator_probe,
4ceb73ae	556	.remove = db8500_regulator_remove,
1032fbfd BJ	557	};
	558
	559	static int __init db8500_regulator_init(void)
	560	{
90609503	561	return platform_driver_register(&db8500_regulator_driver);
1032fbfd BJ	562	}
	563
	564	static void __exit db8500_regulator_exit(void)
	565	{
	566	platform_driver_unregister(&db8500_regulator_driver);
	567	}
	568
	569	arch_initcall(db8500_regulator_init);
	570	module_exit(db8500_regulator_exit);
	571
	572	MODULE_AUTHOR("STMicroelectronics/ST-Ericsson");
	573	MODULE_DESCRIPTION("DB8500 regulator driver");
	574	MODULE_LICENSE("GPL v2");