[linux-2.6-block.git] / drivers / regulator / lochnagar-regulator.c

// SPDX-License-Identifier: GPL-2.0
//
// Lochnagar regulator driver
//
// Copyright (c) 2017-2018 Cirrus Logic, Inc. and
//                         Cirrus Logic International Semiconductor Ltd.
//
// Author: Charles Keepax <ckeepax@opensource.cirrus.com>

#include <linux/bitops.h>
#include <linux/device.h>
#include <linux/err.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regmap.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>

#include <linux/mfd/lochnagar.h>

static const struct regulator_ops lochnagar_micvdd_ops = {
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,

	.list_voltage = regulator_list_voltage_linear_range,
	.map_voltage = regulator_map_voltage_linear_range,

	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,
};

static const struct regulator_linear_range lochnagar_micvdd_ranges[] = {
	REGULATOR_LINEAR_RANGE(1000000, 0,    0xC, 50000),
	REGULATOR_LINEAR_RANGE(1700000, 0xD, 0x1F, 100000),
};

static int lochnagar_micbias_enable(struct regulator_dev *rdev)
{
	struct lochnagar *lochnagar = rdev_get_drvdata(rdev);
	int ret;

	mutex_lock(&lochnagar->analogue_config_lock);

	ret = regulator_enable_regmap(rdev);
	if (ret < 0)
		goto err;

	ret = lochnagar_update_config(lochnagar);

err:
	mutex_unlock(&lochnagar->analogue_config_lock);

	return ret;
}

static int lochnagar_micbias_disable(struct regulator_dev *rdev)
{
	struct lochnagar *lochnagar = rdev_get_drvdata(rdev);
	int ret;

	mutex_lock(&lochnagar->analogue_config_lock);

	ret = regulator_disable_regmap(rdev);
	if (ret < 0)
		goto err;

	ret = lochnagar_update_config(lochnagar);

err:
	mutex_unlock(&lochnagar->analogue_config_lock);

	return ret;
}

static const struct regulator_ops lochnagar_micbias_ops = {
	.enable = lochnagar_micbias_enable,
	.disable = lochnagar_micbias_disable,
	.is_enabled = regulator_is_enabled_regmap,
};

static const struct regulator_ops lochnagar_vddcore_ops = {
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,

	.list_voltage = regulator_list_voltage_linear_range,
	.map_voltage = regulator_map_voltage_linear_range,

	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,
};

static const struct regulator_linear_range lochnagar_vddcore_ranges[] = {
	REGULATOR_LINEAR_RANGE(600000, 0x8, 0x41, 12500),
};

enum lochnagar_regulators {
	LOCHNAGAR_MICVDD,
	LOCHNAGAR_MIC1VDD,
	LOCHNAGAR_MIC2VDD,
	LOCHNAGAR_VDDCORE,
};

static int lochnagar_micbias_of_parse(struct device_node *np,
				      const struct regulator_desc *desc,
				      struct regulator_config *config)
{
	struct lochnagar *lochnagar = config->driver_data;
	int shift = (desc->id - LOCHNAGAR_MIC1VDD) *
		    LOCHNAGAR2_P2_MICBIAS_SRC_SHIFT;
	int mask = LOCHNAGAR2_P1_MICBIAS_SRC_MASK << shift;
	unsigned int val;
	int ret;

	ret = of_property_read_u32(np, "cirrus,micbias-input", &val);
	if (ret >= 0) {
		mutex_lock(&lochnagar->analogue_config_lock);
		ret = regmap_update_bits(lochnagar->regmap,
					 LOCHNAGAR2_ANALOGUE_PATH_CTRL2,
					 mask, val << shift);
		mutex_unlock(&lochnagar->analogue_config_lock);
		if (ret < 0) {
			dev_err(lochnagar->dev,
				"Failed to update micbias source: %d\n", ret);
			return ret;
		}
	}

	return 0;
}

