1 /*
2  * wm831x-ldo.c  --  LDO driver for the WM831x series
3  *
4  * Copyright 2009 Wolfson Microelectronics PLC.
5  *
6  * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
7  *
8  *  This program is free software; you can redistribute  it and/or modify it
9  *  under  the terms of  the GNU General  Public License as published by the
10  *  Free Software Foundation;  either version 2 of the  License, or (at your
11  *  option) any later version.
12  */
13 
14 #include <linux/module.h>
15 #include <linux/moduleparam.h>
16 #include <linux/init.h>
17 #include <linux/bitops.h>
18 #include <linux/err.h>
19 #include <linux/i2c.h>
20 #include <linux/platform_device.h>
21 #include <linux/regulator/driver.h>
22 #include <linux/slab.h>
23 
24 #include <linux/mfd/wm831x/core.h>
25 #include <linux/mfd/wm831x/regulator.h>
26 #include <linux/mfd/wm831x/pdata.h>
27 
28 #define WM831X_LDO_MAX_NAME 9
29 
30 #define WM831X_LDO_CONTROL       0
31 #define WM831X_LDO_ON_CONTROL    1
32 #define WM831X_LDO_SLEEP_CONTROL 2
33 
34 #define WM831X_ALIVE_LDO_ON_CONTROL    0
35 #define WM831X_ALIVE_LDO_SLEEP_CONTROL 1
36 
37 struct wm831x_ldo {
38 	char name[WM831X_LDO_MAX_NAME];
39 	char supply_name[WM831X_LDO_MAX_NAME];
40 	struct regulator_desc desc;
41 	int base;
42 	struct wm831x *wm831x;
43 	struct regulator_dev *regulator;
44 };
45 
46 /*
47  * Shared
48  */
49 
wm831x_ldo_uv_irq(int irq,void * data)50 static irqreturn_t wm831x_ldo_uv_irq(int irq, void *data)
51 {
52 	struct wm831x_ldo *ldo = data;
53 
54 	regulator_notifier_call_chain(ldo->regulator,
55 				      REGULATOR_EVENT_UNDER_VOLTAGE,
56 				      NULL);
57 
58 	return IRQ_HANDLED;
59 }
60 
61 /*
62  * General purpose LDOs
63  */
64 
65 static const struct regulator_linear_range wm831x_gp_ldo_ranges[] = {
66 	REGULATOR_LINEAR_RANGE(900000, 0, 14, 50000),
67 	REGULATOR_LINEAR_RANGE(1700000, 15, 31, 100000),
68 };
69 
wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev * rdev,int uV)70 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
71 					     int uV)
72 {
73 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
74 	struct wm831x *wm831x = ldo->wm831x;
75 	int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
76 
77 	sel = regulator_map_voltage_linear_range(rdev, uV, uV);
78 	if (sel < 0)
79 		return sel;
80 
81 	return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
82 }
83 
wm831x_gp_ldo_get_mode(struct regulator_dev * rdev)84 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
85 {
86 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
87 	struct wm831x *wm831x = ldo->wm831x;
88 	int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
89 	int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
90 	int ret;
91 
92 	ret = wm831x_reg_read(wm831x, on_reg);
93 	if (ret < 0)
94 		return ret;
95 
96 	if (!(ret & WM831X_LDO1_ON_MODE))
97 		return REGULATOR_MODE_NORMAL;
98 
99 	ret = wm831x_reg_read(wm831x, ctrl_reg);
100 	if (ret < 0)
101 		return ret;
102 
103 	if (ret & WM831X_LDO1_LP_MODE)
104 		return REGULATOR_MODE_STANDBY;
105 	else
106 		return REGULATOR_MODE_IDLE;
107 }
108 
wm831x_gp_ldo_set_mode(struct regulator_dev * rdev,unsigned int mode)109 static int wm831x_gp_ldo_set_mode(struct regulator_dev *rdev,
110 				  unsigned int mode)
111 {
112 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
113 	struct wm831x *wm831x = ldo->wm831x;
114 	int ctrl_reg = ldo->base + WM831X_LDO_CONTROL;
115 	int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
116 	int ret;
117 
118 
119 	switch (mode) {
120 	case REGULATOR_MODE_NORMAL:
121 		ret = wm831x_set_bits(wm831x, on_reg,
122 				      WM831X_LDO1_ON_MODE, 0);
123 		if (ret < 0)
124 			return ret;
125 		break;
126 
127 	case REGULATOR_MODE_IDLE:
128 		ret = wm831x_set_bits(wm831x, ctrl_reg,
129 				      WM831X_LDO1_LP_MODE, 0);
130 		if (ret < 0)
131 			return ret;
132 
133 		ret = wm831x_set_bits(wm831x, on_reg,
134 				      WM831X_LDO1_ON_MODE,
135 				      WM831X_LDO1_ON_MODE);
136 		if (ret < 0)
137 			return ret;
138 		break;
139 
140 	case REGULATOR_MODE_STANDBY:
141 		ret = wm831x_set_bits(wm831x, ctrl_reg,
142 				      WM831X_LDO1_LP_MODE,
143 				      WM831X_LDO1_LP_MODE);
144 		if (ret < 0)
145 			return ret;
146 
147 		ret = wm831x_set_bits(wm831x, on_reg,
148 				      WM831X_LDO1_ON_MODE,
149 				      WM831X_LDO1_ON_MODE);
150 		if (ret < 0)
151 			return ret;
152 		break;
153 
154 	default:
155 		return -EINVAL;
156 	}
157 
158 	return 0;
159 }
160 
wm831x_gp_ldo_get_status(struct regulator_dev * rdev)161 static int wm831x_gp_ldo_get_status(struct regulator_dev *rdev)
162 {
163 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
164 	struct wm831x *wm831x = ldo->wm831x;
165 	int mask = 1 << rdev_get_id(rdev);
166 	int ret;
167 
168 	/* Is the regulator on? */
169 	ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
170 	if (ret < 0)
171 		return ret;
172 	if (!(ret & mask))
173 		return REGULATOR_STATUS_OFF;
174 
175 	/* Is it reporting under voltage? */
176 	ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
177 	if (ret < 0)
178 		return ret;
179 	if (ret & mask)
180 		return REGULATOR_STATUS_ERROR;
181 
182 	ret = wm831x_gp_ldo_get_mode(rdev);
183 	if (ret < 0)
184 		return ret;
185 	else
186 		return regulator_mode_to_status(ret);
187 }
188 
wm831x_gp_ldo_get_optimum_mode(struct regulator_dev * rdev,int input_uV,int output_uV,int load_uA)189 static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
190 						   int input_uV,
191 						   int output_uV, int load_uA)
192 {
193 	if (load_uA < 20000)
194 		return REGULATOR_MODE_STANDBY;
195 	if (load_uA < 50000)
196 		return REGULATOR_MODE_IDLE;
197 	return REGULATOR_MODE_NORMAL;
198 }
199 
200 
201 static const struct regulator_ops wm831x_gp_ldo_ops = {
202 	.list_voltage = regulator_list_voltage_linear_range,
203 	.map_voltage = regulator_map_voltage_linear_range,
204 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
205 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
206 	.set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
207 	.get_mode = wm831x_gp_ldo_get_mode,
208 	.set_mode = wm831x_gp_ldo_set_mode,
209 	.get_status = wm831x_gp_ldo_get_status,
210 	.get_optimum_mode = wm831x_gp_ldo_get_optimum_mode,
211 	.get_bypass = regulator_get_bypass_regmap,
212 	.set_bypass = regulator_set_bypass_regmap,
213 
214 	.is_enabled = regulator_is_enabled_regmap,
215 	.enable = regulator_enable_regmap,
216 	.disable = regulator_disable_regmap,
217 };
218 
wm831x_gp_ldo_probe(struct platform_device * pdev)219 static int wm831x_gp_ldo_probe(struct platform_device *pdev)
220 {
221 	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
222 	struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
223 	struct regulator_config config = { };
224 	int id;
225 	struct wm831x_ldo *ldo;
226 	struct resource *res;
227 	int ret, irq;
228 
229 	if (pdata && pdata->wm831x_num)
230 		id = (pdata->wm831x_num * 10) + 1;
231 	else
232 		id = 0;
233 	id = pdev->id - id;
234 
235 	dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
236 
237 	ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
238 	if (!ldo)
239 		return -ENOMEM;
240 
241 	ldo->wm831x = wm831x;
242 
243 	res = platform_get_resource(pdev, IORESOURCE_REG, 0);
244 	if (res == NULL) {
245 		dev_err(&pdev->dev, "No REG resource\n");
246 		ret = -EINVAL;
247 		goto err;
248 	}
249 	ldo->base = res->start;
250 
251 	snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
252 	ldo->desc.name = ldo->name;
253 
254 	snprintf(ldo->supply_name, sizeof(ldo->supply_name),
255 		 "LDO%dVDD", id + 1);
256 	ldo->desc.supply_name = ldo->supply_name;
257 
258 	ldo->desc.id = id;
259 	ldo->desc.type = REGULATOR_VOLTAGE;
260 	ldo->desc.n_voltages = 32;
261 	ldo->desc.ops = &wm831x_gp_ldo_ops;
262 	ldo->desc.owner = THIS_MODULE;
263 	ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
264 	ldo->desc.vsel_mask = WM831X_LDO1_ON_VSEL_MASK;
265 	ldo->desc.enable_reg = WM831X_LDO_ENABLE;
266 	ldo->desc.enable_mask = 1 << id;
267 	ldo->desc.bypass_reg = ldo->base;
268 	ldo->desc.bypass_mask = WM831X_LDO1_SWI;
269 	ldo->desc.linear_ranges = wm831x_gp_ldo_ranges;
270 	ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_gp_ldo_ranges);
271 
272 	config.dev = pdev->dev.parent;
273 	if (pdata)
274 		config.init_data = pdata->ldo[id];
275 	config.driver_data = ldo;
276 	config.regmap = wm831x->regmap;
277 
278 	ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
279 						 &config);
280 	if (IS_ERR(ldo->regulator)) {
281 		ret = PTR_ERR(ldo->regulator);
282 		dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
283 			id + 1, ret);
284 		goto err;
285 	}
286 
287 	irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
288 	ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
289 					wm831x_ldo_uv_irq,
290 					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
291 					ldo->name,
292 					ldo);
293 	if (ret != 0) {
294 		dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
295 			irq, ret);
296 		goto err;
297 	}
298 
299 	platform_set_drvdata(pdev, ldo);
300 
301 	return 0;
302 
303 err:
304 	return ret;
305 }
306 
307 static struct platform_driver wm831x_gp_ldo_driver = {
308 	.probe = wm831x_gp_ldo_probe,
309 	.driver		= {
310 		.name	= "wm831x-ldo",
311 	},
312 };
313 
314 /*
315  * Analogue LDOs
316  */
317 
318 static const struct regulator_linear_range wm831x_aldo_ranges[] = {
319 	REGULATOR_LINEAR_RANGE(1000000, 0, 12, 50000),
320 	REGULATOR_LINEAR_RANGE(1700000, 13, 31, 100000),
321 };
322 
wm831x_aldo_set_suspend_voltage(struct regulator_dev * rdev,int uV)323 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
324 					     int uV)
325 {
326 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
327 	struct wm831x *wm831x = ldo->wm831x;
328 	int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
329 
330 	sel = regulator_map_voltage_linear_range(rdev, uV, uV);
331 	if (sel < 0)
332 		return sel;
333 
334 	return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
335 }
336 
wm831x_aldo_get_mode(struct regulator_dev * rdev)337 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
338 {
339 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
340 	struct wm831x *wm831x = ldo->wm831x;
341 	int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
342 	int ret;
343 
344 	ret = wm831x_reg_read(wm831x, on_reg);
345 	if (ret < 0)
346 		return 0;
347 
348 	if (ret & WM831X_LDO7_ON_MODE)
349 		return REGULATOR_MODE_IDLE;
350 	else
351 		return REGULATOR_MODE_NORMAL;
352 }
353 
wm831x_aldo_set_mode(struct regulator_dev * rdev,unsigned int mode)354 static int wm831x_aldo_set_mode(struct regulator_dev *rdev,
355 				  unsigned int mode)
356 {
357 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
358 	struct wm831x *wm831x = ldo->wm831x;
359 	int on_reg = ldo->base + WM831X_LDO_ON_CONTROL;
360 	int ret;
361 
362 
363 	switch (mode) {
364 	case REGULATOR_MODE_NORMAL:
365 		ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE, 0);
366 		if (ret < 0)
367 			return ret;
368 		break;
369 
370 	case REGULATOR_MODE_IDLE:
371 		ret = wm831x_set_bits(wm831x, on_reg, WM831X_LDO7_ON_MODE,
372 				      WM831X_LDO7_ON_MODE);
373 		if (ret < 0)
374 			return ret;
375 		break;
376 
377 	default:
378 		return -EINVAL;
379 	}
380 
381 	return 0;
382 }
383 
wm831x_aldo_get_status(struct regulator_dev * rdev)384 static int wm831x_aldo_get_status(struct regulator_dev *rdev)
385 {
386 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
387 	struct wm831x *wm831x = ldo->wm831x;
388 	int mask = 1 << rdev_get_id(rdev);
389 	int ret;
390 
391 	/* Is the regulator on? */
392 	ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
393 	if (ret < 0)
394 		return ret;
395 	if (!(ret & mask))
396 		return REGULATOR_STATUS_OFF;
397 
398 	/* Is it reporting under voltage? */
399 	ret = wm831x_reg_read(wm831x, WM831X_LDO_UV_STATUS);
400 	if (ret < 0)
401 		return ret;
402 	if (ret & mask)
403 		return REGULATOR_STATUS_ERROR;
404 
405 	ret = wm831x_aldo_get_mode(rdev);
406 	if (ret < 0)
407 		return ret;
408 	else
409 		return regulator_mode_to_status(ret);
410 }
411 
412 static const struct regulator_ops wm831x_aldo_ops = {
413 	.list_voltage = regulator_list_voltage_linear_range,
414 	.map_voltage = regulator_map_voltage_linear_range,
415 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
416 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
417 	.set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
418 	.get_mode = wm831x_aldo_get_mode,
419 	.set_mode = wm831x_aldo_set_mode,
420 	.get_status = wm831x_aldo_get_status,
421 	.set_bypass = regulator_set_bypass_regmap,
422 	.get_bypass = regulator_get_bypass_regmap,
423 
424 	.is_enabled = regulator_is_enabled_regmap,
425 	.enable = regulator_enable_regmap,
426 	.disable = regulator_disable_regmap,
427 };
428 
wm831x_aldo_probe(struct platform_device * pdev)429 static int wm831x_aldo_probe(struct platform_device *pdev)
430 {
431 	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
432 	struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
433 	struct regulator_config config = { };
434 	int id;
435 	struct wm831x_ldo *ldo;
436 	struct resource *res;
437 	int ret, irq;
438 
439 	if (pdata && pdata->wm831x_num)
440 		id = (pdata->wm831x_num * 10) + 1;
441 	else
442 		id = 0;
443 	id = pdev->id - id;
444 
445 	dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
446 
447 	ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
448 	if (!ldo)
449 		return -ENOMEM;
450 
451 	ldo->wm831x = wm831x;
452 
453 	res = platform_get_resource(pdev, IORESOURCE_REG, 0);
454 	if (res == NULL) {
455 		dev_err(&pdev->dev, "No REG resource\n");
456 		ret = -EINVAL;
457 		goto err;
458 	}
459 	ldo->base = res->start;
460 
461 	snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
462 	ldo->desc.name = ldo->name;
463 
464 	snprintf(ldo->supply_name, sizeof(ldo->supply_name),
465 		 "LDO%dVDD", id + 1);
466 	ldo->desc.supply_name = ldo->supply_name;
467 
468 	ldo->desc.id = id;
469 	ldo->desc.type = REGULATOR_VOLTAGE;
470 	ldo->desc.n_voltages = 32;
471 	ldo->desc.linear_ranges = wm831x_aldo_ranges;
472 	ldo->desc.n_linear_ranges = ARRAY_SIZE(wm831x_aldo_ranges);
473 	ldo->desc.ops = &wm831x_aldo_ops;
474 	ldo->desc.owner = THIS_MODULE;
475 	ldo->desc.vsel_reg = ldo->base + WM831X_LDO_ON_CONTROL;
476 	ldo->desc.vsel_mask = WM831X_LDO7_ON_VSEL_MASK;
477 	ldo->desc.enable_reg = WM831X_LDO_ENABLE;
478 	ldo->desc.enable_mask = 1 << id;
479 	ldo->desc.bypass_reg = ldo->base;
480 	ldo->desc.bypass_mask = WM831X_LDO7_SWI;
481 
482 	config.dev = pdev->dev.parent;
483 	if (pdata)
484 		config.init_data = pdata->ldo[id];
485 	config.driver_data = ldo;
486 	config.regmap = wm831x->regmap;
487 
488 	ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
489 						 &config);
490 	if (IS_ERR(ldo->regulator)) {
491 		ret = PTR_ERR(ldo->regulator);
492 		dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
493 			id + 1, ret);
494 		goto err;
495 	}
496 
497 	irq = wm831x_irq(wm831x, platform_get_irq_byname(pdev, "UV"));
498 	ret = devm_request_threaded_irq(&pdev->dev, irq, NULL,
499 					wm831x_ldo_uv_irq,
500 					IRQF_TRIGGER_RISING | IRQF_ONESHOT,
501 					ldo->name, ldo);
502 	if (ret != 0) {
503 		dev_err(&pdev->dev, "Failed to request UV IRQ %d: %d\n",
504 			irq, ret);
505 		goto err;
506 	}
507 
508 	platform_set_drvdata(pdev, ldo);
509 
510 	return 0;
511 
512 err:
513 	return ret;
514 }
515 
516 static struct platform_driver wm831x_aldo_driver = {
517 	.probe = wm831x_aldo_probe,
518 	.driver		= {
519 		.name	= "wm831x-aldo",
520 	},
521 };
522 
523 /*
524  * Alive LDO
525  */
526 
527 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
528 
wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev * rdev,int uV)529 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
530 					     int uV)
531 {
532 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
533 	struct wm831x *wm831x = ldo->wm831x;
534 	int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
535 
536 	sel = regulator_map_voltage_linear(rdev, uV, uV);
537 	if (sel < 0)
538 		return sel;
539 
540 	return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
541 }
542 
wm831x_alive_ldo_get_status(struct regulator_dev * rdev)543 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
544 {
545 	struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
546 	struct wm831x *wm831x = ldo->wm831x;
547 	int mask = 1 << rdev_get_id(rdev);
548 	int ret;
549 
550 	/* Is the regulator on? */
551 	ret = wm831x_reg_read(wm831x, WM831X_LDO_STATUS);
552 	if (ret < 0)
553 		return ret;
554 	if (ret & mask)
555 		return REGULATOR_STATUS_ON;
556 	else
557 		return REGULATOR_STATUS_OFF;
558 }
559 
560 static const struct regulator_ops wm831x_alive_ldo_ops = {
561 	.list_voltage = regulator_list_voltage_linear,
562 	.map_voltage = regulator_map_voltage_linear,
563 	.get_voltage_sel = regulator_get_voltage_sel_regmap,
564 	.set_voltage_sel = regulator_set_voltage_sel_regmap,
565 	.set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
566 	.get_status = wm831x_alive_ldo_get_status,
567 
568 	.is_enabled = regulator_is_enabled_regmap,
569 	.enable = regulator_enable_regmap,
570 	.disable = regulator_disable_regmap,
571 };
572 
wm831x_alive_ldo_probe(struct platform_device * pdev)573 static int wm831x_alive_ldo_probe(struct platform_device *pdev)
574 {
575 	struct wm831x *wm831x = dev_get_drvdata(pdev->dev.parent);
576 	struct wm831x_pdata *pdata = dev_get_platdata(wm831x->dev);
577 	struct regulator_config config = { };
578 	int id;
579 	struct wm831x_ldo *ldo;
580 	struct resource *res;
581 	int ret;
582 
583 	if (pdata && pdata->wm831x_num)
584 		id = (pdata->wm831x_num * 10) + 1;
585 	else
586 		id = 0;
587 	id = pdev->id - id;
588 
589 
590 	dev_dbg(&pdev->dev, "Probing LDO%d\n", id + 1);
591 
592 	ldo = devm_kzalloc(&pdev->dev, sizeof(struct wm831x_ldo), GFP_KERNEL);
593 	if (!ldo)
594 		return -ENOMEM;
595 
596 	ldo->wm831x = wm831x;
597 
598 	res = platform_get_resource(pdev, IORESOURCE_REG, 0);
599 	if (res == NULL) {
600 		dev_err(&pdev->dev, "No REG resource\n");
601 		ret = -EINVAL;
602 		goto err;
603 	}
604 	ldo->base = res->start;
605 
606 	snprintf(ldo->name, sizeof(ldo->name), "LDO%d", id + 1);
607 	ldo->desc.name = ldo->name;
608 
609 	snprintf(ldo->supply_name, sizeof(ldo->supply_name),
610 		 "LDO%dVDD", id + 1);
611 	ldo->desc.supply_name = ldo->supply_name;
612 
613 	ldo->desc.id = id;
614 	ldo->desc.type = REGULATOR_VOLTAGE;
615 	ldo->desc.n_voltages = WM831X_ALIVE_LDO_MAX_SELECTOR + 1;
616 	ldo->desc.ops = &wm831x_alive_ldo_ops;
617 	ldo->desc.owner = THIS_MODULE;
618 	ldo->desc.vsel_reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
619 	ldo->desc.vsel_mask = WM831X_LDO11_ON_VSEL_MASK;
620 	ldo->desc.enable_reg = WM831X_LDO_ENABLE;
621 	ldo->desc.enable_mask = 1 << id;
622 	ldo->desc.min_uV = 800000;
623 	ldo->desc.uV_step = 50000;
624 	ldo->desc.enable_time = 1000;
625 
626 	config.dev = pdev->dev.parent;
627 	if (pdata)
628 		config.init_data = pdata->ldo[id];
629 	config.driver_data = ldo;
630 	config.regmap = wm831x->regmap;
631 
632 	ldo->regulator = devm_regulator_register(&pdev->dev, &ldo->desc,
633 						 &config);
634 	if (IS_ERR(ldo->regulator)) {
635 		ret = PTR_ERR(ldo->regulator);
636 		dev_err(wm831x->dev, "Failed to register LDO%d: %d\n",
637 			id + 1, ret);
638 		goto err;
639 	}
640 
641 	platform_set_drvdata(pdev, ldo);
642 
643 	return 0;
644 
645 err:
646 	return ret;
647 }
648 
649 static struct platform_driver wm831x_alive_ldo_driver = {
650 	.probe = wm831x_alive_ldo_probe,
651 	.driver		= {
652 		.name	= "wm831x-alive-ldo",
653 	},
654 };
655 
656 static struct platform_driver * const drivers[] = {
657 	&wm831x_gp_ldo_driver,
658 	&wm831x_aldo_driver,
659 	&wm831x_alive_ldo_driver,
660 };
661 
wm831x_ldo_init(void)662 static int __init wm831x_ldo_init(void)
663 {
664 	return platform_register_drivers(drivers, ARRAY_SIZE(drivers));
665 }
666 subsys_initcall(wm831x_ldo_init);
667 
wm831x_ldo_exit(void)668 static void __exit wm831x_ldo_exit(void)
669 {
670 	platform_unregister_drivers(drivers, ARRAY_SIZE(drivers));
671 }
672 module_exit(wm831x_ldo_exit);
673 
674 /* Module information */
675 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
676 MODULE_DESCRIPTION("WM831x LDO driver");
677 MODULE_LICENSE("GPL");
678 MODULE_ALIAS("platform:wm831x-ldo");
679 MODULE_ALIAS("platform:wm831x-aldo");
680 MODULE_ALIAS("platform:wm831x-aliveldo");
681