PageRenderTime 69ms CodeModel.GetById 12ms app.highlight 52ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/regulator/wm831x-ldo.c

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