static const struct regulator_desc lochnagar_regulators[] = {
	[LOCHNAGAR_MICVDD] = {
		.name = "MICVDD",
		.supply_name = "SYSVDD",
		.type = REGULATOR_VOLTAGE,
		.n_voltages = 32,
		.ops = &lochnagar_micvdd_ops,

		.id = LOCHNAGAR_MICVDD,
		.of_match = of_match_ptr("MICVDD"),

		.enable_reg = LOCHNAGAR2_MICVDD_CTRL1,
		.enable_mask = LOCHNAGAR2_MICVDD_REG_ENA_MASK,
		.vsel_reg = LOCHNAGAR2_MICVDD_CTRL2,
		.vsel_mask = LOCHNAGAR2_MICVDD_VSEL_MASK,

		.linear_ranges = lochnagar_micvdd_ranges,
		.n_linear_ranges = ARRAY_SIZE(lochnagar_micvdd_ranges),

		.enable_time = 3000,
		.ramp_delay = 1000,

		.owner = THIS_MODULE,
	},
	[LOCHNAGAR_MIC1VDD] = {
		.name = "MIC1VDD",
		.supply_name = "MICBIAS1",
		.type = REGULATOR_VOLTAGE,
		.ops = &lochnagar_micbias_ops,

		.id = LOCHNAGAR_MIC1VDD,
		.of_match = of_match_ptr("MIC1VDD"),
		.of_parse_cb = lochnagar_micbias_of_parse,

		.enable_reg = LOCHNAGAR2_ANALOGUE_PATH_CTRL2,
		.enable_mask = LOCHNAGAR2_P1_INPUT_BIAS_ENA_MASK,

		.owner = THIS_MODULE,
	},
	[LOCHNAGAR_MIC2VDD] = {
		.name = "MIC2VDD",
		.supply_name = "MICBIAS2",
		.type = REGULATOR_VOLTAGE,
		.ops = &lochnagar_micbias_ops,

		.id = LOCHNAGAR_MIC2VDD,
		.of_match = of_match_ptr("MIC2VDD"),
		.of_parse_cb = lochnagar_micbias_of_parse,

		.enable_reg = LOCHNAGAR2_ANALOGUE_PATH_CTRL2,
		.enable_mask = LOCHNAGAR2_P2_INPUT_BIAS_ENA_MASK,

		.owner = THIS_MODULE,
	},
	[LOCHNAGAR_VDDCORE] = {
		.name = "VDDCORE",
		.supply_name = "SYSVDD",
		.type = REGULATOR_VOLTAGE,
		.n_voltages = 57,
		.ops = &lochnagar_vddcore_ops,

		.id = LOCHNAGAR_VDDCORE,
		.of_match = of_match_ptr("VDDCORE"),

		.enable_reg = LOCHNAGAR2_VDDCORE_CDC_CTRL1,
		.enable_mask = LOCHNAGAR2_VDDCORE_CDC_REG_ENA_MASK,
		.vsel_reg = LOCHNAGAR2_VDDCORE_CDC_CTRL2,
		.vsel_mask = LOCHNAGAR2_VDDCORE_CDC_VSEL_MASK,

		.linear_ranges = lochnagar_vddcore_ranges,
		.n_linear_ranges = ARRAY_SIZE(lochnagar_vddcore_ranges),

		.enable_time = 3000,
		.ramp_delay = 1000,

		.owner = THIS_MODULE,
	},
};

static int lochnagar_regulator_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct lochnagar *lochnagar = dev_get_drvdata(dev->parent);
	struct regulator_config config = { };
	struct regulator_dev *rdev;
	int ret, i;

	config.dev = lochnagar->dev;
	config.regmap = lochnagar->regmap;
	config.driver_data = lochnagar;

	for (i = 0; i < ARRAY_SIZE(lochnagar_regulators); i++) {
		const struct regulator_desc *desc = &lochnagar_regulators[i];

		rdev = devm_regulator_register(dev, desc, &config);
		if (IS_ERR(rdev)) {
			ret = PTR_ERR(rdev);
			dev_err(dev, "Failed to register %s regulator: %d\n",
				desc->name, ret);
			return ret;
		}
	}

	return 0;
}

static struct platform_driver lochnagar_regulator_driver = {
	.driver = {
		.name = "lochnagar-regulator",
	},

	.probe = lochnagar_regulator_probe,
};
module_platform_driver(lochnagar_regulator_driver);

MODULE_AUTHOR("Charles Keepax <ckeepax@opensource.cirrus.com>");
MODULE_DESCRIPTION("Regulator driver for Cirrus Logic Lochnagar Board");
MODULE_LICENSE("GPL v2");
MODULE_ALIAS("platform:lochnagar-regulator");
Commit	Line	Data
bef9391c	1	// SPDX-License-Identifier: GPL-2.0
d8b2a8e9 CK	2	//
	3	// Lochnagar regulator driver
	4	//
	5	// Copyright (c) 2017-2018 Cirrus Logic, Inc. and
	6	// Cirrus Logic International Semiconductor Ltd.
	7	//
	8	// Author: Charles Keepax <ckeepax@opensource.cirrus.com>
