1// SPDX-License-Identifier: GPL-2.0-only
2/*
3 * drivers/regulator/ab3100.c
4 *
5 * Copyright (C) 2008-2009 ST-Ericsson AB
6 * Low-level control of the AB3100 IC Low Dropout (LDO)
7 * regulators, external regulator and buck converter
8 * Author: Mattias Wallin <mattias.wallin@stericsson.com>
9 * Author: Linus Walleij <linus.walleij@stericsson.com>
10 */
11
12#include <linux/module.h>
13#include <linux/kernel.h>
14#include <linux/init.h>
15#include <linux/err.h>
16#include <linux/platform_device.h>
17#include <linux/regulator/driver.h>
18#include <linux/mfd/ab3100.h>
19#include <linux/mfd/abx500.h>
20#include <linux/of.h>
21#include <linux/regulator/of_regulator.h>
22
23/* LDO registers and some handy masking definitions for AB3100 */
24#define AB3100_LDO_A		0x40
25#define AB3100_LDO_C		0x41
26#define AB3100_LDO_D		0x42
27#define AB3100_LDO_E		0x43
28#define AB3100_LDO_E_SLEEP	0x44
29#define AB3100_LDO_F		0x45
30#define AB3100_LDO_G		0x46
31#define AB3100_LDO_H		0x47
32#define AB3100_LDO_H_SLEEP_MODE	0
33#define AB3100_LDO_H_SLEEP_EN	2
34#define AB3100_LDO_ON		4
35#define AB3100_LDO_H_VSEL_AC	5
36#define AB3100_LDO_K		0x48
37#define AB3100_LDO_EXT		0x49
38#define AB3100_BUCK		0x4A
39#define AB3100_BUCK_SLEEP	0x4B
40#define AB3100_REG_ON_MASK	0x10
41
42/**
43 * struct ab3100_regulator
44 * A struct passed around the individual regulator functions
45 * @platform_device: platform device holding this regulator
46 * @dev: handle to the device
47 * @plfdata: AB3100 platform data passed in at probe time
48 * @regreg: regulator register number in the AB3100
49 */
50struct ab3100_regulator {
51	struct device *dev;
52	struct ab3100_platform_data *plfdata;
53	u8 regreg;
54};
55
56/* The order in which registers are initialized */
57static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
58	AB3100_LDO_A,
59	AB3100_LDO_C,
60	AB3100_LDO_E,
61	AB3100_LDO_E_SLEEP,
62	AB3100_LDO_F,
63	AB3100_LDO_G,
64	AB3100_LDO_H,
65	AB3100_LDO_K,
66	AB3100_LDO_EXT,
67	AB3100_BUCK,
68	AB3100_BUCK_SLEEP,
69	AB3100_LDO_D,
70};
71
72/* Preset (hardware defined) voltages for these regulators */
73#define LDO_A_VOLTAGE 2750000
74#define LDO_C_VOLTAGE 2650000
75#define LDO_D_VOLTAGE 2650000
76
77static const unsigned int ldo_e_buck_typ_voltages[] = {
78	1800000,
79	1400000,
80	1300000,
81	1200000,
82	1100000,
83	1050000,
84	900000,
85};
86
87static const unsigned int ldo_f_typ_voltages[] = {
88	1800000,
89	1400000,
90	1300000,
91	1200000,
92	1100000,
93	1050000,
94	2500000,
95	2650000,
96};
97
98static const unsigned int ldo_g_typ_voltages[] = {
99	2850000,
100	2750000,
101	1800000,
102	1500000,
103};
104
105static const unsigned int ldo_h_typ_voltages[] = {
106	2750000,
107	1800000,
108	1500000,
109	1200000,
110};
111
112static const unsigned int ldo_k_typ_voltages[] = {
113	2750000,
114	1800000,
115};
116
117
118/* The regulator devices */
119static struct ab3100_regulator
120ab3100_regulators[AB3100_NUM_REGULATORS] = {
121	{
122		.regreg = AB3100_LDO_A,
123	},
124	{
125		.regreg = AB3100_LDO_C,
126	},
127	{
128		.regreg = AB3100_LDO_D,
129	},
130	{
131		.regreg = AB3100_LDO_E,
132	},
133	{
134		.regreg = AB3100_LDO_F,
135	},
136	{
137		.regreg = AB3100_LDO_G,
138	},
139	{
140		.regreg = AB3100_LDO_H,
141	},
142	{
143		.regreg = AB3100_LDO_K,
144	},
145	{
146		.regreg = AB3100_LDO_EXT,
147		/* No voltages for the external regulator */
148	},
149	{
150		.regreg = AB3100_BUCK,
151	},
152};
153
154/*
155 * General functions for enable, disable and is_enabled used for
156 * LDO: A,C,E,F,G,H,K,EXT and BUCK
157 */
158static int ab3100_enable_regulator(struct regulator_dev *reg)
159{
160	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
161	int err;
162	u8 regval;
163
164	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
165						&regval);
166	if (err) {
167		dev_warn(&reg->dev, "failed to get regid %d value\n",
168			 abreg->regreg);
169		return err;
170	}
171
172	/* The regulator is already on, no reason to go further */
173	if (regval & AB3100_REG_ON_MASK)
174		return 0;
175
176	regval |= AB3100_REG_ON_MASK;
177
178	err = abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
179						regval);
180	if (err) {
181		dev_warn(&reg->dev, "failed to set regid %d value\n",
182			 abreg->regreg);
183		return err;
184	}
185
186	return 0;
187}
188
189static int ab3100_disable_regulator(struct regulator_dev *reg)
190{
191	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
192	int err;
193	u8 regval;
194
195	/*
196	 * LDO D is a special regulator. When it is disabled, the entire
197	 * system is shut down. So this is handled specially.
198	 */
199	pr_info("Called ab3100_disable_regulator\n");
200	if (abreg->regreg == AB3100_LDO_D) {
201		dev_info(&reg->dev, "disabling LDO D - shut down system\n");
202		/* Setting LDO D to 0x00 cuts the power to the SoC */
203		return abx500_set_register_interruptible(abreg->dev, 0,
204							 AB3100_LDO_D, 0x00U);
205	}
206
207	/*
208	 * All other regulators are handled here
209	 */
210	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
211						&regval);
212	if (err) {
213		dev_err(&reg->dev, "unable to get register 0x%x\n",
214			abreg->regreg);
215		return err;
216	}
217	regval &= ~AB3100_REG_ON_MASK;
218	return abx500_set_register_interruptible(abreg->dev, 0, abreg->regreg,
219						 regval);
220}
221
222static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
223{
224	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
225	u8 regval;
226	int err;
227
228	err = abx500_get_register_interruptible(abreg->dev, 0, abreg->regreg,
229						&regval);
230	if (err) {
231		dev_err(&reg->dev, "unable to get register 0x%x\n",
232			abreg->regreg);
233		return err;
234	}
235
236	return regval & AB3100_REG_ON_MASK;
237}
238
239static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
240{
241	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
242	u8 regval;
243	int err;
244
245	/*
246	 * For variable types, read out setting and index into
247	 * supplied voltage list.
248	 */
249	err = abx500_get_register_interruptible(abreg->dev, 0,
250						abreg->regreg, &regval);
251	if (err) {
252		dev_warn(&reg->dev,
253			 "failed to get regulator value in register %02x\n",
254			 abreg->regreg);
255		return err;
256	}
257
258	/* The 3 highest bits index voltages */
259	regval &= 0xE0;
260	regval >>= 5;
261
262	if (regval >= reg->desc->n_voltages) {
263		dev_err(&reg->dev,
264			"regulator register %02x contains an illegal voltage setting\n",
265			abreg->regreg);
266		return -EINVAL;
267	}
268
269	return reg->desc->volt_table[regval];
270}
271
272static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
273					    unsigned selector)
274{
275	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
276	u8 regval;
277	int err;
278
279	err = abx500_get_register_interruptible(abreg->dev, 0,
280						abreg->regreg, &regval);
281	if (err) {
282		dev_warn(&reg->dev,
283			 "failed to get regulator register %02x\n",
284			 abreg->regreg);
285		return err;
286	}
287
288	/* The highest three bits control the variable regulators */
289	regval &= ~0xE0;
290	regval |= (selector << 5);
291
292	err = abx500_set_register_interruptible(abreg->dev, 0,
293						abreg->regreg, regval);
294	if (err)
295		dev_warn(&reg->dev, "failed to set regulator register %02x\n",
296			abreg->regreg);
297
298	return err;
299}
300
301static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
302						int uV)
303{
304	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
305	u8 regval;
306	int err;
307	int bestindex;
308	u8 targetreg;
309
310	if (abreg->regreg == AB3100_LDO_E)
311		targetreg = AB3100_LDO_E_SLEEP;
312	else if (abreg->regreg == AB3100_BUCK)
313		targetreg = AB3100_BUCK_SLEEP;
314	else
315		return -EINVAL;
316
317	/* LDO E and BUCK have special suspend voltages you can set */
318	bestindex = regulator_map_voltage_iterate(reg, uV, uV);
319
320	err = abx500_get_register_interruptible(abreg->dev, 0,
321						targetreg, &regval);
322	if (err) {
323		dev_warn(&reg->dev,
324			 "failed to get regulator register %02x\n",
325			 targetreg);
326		return err;
327	}
328
329	/* The highest three bits control the variable regulators */
330	regval &= ~0xE0;
331	regval |= (bestindex << 5);
332
333	err = abx500_set_register_interruptible(abreg->dev, 0,
334						targetreg, regval);
335	if (err)
336		dev_warn(&reg->dev, "failed to set regulator register %02x\n",
337			abreg->regreg);
338
339	return err;
340}
341
342/*
343 * The external regulator can just define a fixed voltage.
344 */
345static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
346{
347	struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
348
349	if (abreg->plfdata)
350		return abreg->plfdata->external_voltage;
351	else
352		/* TODO: encode external voltage into device tree */
353		return 0;
354}
355
356static const struct regulator_ops regulator_ops_fixed = {
357	.enable      = ab3100_enable_regulator,
358	.disable     = ab3100_disable_regulator,
359	.is_enabled  = ab3100_is_enabled_regulator,
360};
361
362static const struct regulator_ops regulator_ops_variable = {
363	.enable      = ab3100_enable_regulator,
364	.disable     = ab3100_disable_regulator,
365	.is_enabled  = ab3100_is_enabled_regulator,
366	.get_voltage = ab3100_get_voltage_regulator,
367	.set_voltage_sel = ab3100_set_voltage_regulator_sel,
368	.list_voltage = regulator_list_voltage_table,
369};
370
371static const struct regulator_ops regulator_ops_variable_sleepable = {
372	.enable      = ab3100_enable_regulator,
373	.disable     = ab3100_disable_regulator,
374	.is_enabled  = ab3100_is_enabled_regulator,
375	.get_voltage = ab3100_get_voltage_regulator,
376	.set_voltage_sel = ab3100_set_voltage_regulator_sel,
377	.set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
378	.list_voltage = regulator_list_voltage_table,
379};
380
381/*
382 * LDO EXT is an external regulator so it is really
383 * not possible to set any voltage locally here, AB3100
384 * is an on/off switch plain an simple. The external
385 * voltage is defined in the board set-up if any.
386 */
387static const struct regulator_ops regulator_ops_external = {
388	.enable      = ab3100_enable_regulator,
389	.disable     = ab3100_disable_regulator,
390	.is_enabled  = ab3100_is_enabled_regulator,
391	.get_voltage = ab3100_get_voltage_regulator_external,
392};
393
394static const struct regulator_desc
395ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
396	{
397		.name = "LDO_A",
398		.id   = AB3100_LDO_A,
399		.ops  = &regulator_ops_fixed,
400		.n_voltages = 1,
401		.type = REGULATOR_VOLTAGE,
402		.owner = THIS_MODULE,
403		.fixed_uV = LDO_A_VOLTAGE,
404		.enable_time = 200,
405	},
406	{
407		.name = "LDO_C",
408		.id   = AB3100_LDO_C,
409		.ops  = &regulator_ops_fixed,
410		.n_voltages = 1,
411		.type = REGULATOR_VOLTAGE,
412		.owner = THIS_MODULE,
413		.fixed_uV = LDO_C_VOLTAGE,
414		.enable_time = 200,
415	},
416	{
417		.name = "LDO_D",
418		.id   = AB3100_LDO_D,
419		.ops  = &regulator_ops_fixed,
420		.n_voltages = 1,
421		.type = REGULATOR_VOLTAGE,
422		.owner = THIS_MODULE,
423		.fixed_uV = LDO_D_VOLTAGE,
424		.enable_time = 200,
425	},
426	{
427		.name = "LDO_E",
428		.id   = AB3100_LDO_E,
429		.ops  = &regulator_ops_variable_sleepable,
430		.n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
431		.volt_table = ldo_e_buck_typ_voltages,
432		.type = REGULATOR_VOLTAGE,
433		.owner = THIS_MODULE,
434		.enable_time = 200,
435	},
436	{
437		.name = "LDO_F",
438		.id   = AB3100_LDO_F,
439		.ops  = &regulator_ops_variable,
440		.n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
441		.volt_table = ldo_f_typ_voltages,
442		.type = REGULATOR_VOLTAGE,
443		.owner = THIS_MODULE,
444		.enable_time = 600,
445	},
446	{
447		.name = "LDO_G",
448		.id   = AB3100_LDO_G,
449		.ops  = &regulator_ops_variable,
450		.n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
451		.volt_table = ldo_g_typ_voltages,
452		.type = REGULATOR_VOLTAGE,
453		.owner = THIS_MODULE,
454		.enable_time = 400,
455	},
456	{
457		.name = "LDO_H",
458		.id   = AB3100_LDO_H,
459		.ops  = &regulator_ops_variable,
460		.n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
461		.volt_table = ldo_h_typ_voltages,
462		.type = REGULATOR_VOLTAGE,
463		.owner = THIS_MODULE,
464		.enable_time = 200,
465	},
466	{
467		.name = "LDO_K",
468		.id   = AB3100_LDO_K,
469		.ops  = &regulator_ops_variable,
470		.n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
471		.volt_table = ldo_k_typ_voltages,
472		.type = REGULATOR_VOLTAGE,
473		.owner = THIS_MODULE,
474		.enable_time = 200,
475	},
476	{
477		.name = "LDO_EXT",
478		.id   = AB3100_LDO_EXT,
479		.ops  = &regulator_ops_external,
480		.type = REGULATOR_VOLTAGE,
481		.owner = THIS_MODULE,
482	},
483	{
484		.name = "BUCK",
485		.id   = AB3100_BUCK,
486		.ops  = &regulator_ops_variable_sleepable,
487		.n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
488		.volt_table = ldo_e_buck_typ_voltages,
489		.type = REGULATOR_VOLTAGE,
490		.owner = THIS_MODULE,
491		.enable_time = 1000,
492	},
493};
494
495static int ab3100_regulator_register(struct platform_device *pdev,
496				     struct ab3100_platform_data *plfdata,
497				     struct regulator_init_data *init_data,
498				     struct device_node *np,
499				     unsigned long id)
500{
501	const struct regulator_desc *desc;
502	struct ab3100_regulator *reg;
503	struct regulator_dev *rdev;
504	struct regulator_config config = { };
505	int err, i;
506
507	for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
508		desc = &ab3100_regulator_desc[i];
509		if (desc->id == id)
510			break;
511	}
512	if (desc->id != id)
513		return -ENODEV;
514
515	/* Same index used for this array */
516	reg = &ab3100_regulators[i];
517
518	/*
519	 * Initialize per-regulator struct.
520	 * Inherit platform data, this comes down from the
521	 * i2c boarddata, from the machine. So if you want to
522	 * see what it looks like for a certain machine, go
523	 * into the machine I2C setup.
524	 */
525	reg->dev = &pdev->dev;
526	if (plfdata) {
527		reg->plfdata = plfdata;
528		config.init_data = &plfdata->reg_constraints[i];
529	} else if (np) {
530		config.of_node = np;
531		config.init_data = init_data;
532	}
533	config.dev = &pdev->dev;
534	config.driver_data = reg;
535
536	rdev = devm_regulator_register(&pdev->dev, desc, &config);
537	if (IS_ERR(rdev)) {
538		err = PTR_ERR(rdev);
539		dev_err(&pdev->dev,
540			"%s: failed to register regulator %s err %d\n",
541			__func__, desc->name,
542			err);
543		return err;
544	}
545
546	return 0;
547}
548
549static struct of_regulator_match ab3100_regulator_matches[] = {
550	{ .name = "ab3100_ldo_a", .driver_data = (void *) AB3100_LDO_A, },
551	{ .name = "ab3100_ldo_c", .driver_data = (void *) AB3100_LDO_C, },
552	{ .name = "ab3100_ldo_d", .driver_data = (void *) AB3100_LDO_D, },
553	{ .name = "ab3100_ldo_e", .driver_data = (void *) AB3100_LDO_E, },
554	{ .name = "ab3100_ldo_f", .driver_data = (void *) AB3100_LDO_F },
555	{ .name = "ab3100_ldo_g", .driver_data = (void *) AB3100_LDO_G },
556	{ .name = "ab3100_ldo_h", .driver_data = (void *) AB3100_LDO_H },
557	{ .name = "ab3100_ldo_k", .driver_data = (void *) AB3100_LDO_K },
558	{ .name = "ab3100_ext", .driver_data = (void *) AB3100_LDO_EXT },
559	{ .name = "ab3100_buck", .driver_data = (void *) AB3100_BUCK },
560};
561
562/*
563 * Initial settings of ab3100 registers.
564 * Common for below LDO regulator settings are that
565 * bit 7-5 controls voltage. Bit 4 turns regulator ON(1) or OFF(0).
566 * Bit 3-2 controls sleep enable and bit 1-0 controls sleep mode.
567 */
568/* LDO_A 0x16: 2.75V, ON, SLEEP_A, SLEEP OFF GND */
569#define LDO_A_SETTING		0x16
570/* LDO_C 0x10: 2.65V, ON, SLEEP_A or B, SLEEP full power */
571#define LDO_C_SETTING		0x10
572/* LDO_D 0x10: 2.65V, ON, sleep mode not used */
573#define LDO_D_SETTING		0x10
574/* LDO_E 0x10: 1.8V, ON, SLEEP_A or B, SLEEP full power */
575#define LDO_E_SETTING		0x10
576/* LDO_E SLEEP 0x00: 1.8V, not used, SLEEP_A or B, not used */
577#define LDO_E_SLEEP_SETTING	0x00
578/* LDO_F 0xD0: 2.5V, ON, SLEEP_A or B, SLEEP full power */
579#define LDO_F_SETTING		0xD0
580/* LDO_G 0x00: 2.85V, OFF, SLEEP_A or B, SLEEP full power */
581#define LDO_G_SETTING		0x00
582/* LDO_H 0x18: 2.75V, ON, SLEEP_B, SLEEP full power */
583#define LDO_H_SETTING		0x18
584/* LDO_K 0x00: 2.75V, OFF, SLEEP_A or B, SLEEP full power */
585#define LDO_K_SETTING		0x00
586/* LDO_EXT 0x00: Voltage not set, OFF, not used, not used */
587#define LDO_EXT_SETTING		0x00
588/* BUCK 0x7D: 1.2V, ON, SLEEP_A and B, SLEEP low power */
589#define BUCK_SETTING	0x7D
590/* BUCK SLEEP 0xAC: 1.05V, Not used, SLEEP_A and B, Not used */
591#define BUCK_SLEEP_SETTING	0xAC
592
593static const u8 ab3100_reg_initvals[] = {
594	LDO_A_SETTING,
595	LDO_C_SETTING,
596	LDO_E_SETTING,
597	LDO_E_SLEEP_SETTING,
598	LDO_F_SETTING,
599	LDO_G_SETTING,
600	LDO_H_SETTING,
601	LDO_K_SETTING,
602	LDO_EXT_SETTING,
603	BUCK_SETTING,
604	BUCK_SLEEP_SETTING,
605	LDO_D_SETTING,
606};
607
608static int
609ab3100_regulator_of_probe(struct platform_device *pdev, struct device_node *np)
610{
611	int err, i;
612
613	/*
614	 * Set up the regulator registers, as was previously done with
615	 * platform data.
616	 */
617	/* Set up regulators */
618	for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
619		err = abx500_set_register_interruptible(&pdev->dev, 0,
620					ab3100_reg_init_order[i],
621					ab3100_reg_initvals[i]);
622		if (err) {
623			dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
624				err);
625			return err;
626		}
627	}
628
629	for (i = 0; i < ARRAY_SIZE(ab3100_regulator_matches); i++) {
630		err = ab3100_regulator_register(
631			pdev, NULL, ab3100_regulator_matches[i].init_data,
632			ab3100_regulator_matches[i].of_node,
633			(unsigned long)ab3100_regulator_matches[i].driver_data);
634		if (err)
635			return err;
636	}
637
638	return 0;
639}
640
641
642static int ab3100_regulators_probe(struct platform_device *pdev)
643{
644	struct ab3100_platform_data *plfdata = dev_get_platdata(&pdev->dev);
645	struct device_node *np = pdev->dev.of_node;
646	int err = 0;
647	u8 data;
648	int i;
649
650	/* Check chip state */
651	err = abx500_get_register_interruptible(&pdev->dev, 0,
652						AB3100_LDO_D, &data);
653	if (err) {
654		dev_err(&pdev->dev, "could not read initial status of LDO_D\n");
655		return err;
656	}
657	if (data & 0x10)
658		dev_notice(&pdev->dev,
659			   "chip is already in active mode (Warm start)\n");
660	else
661		dev_notice(&pdev->dev,
662			   "chip is in inactive mode (Cold start)\n");
663
664	if (np) {
665		err = of_regulator_match(&pdev->dev, np,
666					 ab3100_regulator_matches,
667					 ARRAY_SIZE(ab3100_regulator_matches));
668		if (err < 0) {
669			dev_err(&pdev->dev,
670				"Error parsing regulator init data: %d\n", err);
671			return err;
672		}
673		return ab3100_regulator_of_probe(pdev, np);
674	}
675
676	/* Set up regulators */
677	for (i = 0; i < ARRAY_SIZE(ab3100_reg_init_order); i++) {
678		err = abx500_set_register_interruptible(&pdev->dev, 0,
679					ab3100_reg_init_order[i],
680					plfdata->reg_initvals[i]);
681		if (err) {
682			dev_err(&pdev->dev, "regulator initialization failed with error %d\n",
683				err);
684			return err;
685		}
686	}
687
688	/* Register the regulators */
689	for (i = 0; i < AB3100_NUM_REGULATORS; i++) {
690		const struct regulator_desc *desc = &ab3100_regulator_desc[i];
691
692		err = ab3100_regulator_register(pdev, plfdata, NULL, NULL,
693						desc->id);
694		if (err)
695			return err;
696	}
697
698	return 0;
699}
700
701static struct platform_driver ab3100_regulators_driver = {
702	.driver = {
703		.name  = "ab3100-regulators",
704	},
705	.probe = ab3100_regulators_probe,
706};
707
708static __init int ab3100_regulators_init(void)
709{
710	return platform_driver_register(&ab3100_regulators_driver);
711}
712
713static __exit void ab3100_regulators_exit(void)
714{
715	platform_driver_unregister(&ab3100_regulators_driver);
716}
717
718subsys_initcall(ab3100_regulators_init);
719module_exit(ab3100_regulators_exit);
720
721MODULE_AUTHOR("Mattias Wallin <mattias.wallin@stericsson.com>");
722MODULE_DESCRIPTION("AB3100 Regulator driver");
723MODULE_LICENSE("GPL");
724MODULE_ALIAS("platform:ab3100-regulators");
725