1/*
2 * twl-regulator.c -- support regulators in twl4030/twl6030 family chips
3 *
4 * Copyright (C) 2008 David Brownell
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 */
11
12#include <linux/module.h>
13#include <linux/string.h>
14#include <linux/slab.h>
15#include <linux/init.h>
16#include <linux/err.h>
17#include <linux/platform_device.h>
18#include <linux/of.h>
19#include <linux/of_device.h>
20#include <linux/regulator/driver.h>
21#include <linux/regulator/machine.h>
22#include <linux/regulator/of_regulator.h>
23#include <linux/i2c/twl.h>
24
25
26/*
27 * The TWL4030/TW5030/TPS659x0/TWL6030 family chips include power management, a
28 * USB OTG transceiver, an RTC, ADC, PWM, and lots more.  Some versions
29 * include an audio codec, battery charger, and more voltage regulators.
30 * These chips are often used in OMAP-based systems.
31 *
32 * This driver implements software-based resource control for various
33 * voltage regulators.  This is usually augmented with state machine
34 * based control.
35 */
36
37struct twlreg_info {
38	/* start of regulator's PM_RECEIVER control register bank */
39	u8			base;
40
41	/* twl resource ID, for resource control state machine */
42	u8			id;
43
44	/* voltage in mV = table[VSEL]; table_len must be a power-of-two */
45	u8			table_len;
46	const u16		*table;
47
48	/* State REMAP default configuration */
49	u8			remap;
50
51	/* chip constraints on regulator behavior */
52	u16			min_mV;
53	u16			max_mV;
54
55	u8			flags;
56
57	/* used by regulator core */
58	struct regulator_desc	desc;
59
60	/* chip specific features */
61	unsigned long		features;
62
63	/*
64	 * optional override functions for voltage set/get
65	 * these are currently only used for SMPS regulators
66	 */
67	int			(*get_voltage)(void *data);
68	int			(*set_voltage)(void *data, int target_uV);
69
70	/* data passed from board for external get/set voltage */
71	void			*data;
72};
73
74
75/* LDO control registers ... offset is from the base of its register bank.
76 * The first three registers of all power resource banks help hardware to
77 * manage the various resource groups.
78 */
79/* Common offset in TWL4030/6030 */
80#define VREG_GRP		0
81/* TWL4030 register offsets */
82#define VREG_TYPE		1
83#define VREG_REMAP		2
84#define VREG_DEDICATED		3	/* LDO control */
85#define VREG_VOLTAGE_SMPS_4030	9
86/* TWL6030 register offsets */
87#define VREG_TRANS		1
88#define VREG_STATE		2
89#define VREG_VOLTAGE		3
90#define VREG_VOLTAGE_SMPS	4
91/* TWL6030 Misc register offsets */
92#define VREG_BC_ALL		1
93#define VREG_BC_REF		2
94#define VREG_BC_PROC		3
95#define VREG_BC_CLK_RST		4
96
97/* TWL6030 LDO register values for CFG_STATE */
98#define TWL6030_CFG_STATE_OFF	0x00
99#define TWL6030_CFG_STATE_ON	0x01
100#define TWL6030_CFG_STATE_OFF2	0x02
101#define TWL6030_CFG_STATE_SLEEP	0x03
102#define TWL6030_CFG_STATE_GRP_SHIFT	5
103#define TWL6030_CFG_STATE_APP_SHIFT	2
104#define TWL6030_CFG_STATE_APP_MASK	(0x03 << TWL6030_CFG_STATE_APP_SHIFT)
105#define TWL6030_CFG_STATE_APP(v)	(((v) & TWL6030_CFG_STATE_APP_MASK) >>\
106						TWL6030_CFG_STATE_APP_SHIFT)
107
108/* Flags for SMPS Voltage reading */
109#define SMPS_OFFSET_EN		BIT(0)
110#define SMPS_EXTENDED_EN	BIT(1)
111
112/* twl6032 SMPS EPROM values */
113#define TWL6030_SMPS_OFFSET		0xB0
114#define TWL6030_SMPS_MULT		0xB3
115#define SMPS_MULTOFFSET_SMPS4	BIT(0)
116#define SMPS_MULTOFFSET_VIO	BIT(1)
117#define SMPS_MULTOFFSET_SMPS3	BIT(6)
118
119static inline int
120twlreg_read(struct twlreg_info *info, unsigned slave_subgp, unsigned offset)
121{
122	u8 value;
123	int status;
124
125	status = twl_i2c_read_u8(slave_subgp,
126			&value, info->base + offset);
127	return (status < 0) ? status : value;
128}
129
130static inline int
131twlreg_write(struct twlreg_info *info, unsigned slave_subgp, unsigned offset,
132						 u8 value)
133{
134	return twl_i2c_write_u8(slave_subgp,
135			value, info->base + offset);
136}
137
138/*----------------------------------------------------------------------*/
139
140/* generic power resource operations, which work on all regulators */
141
142static int twlreg_grp(struct regulator_dev *rdev)
143{
144	return twlreg_read(rdev_get_drvdata(rdev), TWL_MODULE_PM_RECEIVER,
145								 VREG_GRP);
146}
147
148/*
149 * Enable/disable regulators by joining/leaving the P1 (processor) group.
150 * We assume nobody else is updating the DEV_GRP registers.
151 */
152/* definition for 4030 family */
153#define P3_GRP_4030	BIT(7)		/* "peripherals" */
154#define P2_GRP_4030	BIT(6)		/* secondary processor, modem, etc */
155#define P1_GRP_4030	BIT(5)		/* CPU/Linux */
156/* definition for 6030 family */
157#define P3_GRP_6030	BIT(2)		/* secondary processor, modem, etc */
158#define P2_GRP_6030	BIT(1)		/* "peripherals" */
159#define P1_GRP_6030	BIT(0)		/* CPU/Linux */
160
161static int twl4030reg_is_enabled(struct regulator_dev *rdev)
162{
163	int	state = twlreg_grp(rdev);
164
165	if (state < 0)
166		return state;
167
168	return state & P1_GRP_4030;
169}
170
171static int twl6030reg_is_enabled(struct regulator_dev *rdev)
172{
173	struct twlreg_info	*info = rdev_get_drvdata(rdev);
174	int			grp = 0, val;
175
176	if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS))) {
177		grp = twlreg_grp(rdev);
178		if (grp < 0)
179			return grp;
180		grp &= P1_GRP_6030;
181	} else {
182		grp = 1;
183	}
184
185	val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE);
186	val = TWL6030_CFG_STATE_APP(val);
187
188	return grp && (val == TWL6030_CFG_STATE_ON);
189}
190
191static int twl4030reg_enable(struct regulator_dev *rdev)
192{
193	struct twlreg_info	*info = rdev_get_drvdata(rdev);
194	int			grp;
195	int			ret;
196
197	grp = twlreg_grp(rdev);
198	if (grp < 0)
199		return grp;
200
201	grp |= P1_GRP_4030;
202
203	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_GRP, grp);
204
205	return ret;
206}
207
208static int twl6030reg_enable(struct regulator_dev *rdev)
209{
210	struct twlreg_info	*info = rdev_get_drvdata(rdev);
211	int			grp = 0;
212	int			ret;
213
214	if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
215		grp = twlreg_grp(rdev);
216	if (grp < 0)
217		return grp;
218
219	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,
220			grp << TWL6030_CFG_STATE_GRP_SHIFT |
221			TWL6030_CFG_STATE_ON);
222	return ret;
223}
224
225static int twl4030reg_disable(struct regulator_dev *rdev)
226{
227	struct twlreg_info	*info = rdev_get_drvdata(rdev);
228	int			grp;
229	int			ret;
230
231	grp = twlreg_grp(rdev);
232	if (grp < 0)
233		return grp;
234
235	grp &= ~(P1_GRP_4030 | P2_GRP_4030 | P3_GRP_4030);
236
237	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_GRP, grp);
238
239	return ret;
240}
241
242static int twl6030reg_disable(struct regulator_dev *rdev)
243{
244	struct twlreg_info	*info = rdev_get_drvdata(rdev);
245	int			grp = 0;
246	int			ret;
247
248	if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
249		grp = P1_GRP_6030 | P2_GRP_6030 | P3_GRP_6030;
250
251	/* For 6030, set the off state for all grps enabled */
252	ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE,
253			(grp) << TWL6030_CFG_STATE_GRP_SHIFT |
254			TWL6030_CFG_STATE_OFF);
255
256	return ret;
257}
258
259static int twl4030reg_get_status(struct regulator_dev *rdev)
260{
261	int	state = twlreg_grp(rdev);
262
263	if (state < 0)
264		return state;
265	state &= 0x0f;
266
267	/* assume state != WARM_RESET; we'd not be running...  */
268	if (!state)
269		return REGULATOR_STATUS_OFF;
270	return (state & BIT(3))
271		? REGULATOR_STATUS_NORMAL
272		: REGULATOR_STATUS_STANDBY;
273}
274
275static int twl6030reg_get_status(struct regulator_dev *rdev)
276{
277	struct twlreg_info	*info = rdev_get_drvdata(rdev);
278	int			val;
279
280	val = twlreg_grp(rdev);
281	if (val < 0)
282		return val;
283
284	val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE);
285
286	switch (TWL6030_CFG_STATE_APP(val)) {
287	case TWL6030_CFG_STATE_ON:
288		return REGULATOR_STATUS_NORMAL;
289
290	case TWL6030_CFG_STATE_SLEEP:
291		return REGULATOR_STATUS_STANDBY;
292
293	case TWL6030_CFG_STATE_OFF:
294	case TWL6030_CFG_STATE_OFF2:
295	default:
296		break;
297	}
298
299	return REGULATOR_STATUS_OFF;
300}
301
302static int twl4030reg_set_mode(struct regulator_dev *rdev, unsigned mode)
303{
304	struct twlreg_info	*info = rdev_get_drvdata(rdev);
305	unsigned		message;
306	int			status;
307
308	/* We can only set the mode through state machine commands... */
309	switch (mode) {
310	case REGULATOR_MODE_NORMAL:
311		message = MSG_SINGULAR(DEV_GRP_P1, info->id, RES_STATE_ACTIVE);
312		break;
313	case REGULATOR_MODE_STANDBY:
314		message = MSG_SINGULAR(DEV_GRP_P1, info->id, RES_STATE_SLEEP);
315		break;
316	default:
317		return -EINVAL;
318	}
319
320	/* Ensure the resource is associated with some group */
321	status = twlreg_grp(rdev);
322	if (status < 0)
323		return status;
324	if (!(status & (P3_GRP_4030 | P2_GRP_4030 | P1_GRP_4030)))
325		return -EACCES;
326
327	status = twl_i2c_write_u8(TWL_MODULE_PM_MASTER,
328			message >> 8, TWL4030_PM_MASTER_PB_WORD_MSB);
329	if (status < 0)
330		return status;
331
332	return twl_i2c_write_u8(TWL_MODULE_PM_MASTER,
333			message & 0xff, TWL4030_PM_MASTER_PB_WORD_LSB);
334}
335
336static int twl6030reg_set_mode(struct regulator_dev *rdev, unsigned mode)
337{
338	struct twlreg_info	*info = rdev_get_drvdata(rdev);
339	int grp = 0;
340	int val;
341
342	if (!(twl_class_is_6030() && (info->features & TWL6032_SUBCLASS)))
343		grp = twlreg_grp(rdev);
344
345	if (grp < 0)
346		return grp;
347
348	/* Compose the state register settings */
349	val = grp << TWL6030_CFG_STATE_GRP_SHIFT;
350	/* We can only set the mode through state machine commands... */
351	switch (mode) {
352	case REGULATOR_MODE_NORMAL:
353		val |= TWL6030_CFG_STATE_ON;
354		break;
355	case REGULATOR_MODE_STANDBY:
356		val |= TWL6030_CFG_STATE_SLEEP;
357		break;
358
359	default:
360		return -EINVAL;
361	}
362
363	return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE, val);
364}
365
366/*----------------------------------------------------------------------*/
367
368/*
369 * Support for adjustable-voltage LDOs uses a four bit (or less) voltage
370 * select field in its control register.   We use tables indexed by VSEL
371 * to record voltages in milliVolts.  (Accuracy is about three percent.)
372 *
373 * Note that VSEL values for VAUX2 changed in twl5030 and newer silicon;
374 * currently handled by listing two slightly different VAUX2 regulators,
375 * only one of which will be configured.
376 *
377 * VSEL values documented as "TI cannot support these values" are flagged
378 * in these tables as UNSUP() values; we normally won't assign them.
379 *
380 * VAUX3 at 3V is incorrectly listed in some TI manuals as unsupported.
381 * TI are revising the twl5030/tps659x0 specs to support that 3.0V setting.
382 */
383#define UNSUP_MASK	0x8000
384
385#define UNSUP(x)	(UNSUP_MASK | (x))
386#define IS_UNSUP(info, x)			\
387	((UNSUP_MASK & (x)) &&			\
388	 !((info)->features & TWL4030_ALLOW_UNSUPPORTED))
389#define LDO_MV(x)	(~UNSUP_MASK & (x))
390
391
392static const u16 VAUX1_VSEL_table[] = {
393	UNSUP(1500), UNSUP(1800), 2500, 2800,
394	3000, 3000, 3000, 3000,
395};
396static const u16 VAUX2_4030_VSEL_table[] = {
397	UNSUP(1000), UNSUP(1000), UNSUP(1200), 1300,
398	1500, 1800, UNSUP(1850), 2500,
399	UNSUP(2600), 2800, UNSUP(2850), UNSUP(3000),
400	UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150),
401};
402static const u16 VAUX2_VSEL_table[] = {
403	1700, 1700, 1900, 1300,
404	1500, 1800, 2000, 2500,
405	2100, 2800, 2200, 2300,
406	2400, 2400, 2400, 2400,
407};
408static const u16 VAUX3_VSEL_table[] = {
409	1500, 1800, 2500, 2800,
410	3000, 3000, 3000, 3000,
411};
412static const u16 VAUX4_VSEL_table[] = {
413	700, 1000, 1200, UNSUP(1300),
414	1500, 1800, UNSUP(1850), 2500,
415	UNSUP(2600), 2800, UNSUP(2850), UNSUP(3000),
416	UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150),
417};
418static const u16 VMMC1_VSEL_table[] = {
419	1850, 2850, 3000, 3150,
420};
421static const u16 VMMC2_VSEL_table[] = {
422	UNSUP(1000), UNSUP(1000), UNSUP(1200), UNSUP(1300),
423	UNSUP(1500), UNSUP(1800), 1850, UNSUP(2500),
424	2600, 2800, 2850, 3000,
425	3150, 3150, 3150, 3150,
426};
427static const u16 VPLL1_VSEL_table[] = {
428	1000, 1200, 1300, 1800,
429	UNSUP(2800), UNSUP(3000), UNSUP(3000), UNSUP(3000),
430};
431static const u16 VPLL2_VSEL_table[] = {
432	700, 1000, 1200, 1300,
433	UNSUP(1500), 1800, UNSUP(1850), UNSUP(2500),
434	UNSUP(2600), UNSUP(2800), UNSUP(2850), UNSUP(3000),
435	UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150),
436};
437static const u16 VSIM_VSEL_table[] = {
438	UNSUP(1000), UNSUP(1200), UNSUP(1300), 1800,
439	2800, 3000, 3000, 3000,
440};
441static const u16 VDAC_VSEL_table[] = {
442	1200, 1300, 1800, 1800,
443};
444static const u16 VIO_VSEL_table[] = {
445	1800, 1850,
446};
447static const u16 VINTANA2_VSEL_table[] = {
448	2500, 2750,
449};
450
451static int twl4030ldo_list_voltage(struct regulator_dev *rdev, unsigned index)
452{
453	struct twlreg_info	*info = rdev_get_drvdata(rdev);
454	int			mV = info->table[index];
455
456	return IS_UNSUP(info, mV) ? 0 : (LDO_MV(mV) * 1000);
457}
458
459static int
460twl4030ldo_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
461{
462	struct twlreg_info	*info = rdev_get_drvdata(rdev);
463
464	return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE,
465			    selector);
466}
467
468static int twl4030ldo_get_voltage_sel(struct regulator_dev *rdev)
469{
470	struct twlreg_info	*info = rdev_get_drvdata(rdev);
471	int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE);
472
473	if (vsel < 0)
474		return vsel;
475
476	vsel &= info->table_len - 1;
477	return vsel;
478}
479
480static struct regulator_ops twl4030ldo_ops = {
481	.list_voltage	= twl4030ldo_list_voltage,
482
483	.set_voltage_sel = twl4030ldo_set_voltage_sel,
484	.get_voltage_sel = twl4030ldo_get_voltage_sel,
485
486	.enable		= twl4030reg_enable,
487	.disable	= twl4030reg_disable,
488	.is_enabled	= twl4030reg_is_enabled,
489
490	.set_mode	= twl4030reg_set_mode,
491
492	.get_status	= twl4030reg_get_status,
493};
494
495static int
496twl4030smps_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
497			unsigned *selector)
498{
499	struct twlreg_info *info = rdev_get_drvdata(rdev);
500	int vsel = DIV_ROUND_UP(min_uV - 600000, 12500);
501
502	if (info->set_voltage) {
503		return info->set_voltage(info->data, min_uV);
504	} else {
505		twlreg_write(info, TWL_MODULE_PM_RECEIVER,
506			VREG_VOLTAGE_SMPS_4030, vsel);
507	}
508
509	return 0;
510}
511
512static int twl4030smps_get_voltage(struct regulator_dev *rdev)
513{
514	struct twlreg_info *info = rdev_get_drvdata(rdev);
515	int vsel;
516
517	if (info->get_voltage)
518		return info->get_voltage(info->data);
519
520	vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER,
521		VREG_VOLTAGE_SMPS_4030);
522
523	return vsel * 12500 + 600000;
524}
525
526static struct regulator_ops twl4030smps_ops = {
527	.set_voltage	= twl4030smps_set_voltage,
528	.get_voltage	= twl4030smps_get_voltage,
529};
530
531static int twl6030coresmps_set_voltage(struct regulator_dev *rdev, int min_uV,
532	int max_uV, unsigned *selector)
533{
534	struct twlreg_info *info = rdev_get_drvdata(rdev);
535
536	if (info->set_voltage)
537		return info->set_voltage(info->data, min_uV);
538
539	return -ENODEV;
540}
541
542static int twl6030coresmps_get_voltage(struct regulator_dev *rdev)
543{
544	struct twlreg_info *info = rdev_get_drvdata(rdev);
545
546	if (info->get_voltage)
547		return info->get_voltage(info->data);
548
549	return -ENODEV;
550}
551
552static struct regulator_ops twl6030coresmps_ops = {
553	.set_voltage	= twl6030coresmps_set_voltage,
554	.get_voltage	= twl6030coresmps_get_voltage,
555};
556
557static int twl6030ldo_list_voltage(struct regulator_dev *rdev, unsigned sel)
558{
559	struct twlreg_info *info = rdev_get_drvdata(rdev);
560
561	switch (sel) {
562	case 0:
563		return 0;
564	case 1 ... 24:
565		/* Linear mapping from 00000001 to 00011000:
566		 * Absolute voltage value = 1.0 V + 0.1 V × (sel – 00000001)
567		 */
568		return (info->min_mV + 100 * (sel - 1)) * 1000;
569	case 25 ... 30:
570		return -EINVAL;
571	case 31:
572		return 2750000;
573	default:
574		return -EINVAL;
575	}
576}
577
578static int
579twl6030ldo_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
580{
581	struct twlreg_info	*info = rdev_get_drvdata(rdev);
582
583	return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE,
584			    selector);
585}
586
587static int twl6030ldo_get_voltage_sel(struct regulator_dev *rdev)
588{
589	struct twlreg_info	*info = rdev_get_drvdata(rdev);
590	int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE);
591
592	return vsel;
593}
594
595static struct regulator_ops twl6030ldo_ops = {
596	.list_voltage	= twl6030ldo_list_voltage,
597
598	.set_voltage_sel = twl6030ldo_set_voltage_sel,
599	.get_voltage_sel = twl6030ldo_get_voltage_sel,
600
601	.enable		= twl6030reg_enable,
602	.disable	= twl6030reg_disable,
603	.is_enabled	= twl6030reg_is_enabled,
604
605	.set_mode	= twl6030reg_set_mode,
606
607	.get_status	= twl6030reg_get_status,
608};
609
610/*----------------------------------------------------------------------*/
611
612static struct regulator_ops twl4030fixed_ops = {
613	.list_voltage	= regulator_list_voltage_linear,
614
615	.enable		= twl4030reg_enable,
616	.disable	= twl4030reg_disable,
617	.is_enabled	= twl4030reg_is_enabled,
618
619	.set_mode	= twl4030reg_set_mode,
620
621	.get_status	= twl4030reg_get_status,
622};
623
624static struct regulator_ops twl6030fixed_ops = {
625	.list_voltage	= regulator_list_voltage_linear,
626
627	.enable		= twl6030reg_enable,
628	.disable	= twl6030reg_disable,
629	.is_enabled	= twl6030reg_is_enabled,
630
631	.set_mode	= twl6030reg_set_mode,
632
633	.get_status	= twl6030reg_get_status,
634};
635
636/*
637 * SMPS status and control
638 */
639
640static int twl6030smps_list_voltage(struct regulator_dev *rdev, unsigned index)
641{
642	struct twlreg_info	*info = rdev_get_drvdata(rdev);
643
644	int voltage = 0;
645
646	switch (info->flags) {
647	case SMPS_OFFSET_EN:
648		voltage = 100000;
649		/* fall through */
650	case 0:
651		switch (index) {
652		case 0:
653			voltage = 0;
654			break;
655		case 58:
656			voltage = 1350 * 1000;
657			break;
658		case 59:
659			voltage = 1500 * 1000;
660			break;
661		case 60:
662			voltage = 1800 * 1000;
663			break;
664		case 61:
665			voltage = 1900 * 1000;
666			break;
667		case 62:
668			voltage = 2100 * 1000;
669			break;
670		default:
671			voltage += (600000 + (12500 * (index - 1)));
672		}
673		break;
674	case SMPS_EXTENDED_EN:
675		switch (index) {
676		case 0:
677			voltage = 0;
678			break;
679		case 58:
680			voltage = 2084 * 1000;
681			break;
682		case 59:
683			voltage = 2315 * 1000;
684			break;
685		case 60:
686			voltage = 2778 * 1000;
687			break;
688		case 61:
689			voltage = 2932 * 1000;
690			break;
691		case 62:
692			voltage = 3241 * 1000;
693			break;
694		default:
695			voltage = (1852000 + (38600 * (index - 1)));
696		}
697		break;
698	case SMPS_OFFSET_EN | SMPS_EXTENDED_EN:
699		switch (index) {
700		case 0:
701			voltage = 0;
702			break;
703		case 58:
704			voltage = 4167 * 1000;
705			break;
706		case 59:
707			voltage = 2315 * 1000;
708			break;
709		case 60:
710			voltage = 2778 * 1000;
711			break;
712		case 61:
713			voltage = 2932 * 1000;
714			break;
715		case 62:
716			voltage = 3241 * 1000;
717			break;
718		default:
719			voltage = (2161000 + (38600 * (index - 1)));
720		}
721		break;
722	}
723
724	return voltage;
725}
726
727static int twl6030smps_map_voltage(struct regulator_dev *rdev, int min_uV,
728				   int max_uV)
729{
730	struct twlreg_info *info = rdev_get_drvdata(rdev);
731	int vsel = 0;
732
733	switch (info->flags) {
734	case 0:
735		if (min_uV == 0)
736			vsel = 0;
737		else if ((min_uV >= 600000) && (min_uV <= 1300000)) {
738			vsel = DIV_ROUND_UP(min_uV - 600000, 12500);
739			vsel++;
740		}
741		/* Values 1..57 for vsel are linear and can be calculated
742		 * values 58..62 are non linear.
743		 */
744		else if ((min_uV > 1900000) && (min_uV <= 2100000))
745			vsel = 62;
746		else if ((min_uV > 1800000) && (min_uV <= 1900000))
747			vsel = 61;
748		else if ((min_uV > 1500000) && (min_uV <= 1800000))
749			vsel = 60;
750		else if ((min_uV > 1350000) && (min_uV <= 1500000))
751			vsel = 59;
752		else if ((min_uV > 1300000) && (min_uV <= 1350000))
753			vsel = 58;
754		else
755			return -EINVAL;
756		break;
757	case SMPS_OFFSET_EN:
758		if (min_uV == 0)
759			vsel = 0;
760		else if ((min_uV >= 700000) && (min_uV <= 1420000)) {
761			vsel = DIV_ROUND_UP(min_uV - 700000, 12500);
762			vsel++;
763		}
764		/* Values 1..57 for vsel are linear and can be calculated
765		 * values 58..62 are non linear.
766		 */
767		else if ((min_uV > 1900000) && (min_uV <= 2100000))
768			vsel = 62;
769		else if ((min_uV > 1800000) && (min_uV <= 1900000))
770			vsel = 61;
771		else if ((min_uV > 1350000) && (min_uV <= 1800000))
772			vsel = 60;
773		else if ((min_uV > 1350000) && (min_uV <= 1500000))
774			vsel = 59;
775		else if ((min_uV > 1300000) && (min_uV <= 1350000))
776			vsel = 58;
777		else
778			return -EINVAL;
779		break;
780	case SMPS_EXTENDED_EN:
781		if (min_uV == 0) {
782			vsel = 0;
783		} else if ((min_uV >= 1852000) && (max_uV <= 4013600)) {
784			vsel = DIV_ROUND_UP(min_uV - 1852000, 38600);
785			vsel++;
786		}
787		break;
788	case SMPS_OFFSET_EN|SMPS_EXTENDED_EN:
789		if (min_uV == 0) {
790			vsel = 0;
791		} else if ((min_uV >= 2161000) && (min_uV <= 4321000)) {
792			vsel = DIV_ROUND_UP(min_uV - 2161000, 38600);
793			vsel++;
794		}
795		break;
796	}
797
798	return vsel;
799}
800
801static int twl6030smps_set_voltage_sel(struct regulator_dev *rdev,
802				       unsigned int selector)
803{
804	struct twlreg_info *info = rdev_get_drvdata(rdev);
805
806	return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS,
807			    selector);
808}
809
810static int twl6030smps_get_voltage_sel(struct regulator_dev *rdev)
811{
812	struct twlreg_info	*info = rdev_get_drvdata(rdev);
813
814	return twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS);
815}
816
817static struct regulator_ops twlsmps_ops = {
818	.list_voltage		= twl6030smps_list_voltage,
819	.map_voltage		= twl6030smps_map_voltage,
820
821	.set_voltage_sel	= twl6030smps_set_voltage_sel,
822	.get_voltage_sel	= twl6030smps_get_voltage_sel,
823
824	.enable			= twl6030reg_enable,
825	.disable		= twl6030reg_disable,
826	.is_enabled		= twl6030reg_is_enabled,
827
828	.set_mode		= twl6030reg_set_mode,
829
830	.get_status		= twl6030reg_get_status,
831};
832
833/*----------------------------------------------------------------------*/
834
835#define TWL4030_FIXED_LDO(label, offset, mVolts, num, turnon_delay, \
836			remap_conf) \
837		TWL_FIXED_LDO(label, offset, mVolts, num, turnon_delay, \
838			remap_conf, TWL4030, twl4030fixed_ops)
839#define TWL6030_FIXED_LDO(label, offset, mVolts, turnon_delay) \
840		TWL_FIXED_LDO(label, offset, mVolts, 0x0, turnon_delay, \
841			0x0, TWL6030, twl6030fixed_ops)
842
843#define TWL4030_ADJUSTABLE_LDO(label, offset, num, turnon_delay, remap_conf) \
844static const struct twlreg_info TWL4030_INFO_##label = { \
845	.base = offset, \
846	.id = num, \
847	.table_len = ARRAY_SIZE(label##_VSEL_table), \
848	.table = label##_VSEL_table, \
849	.remap = remap_conf, \
850	.desc = { \
851		.name = #label, \
852		.id = TWL4030_REG_##label, \
853		.n_voltages = ARRAY_SIZE(label##_VSEL_table), \
854		.ops = &twl4030ldo_ops, \
855		.type = REGULATOR_VOLTAGE, \
856		.owner = THIS_MODULE, \
857		.enable_time = turnon_delay, \
858		}, \
859	}
860
861#define TWL4030_ADJUSTABLE_SMPS(label, offset, num, turnon_delay, remap_conf) \
862static const struct twlreg_info TWL4030_INFO_##label = { \
863	.base = offset, \
864	.id = num, \
865	.remap = remap_conf, \
866	.desc = { \
867		.name = #label, \
868		.id = TWL4030_REG_##label, \
869		.ops = &twl4030smps_ops, \
870		.type = REGULATOR_VOLTAGE, \
871		.owner = THIS_MODULE, \
872		.enable_time = turnon_delay, \
873		}, \
874	}
875
876#define TWL6030_ADJUSTABLE_SMPS(label) \
877static const struct twlreg_info TWL6030_INFO_##label = { \
878	.desc = { \
879		.name = #label, \
880		.id = TWL6030_REG_##label, \
881		.ops = &twl6030coresmps_ops, \
882		.type = REGULATOR_VOLTAGE, \
883		.owner = THIS_MODULE, \
884		}, \
885	}
886
887#define TWL6030_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts) \
888static const struct twlreg_info TWL6030_INFO_##label = { \
889	.base = offset, \
890	.min_mV = min_mVolts, \
891	.max_mV = max_mVolts, \
892	.desc = { \
893		.name = #label, \
894		.id = TWL6030_REG_##label, \
895		.n_voltages = 32, \
896		.ops = &twl6030ldo_ops, \
897		.type = REGULATOR_VOLTAGE, \
898		.owner = THIS_MODULE, \
899		}, \
900	}
901
902#define TWL6032_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts) \
903static const struct twlreg_info TWL6032_INFO_##label = { \
904	.base = offset, \
905	.min_mV = min_mVolts, \
906	.max_mV = max_mVolts, \
907	.desc = { \
908		.name = #label, \
909		.id = TWL6032_REG_##label, \
910		.n_voltages = 32, \
911		.ops = &twl6030ldo_ops, \
912		.type = REGULATOR_VOLTAGE, \
913		.owner = THIS_MODULE, \
914		}, \
915	}
916
917#define TWL_FIXED_LDO(label, offset, mVolts, num, turnon_delay, remap_conf, \
918		family, operations) \
919static const struct twlreg_info TWLFIXED_INFO_##label = { \
920	.base = offset, \
921	.id = num, \
922	.min_mV = mVolts, \
923	.remap = remap_conf, \
924	.desc = { \
925		.name = #label, \
926		.id = family##_REG_##label, \
927		.n_voltages = 1, \
928		.ops = &operations, \
929		.type = REGULATOR_VOLTAGE, \
930		.owner = THIS_MODULE, \
931		.min_uV = mVolts * 1000, \
932		.enable_time = turnon_delay, \
933		}, \
934	}
935
936#define TWL6032_ADJUSTABLE_SMPS(label, offset) \
937static const struct twlreg_info TWLSMPS_INFO_##label = { \
938	.base = offset, \
939	.min_mV = 600, \
940	.max_mV = 2100, \
941	.desc = { \
942		.name = #label, \
943		.id = TWL6032_REG_##label, \
944		.n_voltages = 63, \
945		.ops = &twlsmps_ops, \
946		.type = REGULATOR_VOLTAGE, \
947		.owner = THIS_MODULE, \
948		}, \
949	}
950
951/*
952 * We list regulators here if systems need some level of
953 * software control over them after boot.
954 */
955TWL4030_ADJUSTABLE_LDO(VAUX1, 0x17, 1, 100, 0x08);
956TWL4030_ADJUSTABLE_LDO(VAUX2_4030, 0x1b, 2, 100, 0x08);
957TWL4030_ADJUSTABLE_LDO(VAUX2, 0x1b, 2, 100, 0x08);
958TWL4030_ADJUSTABLE_LDO(VAUX3, 0x1f, 3, 100, 0x08);
959TWL4030_ADJUSTABLE_LDO(VAUX4, 0x23, 4, 100, 0x08);
960TWL4030_ADJUSTABLE_LDO(VMMC1, 0x27, 5, 100, 0x08);
961TWL4030_ADJUSTABLE_LDO(VMMC2, 0x2b, 6, 100, 0x08);
962TWL4030_ADJUSTABLE_LDO(VPLL1, 0x2f, 7, 100, 0x00);
963TWL4030_ADJUSTABLE_LDO(VPLL2, 0x33, 8, 100, 0x08);
964TWL4030_ADJUSTABLE_LDO(VSIM, 0x37, 9, 100, 0x00);
965TWL4030_ADJUSTABLE_LDO(VDAC, 0x3b, 10, 100, 0x08);
966TWL4030_ADJUSTABLE_LDO(VINTANA2, 0x43, 12, 100, 0x08);
967TWL4030_ADJUSTABLE_LDO(VIO, 0x4b, 14, 1000, 0x08);
968TWL4030_ADJUSTABLE_SMPS(VDD1, 0x55, 15, 1000, 0x08);
969TWL4030_ADJUSTABLE_SMPS(VDD2, 0x63, 16, 1000, 0x08);
970/* VUSBCP is managed *only* by the USB subchip */
971/* 6030 REG with base as PMC Slave Misc : 0x0030 */
972/* Turnon-delay and remap configuration values for 6030 are not
973   verified since the specification is not public */
974TWL6030_ADJUSTABLE_SMPS(VDD1);
975TWL6030_ADJUSTABLE_SMPS(VDD2);
976TWL6030_ADJUSTABLE_SMPS(VDD3);
977TWL6030_ADJUSTABLE_LDO(VAUX1_6030, 0x54, 1000, 3300);
978TWL6030_ADJUSTABLE_LDO(VAUX2_6030, 0x58, 1000, 3300);
979TWL6030_ADJUSTABLE_LDO(VAUX3_6030, 0x5c, 1000, 3300);
980TWL6030_ADJUSTABLE_LDO(VMMC, 0x68, 1000, 3300);
981TWL6030_ADJUSTABLE_LDO(VPP, 0x6c, 1000, 3300);
982TWL6030_ADJUSTABLE_LDO(VUSIM, 0x74, 1000, 3300);
983/* 6025 are renamed compared to 6030 versions */
984TWL6032_ADJUSTABLE_LDO(LDO2, 0x54, 1000, 3300);
985TWL6032_ADJUSTABLE_LDO(LDO4, 0x58, 1000, 3300);
986TWL6032_ADJUSTABLE_LDO(LDO3, 0x5c, 1000, 3300);
987TWL6032_ADJUSTABLE_LDO(LDO5, 0x68, 1000, 3300);
988TWL6032_ADJUSTABLE_LDO(LDO1, 0x6c, 1000, 3300);
989TWL6032_ADJUSTABLE_LDO(LDO7, 0x74, 1000, 3300);
990TWL6032_ADJUSTABLE_LDO(LDO6, 0x60, 1000, 3300);
991TWL6032_ADJUSTABLE_LDO(LDOLN, 0x64, 1000, 3300);
992TWL6032_ADJUSTABLE_LDO(LDOUSB, 0x70, 1000, 3300);
993TWL4030_FIXED_LDO(VINTANA1, 0x3f, 1500, 11, 100, 0x08);
994TWL4030_FIXED_LDO(VINTDIG, 0x47, 1500, 13, 100, 0x08);
995TWL4030_FIXED_LDO(VUSB1V5, 0x71, 1500, 17, 100, 0x08);
996TWL4030_FIXED_LDO(VUSB1V8, 0x74, 1800, 18, 100, 0x08);
997TWL4030_FIXED_LDO(VUSB3V1, 0x77, 3100, 19, 150, 0x08);
998TWL6030_FIXED_LDO(VANA, 0x50, 2100, 0);
999TWL6030_FIXED_LDO(VCXIO, 0x60, 1800, 0);
1000TWL6030_FIXED_LDO(VDAC, 0x64, 1800, 0);
1001TWL6030_FIXED_LDO(VUSB, 0x70, 3300, 0);
1002TWL6030_FIXED_LDO(V1V8, 0x16, 1800, 0);
1003TWL6030_FIXED_LDO(V2V1, 0x1c, 2100, 0);
1004TWL6032_ADJUSTABLE_SMPS(SMPS3, 0x34);
1005TWL6032_ADJUSTABLE_SMPS(SMPS4, 0x10);
1006TWL6032_ADJUSTABLE_SMPS(VIO, 0x16);
1007
1008static u8 twl_get_smps_offset(void)
1009{
1010	u8 value;
1011
1012	twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &value,
1013			TWL6030_SMPS_OFFSET);
1014	return value;
1015}
1016
1017static u8 twl_get_smps_mult(void)
1018{
1019	u8 value;
1020
1021	twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &value,
1022			TWL6030_SMPS_MULT);
1023	return value;
1024}
1025
1026#define TWL_OF_MATCH(comp, family, label) \
1027	{ \
1028		.compatible = comp, \
1029		.data = &family##_INFO_##label, \
1030	}
1031
1032#define TWL4030_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL4030, label)
1033#define TWL6030_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6030, label)
1034#define TWL6032_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6032, label)
1035#define TWLFIXED_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLFIXED, label)
1036#define TWLSMPS_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLSMPS, label)
1037
1038static const struct of_device_id twl_of_match[] = {
1039	TWL4030_OF_MATCH("ti,twl4030-vaux1", VAUX1),
1040	TWL4030_OF_MATCH("ti,twl4030-vaux2", VAUX2_4030),
1041	TWL4030_OF_MATCH("ti,twl5030-vaux2", VAUX2),
1042	TWL4030_OF_MATCH("ti,twl4030-vaux3", VAUX3),
1043	TWL4030_OF_MATCH("ti,twl4030-vaux4", VAUX4),
1044	TWL4030_OF_MATCH("ti,twl4030-vmmc1", VMMC1),
1045	TWL4030_OF_MATCH("ti,twl4030-vmmc2", VMMC2),
1046	TWL4030_OF_MATCH("ti,twl4030-vpll1", VPLL1),
1047	TWL4030_OF_MATCH("ti,twl4030-vpll2", VPLL2),
1048	TWL4030_OF_MATCH("ti,twl4030-vsim", VSIM),
1049	TWL4030_OF_MATCH("ti,twl4030-vdac", VDAC),
1050	TWL4030_OF_MATCH("ti,twl4030-vintana2", VINTANA2),
1051	TWL4030_OF_MATCH("ti,twl4030-vio", VIO),
1052	TWL4030_OF_MATCH("ti,twl4030-vdd1", VDD1),
1053	TWL4030_OF_MATCH("ti,twl4030-vdd2", VDD2),
1054	TWL6030_OF_MATCH("ti,twl6030-vdd1", VDD1),
1055	TWL6030_OF_MATCH("ti,twl6030-vdd2", VDD2),
1056	TWL6030_OF_MATCH("ti,twl6030-vdd3", VDD3),
1057	TWL6030_OF_MATCH("ti,twl6030-vaux1", VAUX1_6030),
1058	TWL6030_OF_MATCH("ti,twl6030-vaux2", VAUX2_6030),
1059	TWL6030_OF_MATCH("ti,twl6030-vaux3", VAUX3_6030),
1060	TWL6030_OF_MATCH("ti,twl6030-vmmc", VMMC),
1061	TWL6030_OF_MATCH("ti,twl6030-vpp", VPP),
1062	TWL6030_OF_MATCH("ti,twl6030-vusim", VUSIM),
1063	TWL6032_OF_MATCH("ti,twl6032-ldo2", LDO2),
1064	TWL6032_OF_MATCH("ti,twl6032-ldo4", LDO4),
1065	TWL6032_OF_MATCH("ti,twl6032-ldo3", LDO3),
1066	TWL6032_OF_MATCH("ti,twl6032-ldo5", LDO5),
1067	TWL6032_OF_MATCH("ti,twl6032-ldo1", LDO1),
1068	TWL6032_OF_MATCH("ti,twl6032-ldo7", LDO7),
1069	TWL6032_OF_MATCH("ti,twl6032-ldo6", LDO6),
1070	TWL6032_OF_MATCH("ti,twl6032-ldoln", LDOLN),
1071	TWL6032_OF_MATCH("ti,twl6032-ldousb", LDOUSB),
1072	TWLFIXED_OF_MATCH("ti,twl4030-vintana1", VINTANA1),
1073	TWLFIXED_OF_MATCH("ti,twl4030-vintdig", VINTDIG),
1074	TWLFIXED_OF_MATCH("ti,twl4030-vusb1v5", VUSB1V5),
1075	TWLFIXED_OF_MATCH("ti,twl4030-vusb1v8", VUSB1V8),
1076	TWLFIXED_OF_MATCH("ti,twl4030-vusb3v1", VUSB3V1),
1077	TWLFIXED_OF_MATCH("ti,twl6030-vana", VANA),
1078	TWLFIXED_OF_MATCH("ti,twl6030-vcxio", VCXIO),
1079	TWLFIXED_OF_MATCH("ti,twl6030-vdac", VDAC),
1080	TWLFIXED_OF_MATCH("ti,twl6030-vusb", VUSB),
1081	TWLFIXED_OF_MATCH("ti,twl6030-v1v8", V1V8),
1082	TWLFIXED_OF_MATCH("ti,twl6030-v2v1", V2V1),
1083	TWLSMPS_OF_MATCH("ti,twl6032-smps3", SMPS3),
1084	TWLSMPS_OF_MATCH("ti,twl6032-smps4", SMPS4),
1085	TWLSMPS_OF_MATCH("ti,twl6032-vio", VIO),
1086	{},
1087};
1088MODULE_DEVICE_TABLE(of, twl_of_match);
1089
1090static int twlreg_probe(struct platform_device *pdev)
1091{
1092	int				i, id;
1093	struct twlreg_info		*info;
1094	const struct twlreg_info	*template;
1095	struct regulator_init_data	*initdata;
1096	struct regulation_constraints	*c;
1097	struct regulator_dev		*rdev;
1098	struct twl_regulator_driver_data	*drvdata;
1099	const struct of_device_id	*match;
1100	struct regulator_config		config = { };
1101
1102	match = of_match_device(twl_of_match, &pdev->dev);
1103	if (match) {
1104		template = match->data;
1105		id = template->desc.id;
1106		initdata = of_get_regulator_init_data(&pdev->dev,
1107						      pdev->dev.of_node,
1108						      &template->desc);
1109		drvdata = NULL;
1110	} else {
1111		id = pdev->id;
1112		initdata = dev_get_platdata(&pdev->dev);
1113		for (i = 0, template = NULL; i < ARRAY_SIZE(twl_of_match); i++) {
1114			template = twl_of_match[i].data;
1115			if (template && template->desc.id == id)
1116				break;
1117		}
1118		if (i == ARRAY_SIZE(twl_of_match))
1119			return -ENODEV;
1120
1121		drvdata = initdata->driver_data;
1122		if (!drvdata)
1123			return -EINVAL;
1124	}
1125
1126	if (!template)
1127		return -ENODEV;
1128
1129	if (!initdata)
1130		return -EINVAL;
1131
1132	info = devm_kmemdup(&pdev->dev, template, sizeof(*info), GFP_KERNEL);
1133	if (!info)
1134		return -ENOMEM;
1135
1136	if (drvdata) {
1137		/* copy the driver data into regulator data */
1138		info->features = drvdata->features;
1139		info->data = drvdata->data;
1140		info->set_voltage = drvdata->set_voltage;
1141		info->get_voltage = drvdata->get_voltage;
1142	}
1143
1144	/* Constrain board-specific capabilities according to what
1145	 * this driver and the chip itself can actually do.
1146	 */
1147	c = &initdata->constraints;
1148	c->valid_modes_mask &= REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY;
1149	c->valid_ops_mask &= REGULATOR_CHANGE_VOLTAGE
1150				| REGULATOR_CHANGE_MODE
1151				| REGULATOR_CHANGE_STATUS;
1152	switch (id) {
1153	case TWL4030_REG_VIO:
1154	case TWL4030_REG_VDD1:
1155	case TWL4030_REG_VDD2:
1156	case TWL4030_REG_VPLL1:
1157	case TWL4030_REG_VINTANA1:
1158	case TWL4030_REG_VINTANA2:
1159	case TWL4030_REG_VINTDIG:
1160		c->always_on = true;
1161		break;
1162	default:
1163		break;
1164	}
1165
1166	switch (id) {
1167	case TWL6032_REG_SMPS3:
1168		if (twl_get_smps_mult() & SMPS_MULTOFFSET_SMPS3)
1169			info->flags |= SMPS_EXTENDED_EN;
1170		if (twl_get_smps_offset() & SMPS_MULTOFFSET_SMPS3)
1171			info->flags |= SMPS_OFFSET_EN;
1172		break;
1173	case TWL6032_REG_SMPS4:
1174		if (twl_get_smps_mult() & SMPS_MULTOFFSET_SMPS4)
1175			info->flags |= SMPS_EXTENDED_EN;
1176		if (twl_get_smps_offset() & SMPS_MULTOFFSET_SMPS4)
1177			info->flags |= SMPS_OFFSET_EN;
1178		break;
1179	case TWL6032_REG_VIO:
1180		if (twl_get_smps_mult() & SMPS_MULTOFFSET_VIO)
1181			info->flags |= SMPS_EXTENDED_EN;
1182		if (twl_get_smps_offset() & SMPS_MULTOFFSET_VIO)
1183			info->flags |= SMPS_OFFSET_EN;
1184		break;
1185	}
1186
1187	config.dev = &pdev->dev;
1188	config.init_data = initdata;
1189	config.driver_data = info;
1190	config.of_node = pdev->dev.of_node;
1191
1192	rdev = devm_regulator_register(&pdev->dev, &info->desc, &config);
1193	if (IS_ERR(rdev)) {
1194		dev_err(&pdev->dev, "can't register %s, %ld\n",
1195				info->desc.name, PTR_ERR(rdev));
1196		return PTR_ERR(rdev);
1197	}
1198	platform_set_drvdata(pdev, rdev);
1199
1200	if (twl_class_is_4030())
1201		twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_REMAP,
1202						info->remap);
1203
1204	/* NOTE:  many regulators support short-circuit IRQs (presentable
1205	 * as REGULATOR_OVER_CURRENT notifications?) configured via:
1206	 *  - SC_CONFIG
1207	 *  - SC_DETECT1 (vintana2, vmmc1/2, vaux1/2/3/4)
1208	 *  - SC_DETECT2 (vusb, vdac, vio, vdd1/2, vpll2)
1209	 *  - IT_CONFIG
1210	 */
1211
1212	return 0;
1213}
1214
1215MODULE_ALIAS("platform:twl_reg");
1216
1217static struct platform_driver twlreg_driver = {
1218	.probe		= twlreg_probe,
1219	/* NOTE: short name, to work around driver model truncation of
1220	 * "twl_regulator.12" (and friends) to "twl_regulator.1".
1221	 */
1222	.driver  = {
1223		.name  = "twl_reg",
1224		.of_match_table = of_match_ptr(twl_of_match),
1225	},
1226};
1227
1228static int __init twlreg_init(void)
1229{
1230	return platform_driver_register(&twlreg_driver);
1231}
1232subsys_initcall(twlreg_init);
1233
1234static void __exit twlreg_exit(void)
1235{
1236	platform_driver_unregister(&twlreg_driver);
1237}
1238module_exit(twlreg_exit)
1239
1240MODULE_DESCRIPTION("TWL regulator driver");
1241MODULE_LICENSE("GPL");
1242