bef9391c CK	9
	10	#include <linux/bitops.h>
	11	#include <linux/device.h>
	12	#include <linux/err.h>
	13	#include <linux/module.h>
	14	#include <linux/mutex.h>
	15	#include <linux/of.h>
	16	#include <linux/platform_device.h>
	17	#include <linux/regmap.h>
	18	#include <linux/regulator/driver.h>
	19	#include <linux/regulator/machine.h>
	20	#include <linux/regulator/of_regulator.h>
	21
	22	#include <linux/mfd/lochnagar.h>
	23
	24	static const struct regulator_ops lochnagar_micvdd_ops = {
	25	.enable = regulator_enable_regmap,
	26	.disable = regulator_disable_regmap,
	27	.is_enabled = regulator_is_enabled_regmap,
	28
	29	.list_voltage = regulator_list_voltage_linear_range,
	30	.map_voltage = regulator_map_voltage_linear_range,
	31
	32	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	33	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	34	};
	35
	36	static const struct regulator_linear_range lochnagar_micvdd_ranges[] = {
	37	REGULATOR_LINEAR_RANGE(1000000, 0, 0xC, 50000),
	38	REGULATOR_LINEAR_RANGE(1700000, 0xD, 0x1F, 100000),
	39	};
	40
	41	static int lochnagar_micbias_enable(struct regulator_dev *rdev)
	42	{
	43	struct lochnagar *lochnagar = rdev_get_drvdata(rdev);
	44	int ret;
	45
	46	mutex_lock(&lochnagar->analogue_config_lock);
	47
	48	ret = regulator_enable_regmap(rdev);
	49	if (ret < 0)
	50	goto err;
	51
	52	ret = lochnagar_update_config(lochnagar);
	53
	54	err:
	55	mutex_unlock(&lochnagar->analogue_config_lock);
	56
	57	return ret;
	58	}
	59
	60	static int lochnagar_micbias_disable(struct regulator_dev *rdev)
	61	{
	62	struct lochnagar *lochnagar = rdev_get_drvdata(rdev);
	63	int ret;
	64
	65	mutex_lock(&lochnagar->analogue_config_lock);
	66
	67	ret = regulator_disable_regmap(rdev);
	68	if (ret < 0)
	69	goto err;
	70
	71	ret = lochnagar_update_config(lochnagar);
	72
73	err:
74	mutex_unlock(&lochnagar->analogue_config_lock);
75
76	return ret;
77	}
78
79	static const struct regulator_ops lochnagar_micbias_ops = {
80	.enable = lochnagar_micbias_enable,
81	.disable = lochnagar_micbias_disable,
82	.is_enabled = regulator_is_enabled_regmap,
83	};
84
85	static const struct regulator_ops lochnagar_vddcore_ops = {
86	.enable = regulator_enable_regmap,
87	.disable = regulator_disable_regmap,
88	.is_enabled = regulator_is_enabled_regmap,
89
90	.list_voltage = regulator_list_voltage_linear_range,
91	.map_voltage = regulator_map_voltage_linear_range,
92
93	.get_voltage_sel = regulator_get_voltage_sel_regmap,
94	.set_voltage_sel = regulator_set_voltage_sel_regmap,
95	};
96
97	static const struct regulator_linear_range lochnagar_vddcore_ranges[] = {
98	REGULATOR_LINEAR_RANGE(600000, 0x8, 0x41, 12500),
99	};
100
101	enum lochnagar_regulators {
102	LOCHNAGAR_MICVDD,
103	LOCHNAGAR_MIC1VDD,
104	LOCHNAGAR_MIC2VDD,
105	LOCHNAGAR_VDDCORE,
106	};
107
108	static int lochnagar_micbias_of_parse(struct device_node *np,
109	const struct regulator_desc *desc,
110	struct regulator_config *config)
111	{
112	struct lochnagar *lochnagar = config->driver_data;
113	int shift = (desc->id - LOCHNAGAR_MIC1VDD) *
114	LOCHNAGAR2_P2_MICBIAS_SRC_SHIFT;
115	int mask = LOCHNAGAR2_P1_MICBIAS_SRC_MASK << shift;
116	unsigned int val;
117	int ret;
118
119	ret = of_property_read_u32(np, "cirrus,micbias-input", &val);
120	if (ret >= 0) {
121	mutex_lock(&lochnagar->analogue_config_lock);
122	ret = regmap_update_bits(lochnagar->regmap,
123	LOCHNAGAR2_ANALOGUE_PATH_CTRL2,
124	mask, val << shift);
125	mutex_unlock(&lochnagar->analogue_config_lock);
126	if (ret < 0) {
127	dev_err(lochnagar->dev,
128	"Failed to update micbias source: %d\n", ret);
129	return ret;
130	}
131	}
132
133	return 0;
134	}
135
136	static const struct regulator_desc lochnagar_regulators[] = {
137	[LOCHNAGAR_MICVDD] = {
138	.name = "MICVDD",
139	.supply_name = "SYSVDD",
140	.type = REGULATOR_VOLTAGE,
141	.n_voltages = 32,
142	.ops = &lochnagar_micvdd_ops,
143
144	.id = LOCHNAGAR_MICVDD,
145	.of_match = of_match_ptr("MICVDD"),
146
147	.enable_reg = LOCHNAGAR2_MICVDD_CTRL1,
148	.enable_mask = LOCHNAGAR2_MICVDD_REG_ENA_MASK,
149	.vsel_reg = LOCHNAGAR2_MICVDD_CTRL2,
150	.vsel_mask = LOCHNAGAR2_MICVDD_VSEL_MASK,
151
152	.linear_ranges = lochnagar_micvdd_ranges,
153	.n_linear_ranges = ARRAY_SIZE(lochnagar_micvdd_ranges),
154
155	.enable_time = 3000,
156	.ramp_delay = 1000,
157
158	.owner = THIS_MODULE,
159	},
160	[LOCHNAGAR_MIC1VDD] = {
161	.name = "MIC1VDD",
162	.supply_name = "MICBIAS1",
163	.type = REGULATOR_VOLTAGE,
164	.ops = &lochnagar_micbias_ops,
165
166	.id = LOCHNAGAR_MIC1VDD,
167	.of_match = of_match_ptr("MIC1VDD"),
168	.of_parse_cb = lochnagar_micbias_of_parse,
169
170	.enable_reg = LOCHNAGAR2_ANALOGUE_PATH_CTRL2,
171	.enable_mask = LOCHNAGAR2_P1_INPUT_BIAS_ENA_MASK,
172
173	.owner = THIS_MODULE,
174	},
175	[LOCHNAGAR_MIC2VDD] = {
176	.name = "MIC2VDD",
177	.supply_name = "MICBIAS2",
178	.type = REGULATOR_VOLTAGE,
179	.ops = &lochnagar_micbias_ops,
180
181	.id = LOCHNAGAR_MIC2VDD,
182	.of_match = of_match_ptr("MIC2VDD"),
183	.of_parse_cb = lochnagar_micbias_of_parse,
184
185	.enable_reg = LOCHNAGAR2_ANALOGUE_PATH_CTRL2,
186	.enable_mask = LOCHNAGAR2_P2_INPUT_BIAS_ENA_MASK,
187
188	.owner = THIS_MODULE,
189	},
190	[LOCHNAGAR_VDDCORE] = {
191	.name = "VDDCORE",
192	.supply_name = "SYSVDD",
193	.type = REGULATOR_VOLTAGE,
194	.n_voltages = 57,
195	.ops = &lochnagar_vddcore_ops,
196
197	.id = LOCHNAGAR_VDDCORE,
198	.of_match = of_match_ptr("VDDCORE"),
199
200	.enable_reg = LOCHNAGAR2_VDDCORE_CDC_CTRL1,
201	.enable_mask = LOCHNAGAR2_VDDCORE_CDC_REG_ENA_MASK,
202	.vsel_reg = LOCHNAGAR2_VDDCORE_CDC_CTRL2,
203	.vsel_mask = LOCHNAGAR2_VDDCORE_CDC_VSEL_MASK,
204
205	.linear_ranges = lochnagar_vddcore_ranges,
206	.n_linear_ranges = ARRAY_SIZE(lochnagar_vddcore_ranges),
207
208	.enable_time = 3000,
209	.ramp_delay = 1000,
210
211	.owner = THIS_MODULE,
212	},
213	};
214
215	static int lochnagar_regulator_probe(struct platform_device *pdev)
216	{
217	struct device *dev = &pdev->dev;
218	struct lochnagar *lochnagar = dev_get_drvdata(dev->parent);
219	struct regulator_config config = { };
220	struct regulator_dev *rdev;
221	int ret, i;
222
223	config.dev = lochnagar->dev;
224	config.regmap = lochnagar->regmap;
225	config.driver_data = lochnagar;
226
227	for (i = 0; i < ARRAY_SIZE(lochnagar_regulators); i++) {
228	const struct regulator_desc *desc = &lochnagar_regulators[i];
229
230	rdev = devm_regulator_register(dev, desc, &config);
231	if (IS_ERR(rdev)) {
232	ret = PTR_ERR(rdev);
233	dev_err(dev, "Failed to register %s regulator: %d\n",
234	desc->name, ret);
235	return ret;
236	}
237	}
238
239	return 0;
240	}
241
242	static struct platform_driver lochnagar_regulator_driver = {
243	.driver = {
244	.name = "lochnagar-regulator",
245	},
246
247	.probe = lochnagar_regulator_probe,
248	};
249	module_platform_driver(lochnagar_regulator_driver);
250
251	MODULE_AUTHOR("Charles Keepax <ckeepax@opensource.cirrus.com>");
252	MODULE_DESCRIPTION("Regulator driver for Cirrus Logic Lochnagar Board");
253	MODULE_LICENSE("GPL v2");
254	MODULE_ALIAS("platform:lochnagar-regulator");