[deliverable/linux.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/module.h>

/*
 * power state reference count
 */
static int power_state_active_cnt; /* will initialize to zero */
static DEFINE_SPINLOCK(power_state_active_lock);

static void power_state_active_enable(void)
{
	unsigned long flags;

	spin_lock_irqsave(&power_state_active_lock, flags);
	power_state_active_cnt++;
	spin_unlock_irqrestore(&power_state_active_lock, flags);
}

static int power_state_active_disable(void)
{
	int ret = 0;
	unsigned long flags;

	spin_lock_irqsave(&power_state_active_lock, flags);
	if (power_state_active_cnt <= 0) {
		pr_err("power state: unbalanced enable/disable calls\n");
		ret = -EINVAL;
		goto out;
	}

	power_state_active_cnt--;
out:
	spin_unlock_irqrestore(&power_state_active_lock, flags);
	return ret;
}

/*
 * Exported interface for CPUIdle only. This function is called when interrupts
 * are turned off. Hence, no locking.
 */
int power_state_active_is_enabled(void)
{
	return (power_state_active_cnt > 0);
}

/**
 * struct db8500_regulator_info - db8500 regulator information
 * @dev: device pointer
 * @desc: regulator description
 * @rdev: regulator device pointer
 * @is_enabled: status of the regulator
 * @epod_id: id for EPOD (power domain)
 * @is_ramret: RAM retention switch for EPOD (power domain)
 * @operating_point: operating point (only for vape, to be removed)
 *
 */
struct db8500_regulator_info {
	struct device *dev;
	struct regulator_desc desc;
	struct regulator_dev *rdev;
	bool is_enabled;
	u16 epod_id;
	bool is_ramret;
	bool exclude_from_power_state;
	unsigned int operating_point;
};

static int db8500_regulator_enable(struct regulator_dev *rdev)
{
	struct db8500_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);

	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 db8500_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);

	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 db8500_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 db8500_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 db8500_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 db8500_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 db8500_regulator_info
db8500_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 __devinit db8500_regulator_probe(struct platform_device *pdev)
{
	struct regulator_init_data *db8500_init_data =
					dev_get_platdata(&pdev->dev);
	int i, err;

	/* register all regulators */
	for (i = 0; i < ARRAY_SIZE(db8500_regulator_info); i++) {
		struct db8500_regulator_info *info;
		struct regulator_init_data *init_data = &db8500_init_data[i];

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

		/* register with the regulator framework */
		info->rdev = regulator_register(&info->desc, &pdev->dev,
				init_data, info, NULL);
		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 (--i >= 0) {
				info = &db8500_regulator_info[i];
				regulator_unregister(info->rdev);
			}
			return err;
		}

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

	return 0;
}

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

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