1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (C) 2020 ROHM Semiconductors
3 // ROHM BD9576MUF/BD9573MUF regulator driver
4 
5 #include <linux/delay.h>
6 #include <linux/err.h>
7 #include <linux/gpio/consumer.h>
8 #include <linux/interrupt.h>
9 #include <linux/kernel.h>
10 #include <linux/mfd/rohm-bd957x.h>
11 #include <linux/mfd/rohm-generic.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/platform_device.h>
15 #include <linux/regulator/driver.h>
16 #include <linux/regulator/machine.h>
17 #include <linux/regulator/of_regulator.h>
18 #include <linux/slab.h>
19 
20 #define BD957X_VOUTS1_VOLT	3300000
21 #define BD957X_VOUTS4_BASE_VOLT	1030000
22 #define BD957X_VOUTS34_NUM_VOLT	32
23 
24 static int vout1_volt_table[] = {5000000, 4900000, 4800000, 4700000, 4600000,
25 				 4500000, 4500000, 4500000, 5000000, 5100000,
26 				 5200000, 5300000, 5400000, 5500000, 5500000,
27 				 5500000};
28 
29 static int vout2_volt_table[] = {1800000, 1780000, 1760000, 1740000, 1720000,
30 				 1700000, 1680000, 1660000, 1800000, 1820000,
31 				 1840000, 1860000, 1880000, 1900000, 1920000,
32 				 1940000};
33 
34 static int voutl1_volt_table[] = {2500000, 2540000, 2580000, 2620000, 2660000,
35 				  2700000, 2740000, 2780000, 2500000, 2460000,
36 				  2420000, 2380000, 2340000, 2300000, 2260000,
37 				  2220000};
38 
39 struct bd957x_regulator_data {
40 	struct regulator_desc desc;
41 	int base_voltage;
42 };
43 
44 static int bd957x_vout34_list_voltage(struct regulator_dev *rdev,
45 				      unsigned int selector)
46 {
47 	const struct regulator_desc *desc = rdev->desc;
48 	int multiplier = selector & desc->vsel_mask & 0x7f;
49 	int tune;
50 
51 	/* VOUT3 and 4 has 10mV step */
52 	tune = multiplier * 10000;
53 
54 	if (!(selector & 0x80))
55 		return desc->fixed_uV - tune;
56 
57 	return desc->fixed_uV + tune;
58 }
59 
60 static int bd957x_list_voltage(struct regulator_dev *rdev,
61 			       unsigned int selector)
62 {
63 	const struct regulator_desc *desc = rdev->desc;
64 	int index = selector & desc->vsel_mask & 0x7f;
65 
66 	if (!(selector & 0x80))
67 		index += desc->n_voltages/2;
68 
69 	if (index >= desc->n_voltages)
70 		return -EINVAL;
71 
72 	return desc->volt_table[index];
73 }
74 
75 static const struct regulator_ops bd957x_vout34_ops = {
76 	.is_enabled = regulator_is_enabled_regmap,
77 	.list_voltage = bd957x_vout34_list_voltage,
78 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
79 };
80 
81 static const struct regulator_ops bd957X_vouts1_regulator_ops = {
82 	.is_enabled = regulator_is_enabled_regmap,
83 };
84 
85 static const struct regulator_ops bd957x_ops = {
86 	.is_enabled = regulator_is_enabled_regmap,
87 	.list_voltage = bd957x_list_voltage,
88 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
89 };
90 
91 static struct bd957x_regulator_data bd9576_regulators[] = {
92 	{
93 		.desc = {
94 			.name = "VD50",
95 			.of_match = of_match_ptr("regulator-vd50"),
96 			.regulators_node = of_match_ptr("regulators"),
97 			.id = BD957X_VD50,
98 			.type = REGULATOR_VOLTAGE,
99 			.ops = &bd957x_ops,
100 			.volt_table = &vout1_volt_table[0],
101 			.n_voltages = ARRAY_SIZE(vout1_volt_table),
102 			.vsel_reg = BD957X_REG_VOUT1_TUNE,
103 			.vsel_mask = BD957X_MASK_VOUT1_TUNE,
104 			.enable_reg = BD957X_REG_POW_TRIGGER1,
105 			.enable_mask = BD957X_REGULATOR_EN_MASK,
106 			.enable_val = BD957X_REGULATOR_DIS_VAL,
107 			.enable_is_inverted = true,
108 			.owner = THIS_MODULE,
109 		},
110 	},
111 	{
112 		.desc = {
113 			.name = "VD18",
114 			.of_match = of_match_ptr("regulator-vd18"),
115 			.regulators_node = of_match_ptr("regulators"),
116 			.id = BD957X_VD18,
117 			.type = REGULATOR_VOLTAGE,
118 			.ops = &bd957x_ops,
119 			.volt_table = &vout2_volt_table[0],
120 			.n_voltages = ARRAY_SIZE(vout2_volt_table),
121 			.vsel_reg = BD957X_REG_VOUT2_TUNE,
122 			.vsel_mask = BD957X_MASK_VOUT2_TUNE,
123 			.enable_reg = BD957X_REG_POW_TRIGGER2,
124 			.enable_mask = BD957X_REGULATOR_EN_MASK,
125 			.enable_val = BD957X_REGULATOR_DIS_VAL,
126 			.enable_is_inverted = true,
127 			.owner = THIS_MODULE,
128 		},
129 	},
130 	{
131 		.desc = {
132 			.name = "VDDDR",
133 			.of_match = of_match_ptr("regulator-vdddr"),
134 			.regulators_node = of_match_ptr("regulators"),
135 			.id = BD957X_VDDDR,
136 			.ops = &bd957x_vout34_ops,
137 			.type = REGULATOR_VOLTAGE,
138 			.n_voltages = BD957X_VOUTS34_NUM_VOLT,
139 			.vsel_reg = BD957X_REG_VOUT3_TUNE,
140 			.vsel_mask = BD957X_MASK_VOUT3_TUNE,
141 			.enable_reg = BD957X_REG_POW_TRIGGER3,
142 			.enable_mask = BD957X_REGULATOR_EN_MASK,
143 			.enable_val = BD957X_REGULATOR_DIS_VAL,
144 			.enable_is_inverted = true,
145 			.owner = THIS_MODULE,
146 		},
147 	},
148 	{
149 		.desc = {
150 			.name = "VD10",
151 			.of_match = of_match_ptr("regulator-vd10"),
152 			.regulators_node = of_match_ptr("regulators"),
153 			.id = BD957X_VD10,
154 			.ops = &bd957x_vout34_ops,
155 			.type = REGULATOR_VOLTAGE,
156 			.fixed_uV = BD957X_VOUTS4_BASE_VOLT,
157 			.n_voltages = BD957X_VOUTS34_NUM_VOLT,
158 			.vsel_reg = BD957X_REG_VOUT4_TUNE,
159 			.vsel_mask = BD957X_MASK_VOUT4_TUNE,
160 			.enable_reg = BD957X_REG_POW_TRIGGER4,
161 			.enable_mask = BD957X_REGULATOR_EN_MASK,
162 			.enable_val = BD957X_REGULATOR_DIS_VAL,
163 			.enable_is_inverted = true,
164 			.owner = THIS_MODULE,
165 		},
166 	},
167 	{
168 		.desc = {
169 			.name = "VOUTL1",
170 			.of_match = of_match_ptr("regulator-voutl1"),
171 			.regulators_node = of_match_ptr("regulators"),
172 			.id = BD957X_VOUTL1,
173 			.ops = &bd957x_ops,
174 			.type = REGULATOR_VOLTAGE,
175 			.volt_table = &voutl1_volt_table[0],
176 			.n_voltages = ARRAY_SIZE(voutl1_volt_table),
177 			.vsel_reg = BD957X_REG_VOUTL1_TUNE,
178 			.vsel_mask = BD957X_MASK_VOUTL1_TUNE,
179 			.enable_reg = BD957X_REG_POW_TRIGGERL1,
180 			.enable_mask = BD957X_REGULATOR_EN_MASK,
181 			.enable_val = BD957X_REGULATOR_DIS_VAL,
182 			.enable_is_inverted = true,
183 			.owner = THIS_MODULE,
184 		},
185 	},
186 	{
187 		.desc = {
188 			.name = "VOUTS1",
189 			.of_match = of_match_ptr("regulator-vouts1"),
190 			.regulators_node = of_match_ptr("regulators"),
191 			.id = BD957X_VOUTS1,
192 			.ops = &bd957X_vouts1_regulator_ops,
193 			.type = REGULATOR_VOLTAGE,
194 			.n_voltages = 1,
195 			.fixed_uV = BD957X_VOUTS1_VOLT,
196 			.enable_reg = BD957X_REG_POW_TRIGGERS1,
197 			.enable_mask = BD957X_REGULATOR_EN_MASK,
198 			.enable_val = BD957X_REGULATOR_DIS_VAL,
199 			.enable_is_inverted = true,
200 			.owner = THIS_MODULE,
201 		},
202 	},
203 };
204 
205 static int bd957x_probe(struct platform_device *pdev)
206 {
207 	struct regmap *regmap;
208 	struct regulator_config config = { 0 };
209 	int i, err;
210 	bool vout_mode, ddr_sel;
211 	const struct bd957x_regulator_data *reg_data = &bd9576_regulators[0];
212 	unsigned int num_reg_data = ARRAY_SIZE(bd9576_regulators);
213 	enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
214 
215 	regmap = dev_get_regmap(pdev->dev.parent, NULL);
216 	if (!regmap) {
217 		dev_err(&pdev->dev, "No regmap\n");
218 		return -EINVAL;
219 	}
220 	vout_mode = of_property_read_bool(pdev->dev.parent->of_node,
221 					 "rohm,vout1-en-low");
222 	if (vout_mode) {
223 		struct gpio_desc *en;
224 
225 		dev_dbg(&pdev->dev, "GPIO controlled mode\n");
226 
227 		/* VOUT1 enable state judged by VOUT1_EN pin */
228 		/* See if we have GPIO defined */
229 		en = devm_gpiod_get_from_of_node(&pdev->dev,
230 						 pdev->dev.parent->of_node,
231 						 "rohm,vout1-en-gpios", 0,
232 						 GPIOD_OUT_LOW, "vout1-en");
233 		if (!IS_ERR(en)) {
234 			/* VOUT1_OPS gpio ctrl */
235 			/*
236 			 * Regulator core prioritizes the ena_gpio over
237 			 * enable/disable/is_enabled callbacks so no need to
238 			 * clear them. We can still use same ops
239 			 */
240 			config.ena_gpiod = en;
241 		} else {
242 			/*
243 			 * In theory it is possible someone wants to set
244 			 * vout1-en LOW during OTP loading and set VOUT1 to be
245 			 * controlled by GPIO - but control the GPIO from some
246 			 * where else than this driver. For that to work we
247 			 * should unset the is_enabled callback here.
248 			 *
249 			 * I believe such case where rohm,vout1-en-low is set
250 			 * and vout1-en-gpios is not is likely to be a
251 			 * misconfiguration. So let's just err out for now.
252 			 */
253 			dev_err(&pdev->dev,
254 				"Failed to get VOUT1 control GPIO\n");
255 			return PTR_ERR(en);
256 		}
257 	}
258 
259 	/*
260 	 * If more than one PMIC needs to be controlled by same processor then
261 	 * allocate the regulator data array here and use bd9576_regulators as
262 	 * template. At the moment I see no such use-case so I spare some
263 	 * bytes and use bd9576_regulators directly for non-constant configs
264 	 * like DDR voltage selection.
265 	 */
266 	ddr_sel =  of_property_read_bool(pdev->dev.parent->of_node,
267 					 "rohm,ddr-sel-low");
268 	if (ddr_sel)
269 		bd9576_regulators[2].desc.fixed_uV = 1350000;
270 	else
271 		bd9576_regulators[2].desc.fixed_uV = 1500000;
272 
273 	switch (chip) {
274 	case ROHM_CHIP_TYPE_BD9576:
275 		dev_dbg(&pdev->dev, "Found BD9576MUF\n");
276 		break;
277 	case ROHM_CHIP_TYPE_BD9573:
278 		dev_dbg(&pdev->dev, "Found BD9573MUF\n");
279 		break;
280 	default:
281 		dev_err(&pdev->dev, "Unsupported chip type\n");
282 		err = -EINVAL;
283 		goto err;
284 	}
285 
286 	config.dev = pdev->dev.parent;
287 	config.regmap = regmap;
288 
289 	for (i = 0; i < num_reg_data; i++) {
290 
291 		const struct regulator_desc *desc;
292 		struct regulator_dev *rdev;
293 		const struct bd957x_regulator_data *r;
294 
295 		r = &reg_data[i];
296 		desc = &r->desc;
297 
298 		rdev = devm_regulator_register(&pdev->dev, desc, &config);
299 		if (IS_ERR(rdev)) {
300 			dev_err(&pdev->dev,
301 				"failed to register %s regulator\n",
302 				desc->name);
303 			err = PTR_ERR(rdev);
304 			goto err;
305 		}
306 		/*
307 		 * Clear the VOUT1 GPIO setting - rest of the regulators do not
308 		 * support GPIO control
309 		 */
310 		config.ena_gpiod = NULL;
311 	}
312 
313 err:
314 	return err;
315 }
316 
317 static const struct platform_device_id bd957x_pmic_id[] = {
318 	{ "bd9573-pmic", ROHM_CHIP_TYPE_BD9573 },
319 	{ "bd9576-pmic", ROHM_CHIP_TYPE_BD9576 },
320 	{ },
321 };
322 MODULE_DEVICE_TABLE(platform, bd957x_pmic_id);
323 
324 static struct platform_driver bd957x_regulator = {
325 	.driver = {
326 		.name = "bd957x-pmic",
327 	},
328 	.probe = bd957x_probe,
329 	.id_table = bd957x_pmic_id,
330 };
331 
332 module_platform_driver(bd957x_regulator);
333 
334 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
335 MODULE_DESCRIPTION("ROHM BD9576/BD9573 voltage regulator driver");
336 MODULE_LICENSE("GPL");
337 MODULE_ALIAS("platform:bd957x-pmic");
338