1 /*
2  * Copyright 2017 NXP
3  *
4  * Peng Fan <peng.fan@nxp.com>
5  *
6  * SPDX-License-Identifier:	GPL-2.0+
7  */
8 
9 #include <common.h>
10 #include <fdtdec.h>
11 #include <errno.h>
12 #include <dm.h>
13 #include <i2c.h>
14 #include <power/pmic.h>
15 #include <power/regulator.h>
16 #include <power/pfuze100_pmic.h>
17 
18 /**
19  * struct pfuze100_regulator_desc - regulator descriptor
20  *
21  * @name: Identify name for the regulator.
22  * @type: Indicates the regulator type.
23  * @uV_step: Voltage increase for each selector.
24  * @vsel_reg: Register for adjust regulator voltage for normal.
25  * @vsel_mask: Mask bit for setting regulator voltage for normal.
26  * @stby_reg: Register for adjust regulator voltage for standby.
27  * @stby_mask: Mask bit for setting regulator voltage for standby.
28  * @volt_table: Voltage mapping table (if table based mapping).
29  * @voltage: Current voltage for REGULATOR_TYPE_FIXED type regulator.
30  */
31 struct pfuze100_regulator_desc {
32 	char *name;
33 	enum regulator_type type;
34 	unsigned int uV_step;
35 	unsigned int vsel_reg;
36 	unsigned int vsel_mask;
37 	unsigned int stby_reg;
38 	unsigned int stby_mask;
39 	unsigned int *volt_table;
40 	unsigned int voltage;
41 };
42 
43 /**
44  * struct pfuze100_regulator_platdata - platform data for pfuze100
45  *
46  * @desc: Points the description entry of one regulator of pfuze100
47  */
48 struct pfuze100_regulator_platdata {
49 	struct pfuze100_regulator_desc *desc;
50 };
51 
52 #define PFUZE100_FIXED_REG(_name, base, vol)				\
53 	{								\
54 		.name		=	#_name,				\
55 		.type		=	REGULATOR_TYPE_FIXED,		\
56 		.voltage	=	(vol),				\
57 	}
58 
59 #define PFUZE100_SW_REG(_name, base, step)				\
60 	{								\
61 		.name		=	#_name,				\
62 		.type		=	REGULATOR_TYPE_BUCK,		\
63 		.uV_step	=	(step),				\
64 		.vsel_reg	=	(base) + PFUZE100_VOL_OFFSET,	\
65 		.vsel_mask	=	0x3F,				\
66 		.stby_reg	=	(base) + PFUZE100_STBY_OFFSET,	\
67 		.stby_mask	=	0x3F,				\
68 	}
69 
70 #define PFUZE100_SWB_REG(_name, base, mask, step, voltages)		\
71 	{								\
72 		.name		=	#_name,				\
73 		.type		=	REGULATOR_TYPE_BUCK,		\
74 		.uV_step	=	(step),				\
75 		.vsel_reg	=	(base),				\
76 		.vsel_mask	=	(mask),				\
77 		.volt_table	=	(voltages),			\
78 	}
79 
80 #define PFUZE100_SNVS_REG(_name, base, mask, voltages)			\
81 	{								\
82 		.name		=	#_name,				\
83 		.type		=	REGULATOR_TYPE_OTHER,		\
84 		.vsel_reg	=	(base),				\
85 		.vsel_mask	=	(mask),				\
86 		.volt_table	=	(voltages),			\
87 	}
88 
89 #define PFUZE100_VGEN_REG(_name, base, step)				\
90 	{								\
91 		.name		=	#_name,				\
92 		.type		=	REGULATOR_TYPE_LDO,		\
93 		.uV_step	=	(step),				\
94 		.vsel_reg	=	(base),				\
95 		.vsel_mask	=	0xF,				\
96 		.stby_reg	=	(base),				\
97 		.stby_mask	=	0x20,				\
98 	}
99 
100 #define PFUZE3000_VCC_REG(_name, base, step)				\
101 	{								\
102 		.name		=	#_name,				\
103 		.type		=	REGULATOR_TYPE_LDO,		\
104 		.uV_step	=	(step),				\
105 		.vsel_reg	=	(base),				\
106 		.vsel_mask	=	0x3,				\
107 		.stby_reg	=	(base),				\
108 		.stby_mask	=	0x20,				\
109 }
110 
111 #define PFUZE3000_SW1_REG(_name, base, step)				\
112 	{								\
113 		.name		=	#_name,				\
114 		.type		=	REGULATOR_TYPE_BUCK,		\
115 		.uV_step	=	(step),				\
116 		.vsel_reg	=	(base) + PFUZE100_VOL_OFFSET,	\
117 		.vsel_mask	=	0x1F,				\
118 		.stby_reg	=	(base) + PFUZE100_STBY_OFFSET,	\
119 		.stby_mask	=	0x1F,				\
120 	}
121 
122 #define PFUZE3000_SW2_REG(_name, base, step)				\
123 	{								\
124 		.name		=	#_name,				\
125 		.type		=	REGULATOR_TYPE_BUCK,		\
126 		.uV_step	=	(step),				\
127 		.vsel_reg	=	(base) + PFUZE100_VOL_OFFSET,	\
128 		.vsel_mask	=	0x7,				\
129 		.stby_reg	=	(base) + PFUZE100_STBY_OFFSET,	\
130 		.stby_mask	=	0x7,				\
131 	}
132 
133 #define PFUZE3000_SW3_REG(_name, base, step)				\
134 	{								\
135 		.name		=	#_name,				\
136 		.type		=	REGULATOR_TYPE_BUCK,		\
137 		.uV_step	=	(step),				\
138 		.vsel_reg	=	(base) + PFUZE100_VOL_OFFSET,	\
139 		.vsel_mask	=	0xF,				\
140 		.stby_reg	=	(base) + PFUZE100_STBY_OFFSET,	\
141 		.stby_mask	=	0xF,				\
142 	}
143 
144 static unsigned int pfuze100_swbst[] = {
145 	5000000, 5050000, 5100000, 5150000
146 };
147 
148 static unsigned int pfuze100_vsnvs[] = {
149 	1000000, 1100000, 1200000, 1300000, 1500000, 1800000, 3000000, -1
150 };
151 
152 static unsigned int pfuze3000_vsnvs[] = {
153 	-1, -1, -1, -1, -1, -1, 3000000, -1
154 };
155 
156 static unsigned int pfuze3000_sw2lo[] = {
157 	1500000, 1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000
158 };
159 
160 /* PFUZE100 */
161 static struct pfuze100_regulator_desc pfuze100_regulators[] = {
162 	PFUZE100_SW_REG(sw1ab, PFUZE100_SW1ABVOL, 25000),
163 	PFUZE100_SW_REG(sw1c, PFUZE100_SW1CVOL, 25000),
164 	PFUZE100_SW_REG(sw2, PFUZE100_SW2VOL, 25000),
165 	PFUZE100_SW_REG(sw3a, PFUZE100_SW3AVOL, 25000),
166 	PFUZE100_SW_REG(sw3b, PFUZE100_SW3BVOL, 25000),
167 	PFUZE100_SW_REG(sw4, PFUZE100_SW4VOL, 25000),
168 	PFUZE100_SWB_REG(swbst, PFUZE100_SWBSTCON1, 0x3, 50000, pfuze100_swbst),
169 	PFUZE100_SNVS_REG(vsnvs, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs),
170 	PFUZE100_FIXED_REG(vrefddr, PFUZE100_VREFDDRCON, 750000),
171 	PFUZE100_VGEN_REG(vgen1, PFUZE100_VGEN1VOL, 50000),
172 	PFUZE100_VGEN_REG(vgen2, PFUZE100_VGEN2VOL, 50000),
173 	PFUZE100_VGEN_REG(vgen3, PFUZE100_VGEN3VOL, 100000),
174 	PFUZE100_VGEN_REG(vgen4, PFUZE100_VGEN4VOL, 100000),
175 	PFUZE100_VGEN_REG(vgen5, PFUZE100_VGEN5VOL, 100000),
176 	PFUZE100_VGEN_REG(vgen6, PFUZE100_VGEN6VOL, 100000),
177 };
178 
179 /* PFUZE200 */
180 static struct pfuze100_regulator_desc pfuze200_regulators[] = {
181 	PFUZE100_SW_REG(sw1ab, PFUZE100_SW1ABVOL, 25000),
182 	PFUZE100_SW_REG(sw2, PFUZE100_SW2VOL, 25000),
183 	PFUZE100_SW_REG(sw3a, PFUZE100_SW3AVOL, 25000),
184 	PFUZE100_SW_REG(sw3b, PFUZE100_SW3BVOL, 25000),
185 	PFUZE100_SWB_REG(swbst, PFUZE100_SWBSTCON1, 0x3, 50000, pfuze100_swbst),
186 	PFUZE100_SNVS_REG(vsnvs, PFUZE100_VSNVSVOL, 0x7, pfuze100_vsnvs),
187 	PFUZE100_FIXED_REG(vrefddr, PFUZE100_VREFDDRCON, 750000),
188 	PFUZE100_VGEN_REG(vgen1, PFUZE100_VGEN1VOL, 50000),
189 	PFUZE100_VGEN_REG(vgen2, PFUZE100_VGEN2VOL, 50000),
190 	PFUZE100_VGEN_REG(vgen3, PFUZE100_VGEN3VOL, 100000),
191 	PFUZE100_VGEN_REG(vgen4, PFUZE100_VGEN4VOL, 100000),
192 	PFUZE100_VGEN_REG(vgen5, PFUZE100_VGEN5VOL, 100000),
193 	PFUZE100_VGEN_REG(vgen6, PFUZE100_VGEN6VOL, 100000),
194 };
195 
196 /* PFUZE3000 */
197 static struct pfuze100_regulator_desc pfuze3000_regulators[] = {
198 	PFUZE3000_SW1_REG(sw1a, PFUZE100_SW1ABVOL, 25000),
199 	PFUZE3000_SW1_REG(sw1b, PFUZE100_SW1CVOL, 25000),
200 	PFUZE100_SWB_REG(sw2, PFUZE100_SW2VOL, 0x7, 50000, pfuze3000_sw2lo),
201 	PFUZE3000_SW3_REG(sw3, PFUZE100_SW3AVOL, 50000),
202 	PFUZE100_SWB_REG(swbst, PFUZE100_SWBSTCON1, 0x3, 50000, pfuze100_swbst),
203 	PFUZE100_SNVS_REG(vsnvs, PFUZE100_VSNVSVOL, 0x7, pfuze3000_vsnvs),
204 	PFUZE100_FIXED_REG(vrefddr, PFUZE100_VREFDDRCON, 750000),
205 	PFUZE100_VGEN_REG(vldo1, PFUZE100_VGEN1VOL, 100000),
206 	PFUZE100_VGEN_REG(vldo2, PFUZE100_VGEN2VOL, 50000),
207 	PFUZE3000_VCC_REG(vccsd, PFUZE100_VGEN3VOL, 150000),
208 	PFUZE3000_VCC_REG(v33, PFUZE100_VGEN4VOL, 150000),
209 	PFUZE100_VGEN_REG(vldo3, PFUZE100_VGEN5VOL, 100000),
210 	PFUZE100_VGEN_REG(vldo4, PFUZE100_VGEN6VOL, 100000),
211 };
212 
213 #define MODE(_id, _val, _name) { \
214 	.id = _id, \
215 	.register_value = _val, \
216 	.name = _name, \
217 }
218 
219 /* SWx Buck regulator mode */
220 static struct dm_regulator_mode pfuze_sw_modes[] = {
221 	MODE(OFF_OFF, OFF_OFF, "OFF_OFF"),
222 	MODE(PWM_OFF, PWM_OFF, "PWM_OFF"),
223 	MODE(PFM_OFF, PFM_OFF, "PFM_OFF"),
224 	MODE(APS_OFF, APS_OFF, "APS_OFF"),
225 	MODE(PWM_PWM, PWM_PWM, "PWM_PWM"),
226 	MODE(PWM_APS, PWM_APS, "PWM_APS"),
227 	MODE(APS_APS, APS_APS, "APS_APS"),
228 	MODE(APS_PFM, APS_PFM, "APS_PFM"),
229 	MODE(PWM_PFM, PWM_PFM, "PWM_PFM"),
230 };
231 
232 /* Boost Buck regulator mode for normal operation */
233 static struct dm_regulator_mode pfuze_swbst_modes[] = {
234 	MODE(SWBST_MODE_OFF, SWBST_MODE_OFF , "SWBST_MODE_OFF"),
235 	MODE(SWBST_MODE_PFM, SWBST_MODE_PFM, "SWBST_MODE_PFM"),
236 	MODE(SWBST_MODE_AUTO, SWBST_MODE_AUTO, "SWBST_MODE_AUTO"),
237 	MODE(SWBST_MODE_APS, SWBST_MODE_APS, "SWBST_MODE_APS"),
238 };
239 
240 /* VGENx LDO regulator mode for normal operation */
241 static struct dm_regulator_mode pfuze_ldo_modes[] = {
242 	MODE(LDO_MODE_OFF, LDO_MODE_OFF, "LDO_MODE_OFF"),
243 	MODE(LDO_MODE_ON, LDO_MODE_ON, "LDO_MODE_ON"),
244 };
245 
246 static struct pfuze100_regulator_desc *se_desc(struct pfuze100_regulator_desc *desc,
247 					       int size,
248 					       const char *name)
249 {
250 	int i;
251 
252 	for (i = 0; i < size; desc++) {
253 		if (!strcmp(desc->name, name))
254 			return desc;
255 		continue;
256 	}
257 
258 	return NULL;
259 }
260 
261 static int pfuze100_regulator_probe(struct udevice *dev)
262 {
263 	struct dm_regulator_uclass_platdata *uc_pdata;
264 	struct pfuze100_regulator_platdata *plat = dev_get_platdata(dev);
265 	struct pfuze100_regulator_desc *desc;
266 
267 	switch (dev_get_driver_data(dev_get_parent(dev))) {
268 	case PFUZE100:
269 		desc = se_desc(pfuze100_regulators,
270 			       ARRAY_SIZE(pfuze100_regulators),
271 			       dev->name);
272 		break;
273 	case PFUZE200:
274 		desc = se_desc(pfuze200_regulators,
275 			       ARRAY_SIZE(pfuze200_regulators),
276 			       dev->name);
277 		break;
278 	case PFUZE3000:
279 		desc = se_desc(pfuze3000_regulators,
280 			       ARRAY_SIZE(pfuze3000_regulators),
281 			       dev->name);
282 		break;
283 	default:
284 		debug("Unsupported PFUZE\n");
285 		return -EINVAL;
286 	}
287 	if (!desc) {
288 		debug("Do not support regulator %s\n", dev->name);
289 		return -EINVAL;
290 	}
291 
292 	plat->desc = desc;
293 	uc_pdata = dev_get_uclass_platdata(dev);
294 
295 	uc_pdata->type = desc->type;
296 	if (uc_pdata->type == REGULATOR_TYPE_BUCK) {
297 		if (!strcmp(dev->name, "swbst")) {
298 			uc_pdata->mode = pfuze_swbst_modes;
299 			uc_pdata->mode_count = ARRAY_SIZE(pfuze_swbst_modes);
300 		} else {
301 			uc_pdata->mode = pfuze_sw_modes;
302 			uc_pdata->mode_count = ARRAY_SIZE(pfuze_sw_modes);
303 		}
304 	} else if (uc_pdata->type == REGULATOR_TYPE_LDO) {
305 		uc_pdata->mode = pfuze_ldo_modes;
306 		uc_pdata->mode_count = ARRAY_SIZE(pfuze_ldo_modes);
307 	} else {
308 		uc_pdata->mode = NULL;
309 		uc_pdata->mode_count = 0;
310 	}
311 
312 	return 0;
313 }
314 
315 static int pfuze100_regulator_mode(struct udevice *dev, int op, int *opmode)
316 {
317 	int val;
318 	struct pfuze100_regulator_platdata *plat = dev_get_platdata(dev);
319 	struct pfuze100_regulator_desc *desc = plat->desc;
320 
321 	if (op == PMIC_OP_GET) {
322 		if (desc->type == REGULATOR_TYPE_BUCK) {
323 			if (!strcmp(dev->name, "swbst")) {
324 				val = pmic_reg_read(dev->parent,
325 						    desc->vsel_reg);
326 				if (val < 0)
327 					return val;
328 
329 				val &= SWBST_MODE_MASK;
330 				val >>= SWBST_MODE_SHIFT;
331 				*opmode = val;
332 
333 				return 0;
334 			}
335 			val = pmic_reg_read(dev->parent,
336 					    desc->vsel_reg +
337 					    PFUZE100_MODE_OFFSET);
338 			if (val < 0)
339 				return val;
340 
341 			val &= SW_MODE_MASK;
342 			val >>= SW_MODE_SHIFT;
343 			*opmode = val;
344 
345 			return 0;
346 
347 		} else if (desc->type == REGULATOR_TYPE_LDO) {
348 			val = pmic_reg_read(dev->parent, desc->vsel_reg);
349 			if (val < 0)
350 				return val;
351 
352 			val &= LDO_MODE_MASK;
353 			val >>= LDO_MODE_SHIFT;
354 			*opmode = val;
355 
356 			return 0;
357 		} else {
358 			return -EINVAL;
359 		}
360 	}
361 
362 	if (desc->type == REGULATOR_TYPE_BUCK) {
363 		if (!strcmp(dev->name, "swbst"))
364 			return pmic_clrsetbits(dev->parent, desc->vsel_reg,
365 					       SWBST_MODE_MASK,
366 					       *opmode << SWBST_MODE_SHIFT);
367 
368 		val = pmic_clrsetbits(dev->parent,
369 				       desc->vsel_reg + PFUZE100_MODE_OFFSET,
370 				       SW_MODE_MASK,
371 				       *opmode << SW_MODE_SHIFT);
372 
373 	} else if (desc->type == REGULATOR_TYPE_LDO) {
374 		val = pmic_clrsetbits(dev->parent, desc->vsel_reg,
375 				       LDO_MODE_MASK,
376 				       *opmode << LDO_MODE_SHIFT);
377 		return val;
378 	} else {
379 		return -EINVAL;
380 	}
381 
382 	return 0;
383 }
384 
385 static int pfuze100_regulator_enable(struct udevice *dev, int op, bool *enable)
386 {
387 	int val;
388 	int ret, on_off;
389 	struct dm_regulator_uclass_platdata *uc_pdata =
390 		dev_get_uclass_platdata(dev);
391 
392 	if (op == PMIC_OP_GET) {
393 		if (!strcmp(dev->name, "vrefddr")) {
394 			val = pmic_reg_read(dev->parent, PFUZE100_VREFDDRCON);
395 			if (val < 0)
396 				return val;
397 
398 			if (val & VREFDDRCON_EN)
399 				*enable = true;
400 			else
401 				*enable = false;
402 			return 0;
403 		}
404 		ret = pfuze100_regulator_mode(dev, op, &on_off);
405 		if (ret)
406 			return ret;
407 		switch (on_off) {
408 		/* OFF_OFF, SWBST_MODE_OFF, LDO_MODE_OFF have same value */
409 		case OFF_OFF:
410 			*enable = false;
411 			break;
412 		default:
413 			*enable = true;
414 			break;
415 		}
416 	} else if (op == PMIC_OP_SET) {
417 		if (!strcmp(dev->name, "vrefddr")) {
418 			val = pmic_reg_read(dev->parent, PFUZE100_VREFDDRCON);
419 			if (val < 0)
420 				return val;
421 
422 			if (val & VREFDDRCON_EN)
423 				return 0;
424 			val |= VREFDDRCON_EN;
425 
426 			return pmic_reg_write(dev->parent, PFUZE100_VREFDDRCON,
427 					      val);
428 		}
429 
430 		if (uc_pdata->type == REGULATOR_TYPE_LDO) {
431 			on_off = *enable ? LDO_MODE_ON : LDO_MODE_OFF;
432 		} else if (uc_pdata->type == REGULATOR_TYPE_BUCK) {
433 			if (!strcmp(dev->name, "swbst"))
434 				on_off = *enable ? SWBST_MODE_AUTO :
435 					SWBST_MODE_OFF;
436 			else
437 				on_off = *enable ? APS_PFM : OFF_OFF;
438 		} else {
439 			return -EINVAL;
440 		}
441 
442 		return pfuze100_regulator_mode(dev, op, &on_off);
443 	}
444 
445 	return 0;
446 }
447 
448 static int pfuze100_regulator_val(struct udevice *dev, int op, int *uV)
449 {
450 	int i;
451 	int val;
452 	struct pfuze100_regulator_platdata *plat = dev_get_platdata(dev);
453 	struct pfuze100_regulator_desc *desc = plat->desc;
454 	struct dm_regulator_uclass_platdata *uc_pdata =
455 		dev_get_uclass_platdata(dev);
456 
457 	if (op == PMIC_OP_GET) {
458 		*uV = 0;
459 		if (uc_pdata->type == REGULATOR_TYPE_FIXED) {
460 			*uV = desc->voltage;
461 		} else if (desc->volt_table) {
462 			val = pmic_reg_read(dev->parent, desc->vsel_reg);
463 			if (val < 0)
464 				return val;
465 			val &= desc->vsel_mask;
466 			*uV = desc->volt_table[val];
467 		} else {
468 			if (uc_pdata->min_uV < 0) {
469 				debug("Need to provide min_uV in dts.\n");
470 				return -EINVAL;
471 			}
472 			val = pmic_reg_read(dev->parent, desc->vsel_reg);
473 			if (val < 0)
474 				return val;
475 			val &= desc->vsel_mask;
476 			*uV = uc_pdata->min_uV + (int)val * desc->uV_step;
477 		}
478 
479 		return 0;
480 	}
481 
482 	if (uc_pdata->type == REGULATOR_TYPE_FIXED) {
483 		debug("Set voltage for REGULATOR_TYPE_FIXED regulator\n");
484 		return -EINVAL;
485 	} else if (desc->volt_table) {
486 		for (i = 0; i < desc->vsel_mask; i++) {
487 			if (*uV == desc->volt_table[i])
488 				break;
489 		}
490 		if (i == desc->vsel_mask) {
491 			debug("Unsupported voltage %u\n", *uV);
492 			return -EINVAL;
493 		}
494 
495 		return pmic_clrsetbits(dev->parent, desc->vsel_reg,
496 				       desc->vsel_mask, i);
497 	} else {
498 		if (uc_pdata->min_uV < 0) {
499 			debug("Need to provide min_uV in dts.\n");
500 			return -EINVAL;
501 		}
502 		return pmic_clrsetbits(dev->parent, desc->vsel_reg,
503 				       desc->vsel_mask,
504 				       (*uV - uc_pdata->min_uV) / desc->uV_step);
505 	}
506 
507 	return 0;
508 }
509 
510 static int pfuze100_regulator_get_value(struct udevice *dev)
511 {
512 	int uV;
513 	int ret;
514 
515 	ret = pfuze100_regulator_val(dev, PMIC_OP_GET, &uV);
516 	if (ret)
517 		return ret;
518 
519 	return uV;
520 }
521 
522 static int pfuze100_regulator_set_value(struct udevice *dev, int uV)
523 {
524 	return pfuze100_regulator_val(dev, PMIC_OP_SET, &uV);
525 }
526 
527 static bool pfuze100_regulator_get_enable(struct udevice *dev)
528 {
529 	int ret;
530 	bool enable = false;
531 
532 	ret = pfuze100_regulator_enable(dev, PMIC_OP_GET, &enable);
533 	if (ret)
534 		return ret;
535 
536 	return enable;
537 }
538 
539 static int pfuze100_regulator_set_enable(struct udevice *dev, bool enable)
540 {
541 	return pfuze100_regulator_enable(dev, PMIC_OP_SET, &enable);
542 }
543 
544 static int pfuze100_regulator_get_mode(struct udevice *dev)
545 {
546 	int mode;
547 	int ret;
548 
549 	ret = pfuze100_regulator_mode(dev, PMIC_OP_GET, &mode);
550 	if (ret)
551 		return ret;
552 
553 	return mode;
554 }
555 
556 static int pfuze100_regulator_set_mode(struct udevice *dev, int mode)
557 {
558 	return pfuze100_regulator_mode(dev, PMIC_OP_SET, &mode);
559 }
560 
561 static const struct dm_regulator_ops pfuze100_regulator_ops = {
562 	.get_value  = pfuze100_regulator_get_value,
563 	.set_value  = pfuze100_regulator_set_value,
564 	.get_enable = pfuze100_regulator_get_enable,
565 	.set_enable = pfuze100_regulator_set_enable,
566 	.get_mode   = pfuze100_regulator_get_mode,
567 	.set_mode   = pfuze100_regulator_set_mode,
568 };
569 
570 U_BOOT_DRIVER(pfuze100_regulator) = {
571 	.name = "pfuze100_regulator",
572 	.id = UCLASS_REGULATOR,
573 	.ops = &pfuze100_regulator_ops,
574 	.probe = pfuze100_regulator_probe,
575 	.platdata_auto_alloc_size = sizeof(struct pfuze100_regulator_platdata),
576 };
577