1 /*
2  * Copyright (c) 2014, Sony Mobile Communications AB.
3  * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 and
7  * only version 2 as published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  */
14 
15 #include <linux/module.h>
16 #include <linux/platform_device.h>
17 #include <linux/of.h>
18 #include <linux/of_device.h>
19 #include <linux/regulator/driver.h>
20 #include <linux/regulator/machine.h>
21 #include <linux/regulator/of_regulator.h>
22 #include <linux/mfd/qcom_rpm.h>
23 
24 #include <dt-bindings/mfd/qcom-rpm.h>
25 
26 #define MAX_REQUEST_LEN 2
27 
28 struct request_member {
29 	int		word;
30 	unsigned int	mask;
31 	int		shift;
32 };
33 
34 struct rpm_reg_parts {
35 	struct request_member mV;		/* used if voltage is in mV */
36 	struct request_member uV;		/* used if voltage is in uV */
37 	struct request_member ip;		/* peak current in mA */
38 	struct request_member pd;		/* pull down enable */
39 	struct request_member ia;		/* average current in mA */
40 	struct request_member fm;		/* force mode */
41 	struct request_member pm;		/* power mode */
42 	struct request_member pc;		/* pin control */
43 	struct request_member pf;		/* pin function */
44 	struct request_member enable_state;	/* NCP and switch */
45 	struct request_member comp_mode;	/* NCP */
46 	struct request_member freq;		/* frequency: NCP and SMPS */
47 	struct request_member freq_clk_src;	/* clock source: SMPS */
48 	struct request_member hpm;		/* switch: control OCP and SS */
49 	int request_len;
50 };
51 
52 #define FORCE_MODE_IS_2_BITS(reg) \
53 	(((reg)->parts->fm.mask >> (reg)->parts->fm.shift) == 3)
54 
55 struct qcom_rpm_reg {
56 	struct qcom_rpm *rpm;
57 
58 	struct mutex lock;
59 	struct device *dev;
60 	struct regulator_desc desc;
61 	const struct rpm_reg_parts *parts;
62 
63 	int resource;
64 	u32 val[MAX_REQUEST_LEN];
65 
66 	int uV;
67 	int is_enabled;
68 
69 	bool supports_force_mode_auto;
70 	bool supports_force_mode_bypass;
71 };
72 
73 static const struct rpm_reg_parts rpm8660_ldo_parts = {
74 	.request_len    = 2,
75 	.mV             = { 0, 0x00000FFF,  0 },
76 	.ip             = { 0, 0x00FFF000, 12 },
77 	.fm             = { 0, 0x03000000, 24 },
78 	.pc             = { 0, 0x3C000000, 26 },
79 	.pf             = { 0, 0xC0000000, 30 },
80 	.pd             = { 1, 0x00000001,  0 },
81 	.ia             = { 1, 0x00001FFE,  1 },
82 };
83 
84 static const struct rpm_reg_parts rpm8660_smps_parts = {
85 	.request_len    = 2,
86 	.mV             = { 0, 0x00000FFF,  0 },
87 	.ip             = { 0, 0x00FFF000, 12 },
88 	.fm             = { 0, 0x03000000, 24 },
89 	.pc             = { 0, 0x3C000000, 26 },
90 	.pf             = { 0, 0xC0000000, 30 },
91 	.pd             = { 1, 0x00000001,  0 },
92 	.ia             = { 1, 0x00001FFE,  1 },
93 	.freq           = { 1, 0x001FE000, 13 },
94 	.freq_clk_src   = { 1, 0x00600000, 21 },
95 };
96 
97 static const struct rpm_reg_parts rpm8660_switch_parts = {
98 	.request_len    = 1,
99 	.enable_state   = { 0, 0x00000001,  0 },
100 	.pd             = { 0, 0x00000002,  1 },
101 	.pc             = { 0, 0x0000003C,  2 },
102 	.pf             = { 0, 0x000000C0,  6 },
103 	.hpm            = { 0, 0x00000300,  8 },
104 };
105 
106 static const struct rpm_reg_parts rpm8660_ncp_parts = {
107 	.request_len    = 1,
108 	.mV             = { 0, 0x00000FFF,  0 },
109 	.enable_state   = { 0, 0x00001000, 12 },
110 	.comp_mode      = { 0, 0x00002000, 13 },
111 	.freq           = { 0, 0x003FC000, 14 },
112 };
113 
114 static const struct rpm_reg_parts rpm8960_ldo_parts = {
115 	.request_len    = 2,
116 	.uV             = { 0, 0x007FFFFF,  0 },
117 	.pd             = { 0, 0x00800000, 23 },
118 	.pc             = { 0, 0x0F000000, 24 },
119 	.pf             = { 0, 0xF0000000, 28 },
120 	.ip             = { 1, 0x000003FF,  0 },
121 	.ia             = { 1, 0x000FFC00, 10 },
122 	.fm             = { 1, 0x00700000, 20 },
123 };
124 
125 static const struct rpm_reg_parts rpm8960_smps_parts = {
126 	.request_len    = 2,
127 	.uV             = { 0, 0x007FFFFF,  0 },
128 	.pd             = { 0, 0x00800000, 23 },
129 	.pc             = { 0, 0x0F000000, 24 },
130 	.pf             = { 0, 0xF0000000, 28 },
131 	.ip             = { 1, 0x000003FF,  0 },
132 	.ia             = { 1, 0x000FFC00, 10 },
133 	.fm             = { 1, 0x00700000, 20 },
134 	.pm             = { 1, 0x00800000, 23 },
135 	.freq           = { 1, 0x1F000000, 24 },
136 	.freq_clk_src   = { 1, 0x60000000, 29 },
137 };
138 
139 static const struct rpm_reg_parts rpm8960_switch_parts = {
140 	.request_len    = 1,
141 	.enable_state   = { 0, 0x00000001,  0 },
142 	.pd             = { 0, 0x00000002,  1 },
143 	.pc             = { 0, 0x0000003C,  2 },
144 	.pf             = { 0, 0x000003C0,  6 },
145 	.hpm            = { 0, 0x00000C00, 10 },
146 };
147 
148 static const struct rpm_reg_parts rpm8960_ncp_parts = {
149 	.request_len    = 1,
150 	.uV             = { 0, 0x007FFFFF,  0 },
151 	.enable_state   = { 0, 0x00800000, 23 },
152 	.comp_mode      = { 0, 0x01000000, 24 },
153 	.freq           = { 0, 0x3E000000, 25 },
154 };
155 
156 /*
157  * Physically available PMIC regulator voltage ranges
158  */
159 static const struct regulator_linear_range pldo_ranges[] = {
160 	REGULATOR_LINEAR_RANGE( 750000,   0,  59, 12500),
161 	REGULATOR_LINEAR_RANGE(1500000,  60, 123, 25000),
162 	REGULATOR_LINEAR_RANGE(3100000, 124, 160, 50000),
163 };
164 
165 static const struct regulator_linear_range nldo_ranges[] = {
166 	REGULATOR_LINEAR_RANGE( 750000,   0,  63, 12500),
167 };
168 
169 static const struct regulator_linear_range nldo1200_ranges[] = {
170 	REGULATOR_LINEAR_RANGE( 375000,   0,  59,  6250),
171 	REGULATOR_LINEAR_RANGE( 750000,  60, 123, 12500),
172 };
173 
174 static const struct regulator_linear_range smps_ranges[] = {
175 	REGULATOR_LINEAR_RANGE( 375000,   0,  29, 12500),
176 	REGULATOR_LINEAR_RANGE( 750000,  30,  89, 12500),
177 	REGULATOR_LINEAR_RANGE(1500000,  90, 153, 25000),
178 };
179 
180 static const struct regulator_linear_range ftsmps_ranges[] = {
181 	REGULATOR_LINEAR_RANGE( 350000,   0,   6, 50000),
182 	REGULATOR_LINEAR_RANGE( 700000,   7,  63, 12500),
183 	REGULATOR_LINEAR_RANGE(1500000,  64, 100, 50000),
184 };
185 
186 static const struct regulator_linear_range smb208_ranges[] = {
187 	REGULATOR_LINEAR_RANGE( 375000,   0,  29, 12500),
188 	REGULATOR_LINEAR_RANGE( 750000,  30,  89, 12500),
189 	REGULATOR_LINEAR_RANGE(1500000,  90, 153, 25000),
190 	REGULATOR_LINEAR_RANGE(3100000, 154, 234, 25000),
191 };
192 
193 static const struct regulator_linear_range ncp_ranges[] = {
194 	REGULATOR_LINEAR_RANGE(1500000,   0,  31, 50000),
195 };
196 
197 static int rpm_reg_write(struct qcom_rpm_reg *vreg,
198 			 const struct request_member *req,
199 			 const int value)
200 {
201 	if (WARN_ON((value << req->shift) & ~req->mask))
202 		return -EINVAL;
203 
204 	vreg->val[req->word] &= ~req->mask;
205 	vreg->val[req->word] |= value << req->shift;
206 
207 	return qcom_rpm_write(vreg->rpm,
208 			      QCOM_RPM_ACTIVE_STATE,
209 			      vreg->resource,
210 			      vreg->val,
211 			      vreg->parts->request_len);
212 }
213 
214 static int rpm_reg_set_mV_sel(struct regulator_dev *rdev,
215 			      unsigned selector)
216 {
217 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
218 	const struct rpm_reg_parts *parts = vreg->parts;
219 	const struct request_member *req = &parts->mV;
220 	int ret = 0;
221 	int uV;
222 
223 	if (req->mask == 0)
224 		return -EINVAL;
225 
226 	uV = regulator_list_voltage_linear_range(rdev, selector);
227 	if (uV < 0)
228 		return uV;
229 
230 	mutex_lock(&vreg->lock);
231 	if (vreg->is_enabled)
232 		ret = rpm_reg_write(vreg, req, uV / 1000);
233 
234 	if (!ret)
235 		vreg->uV = uV;
236 	mutex_unlock(&vreg->lock);
237 
238 	return ret;
239 }
240 
241 static int rpm_reg_set_uV_sel(struct regulator_dev *rdev,
242 			      unsigned selector)
243 {
244 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
245 	const struct rpm_reg_parts *parts = vreg->parts;
246 	const struct request_member *req = &parts->uV;
247 	int ret = 0;
248 	int uV;
249 
250 	if (req->mask == 0)
251 		return -EINVAL;
252 
253 	uV = regulator_list_voltage_linear_range(rdev, selector);
254 	if (uV < 0)
255 		return uV;
256 
257 	mutex_lock(&vreg->lock);
258 	if (vreg->is_enabled)
259 		ret = rpm_reg_write(vreg, req, uV);
260 
261 	if (!ret)
262 		vreg->uV = uV;
263 	mutex_unlock(&vreg->lock);
264 
265 	return ret;
266 }
267 
268 static int rpm_reg_get_voltage(struct regulator_dev *rdev)
269 {
270 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
271 
272 	return vreg->uV;
273 }
274 
275 static int rpm_reg_mV_enable(struct regulator_dev *rdev)
276 {
277 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
278 	const struct rpm_reg_parts *parts = vreg->parts;
279 	const struct request_member *req = &parts->mV;
280 	int ret;
281 
282 	if (req->mask == 0)
283 		return -EINVAL;
284 
285 	mutex_lock(&vreg->lock);
286 	ret = rpm_reg_write(vreg, req, vreg->uV / 1000);
287 	if (!ret)
288 		vreg->is_enabled = 1;
289 	mutex_unlock(&vreg->lock);
290 
291 	return ret;
292 }
293 
294 static int rpm_reg_uV_enable(struct regulator_dev *rdev)
295 {
296 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
297 	const struct rpm_reg_parts *parts = vreg->parts;
298 	const struct request_member *req = &parts->uV;
299 	int ret;
300 
301 	if (req->mask == 0)
302 		return -EINVAL;
303 
304 	mutex_lock(&vreg->lock);
305 	ret = rpm_reg_write(vreg, req, vreg->uV);
306 	if (!ret)
307 		vreg->is_enabled = 1;
308 	mutex_unlock(&vreg->lock);
309 
310 	return ret;
311 }
312 
313 static int rpm_reg_switch_enable(struct regulator_dev *rdev)
314 {
315 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
316 	const struct rpm_reg_parts *parts = vreg->parts;
317 	const struct request_member *req = &parts->enable_state;
318 	int ret;
319 
320 	if (req->mask == 0)
321 		return -EINVAL;
322 
323 	mutex_lock(&vreg->lock);
324 	ret = rpm_reg_write(vreg, req, 1);
325 	if (!ret)
326 		vreg->is_enabled = 1;
327 	mutex_unlock(&vreg->lock);
328 
329 	return ret;
330 }
331 
332 static int rpm_reg_mV_disable(struct regulator_dev *rdev)
333 {
334 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
335 	const struct rpm_reg_parts *parts = vreg->parts;
336 	const struct request_member *req = &parts->mV;
337 	int ret;
338 
339 	if (req->mask == 0)
340 		return -EINVAL;
341 
342 	mutex_lock(&vreg->lock);
343 	ret = rpm_reg_write(vreg, req, 0);
344 	if (!ret)
345 		vreg->is_enabled = 0;
346 	mutex_unlock(&vreg->lock);
347 
348 	return ret;
349 }
350 
351 static int rpm_reg_uV_disable(struct regulator_dev *rdev)
352 {
353 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
354 	const struct rpm_reg_parts *parts = vreg->parts;
355 	const struct request_member *req = &parts->uV;
356 	int ret;
357 
358 	if (req->mask == 0)
359 		return -EINVAL;
360 
361 	mutex_lock(&vreg->lock);
362 	ret = rpm_reg_write(vreg, req, 0);
363 	if (!ret)
364 		vreg->is_enabled = 0;
365 	mutex_unlock(&vreg->lock);
366 
367 	return ret;
368 }
369 
370 static int rpm_reg_switch_disable(struct regulator_dev *rdev)
371 {
372 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
373 	const struct rpm_reg_parts *parts = vreg->parts;
374 	const struct request_member *req = &parts->enable_state;
375 	int ret;
376 
377 	if (req->mask == 0)
378 		return -EINVAL;
379 
380 	mutex_lock(&vreg->lock);
381 	ret = rpm_reg_write(vreg, req, 0);
382 	if (!ret)
383 		vreg->is_enabled = 0;
384 	mutex_unlock(&vreg->lock);
385 
386 	return ret;
387 }
388 
389 static int rpm_reg_is_enabled(struct regulator_dev *rdev)
390 {
391 	struct qcom_rpm_reg *vreg = rdev_get_drvdata(rdev);
392 
393 	return vreg->is_enabled;
394 }
395 
396 static struct regulator_ops uV_ops = {
397 	.list_voltage = regulator_list_voltage_linear_range,
398 
399 	.set_voltage_sel = rpm_reg_set_uV_sel,
400 	.get_voltage = rpm_reg_get_voltage,
401 
402 	.enable = rpm_reg_uV_enable,
403 	.disable = rpm_reg_uV_disable,
404 	.is_enabled = rpm_reg_is_enabled,
405 };
406 
407 static struct regulator_ops mV_ops = {
408 	.list_voltage = regulator_list_voltage_linear_range,
409 
410 	.set_voltage_sel = rpm_reg_set_mV_sel,
411 	.get_voltage = rpm_reg_get_voltage,
412 
413 	.enable = rpm_reg_mV_enable,
414 	.disable = rpm_reg_mV_disable,
415 	.is_enabled = rpm_reg_is_enabled,
416 };
417 
418 static struct regulator_ops switch_ops = {
419 	.enable = rpm_reg_switch_enable,
420 	.disable = rpm_reg_switch_disable,
421 	.is_enabled = rpm_reg_is_enabled,
422 };
423 
424 /*
425  * PM8058 regulators
426  */
427 static const struct qcom_rpm_reg pm8058_pldo = {
428 	.desc.linear_ranges = pldo_ranges,
429 	.desc.n_linear_ranges = ARRAY_SIZE(pldo_ranges),
430 	.desc.n_voltages = 161,
431 	.desc.ops = &mV_ops,
432 	.parts = &rpm8660_ldo_parts,
433 	.supports_force_mode_auto = false,
434 	.supports_force_mode_bypass = false,
435 };
436 
437 static const struct qcom_rpm_reg pm8058_nldo = {
438 	.desc.linear_ranges = nldo_ranges,
439 	.desc.n_linear_ranges = ARRAY_SIZE(nldo_ranges),
440 	.desc.n_voltages = 64,
441 	.desc.ops = &mV_ops,
442 	.parts = &rpm8660_ldo_parts,
443 	.supports_force_mode_auto = false,
444 	.supports_force_mode_bypass = false,
445 };
446 
447 static const struct qcom_rpm_reg pm8058_smps = {
448 	.desc.linear_ranges = smps_ranges,
449 	.desc.n_linear_ranges = ARRAY_SIZE(smps_ranges),
450 	.desc.n_voltages = 154,
451 	.desc.ops = &mV_ops,
452 	.parts = &rpm8660_smps_parts,
453 	.supports_force_mode_auto = false,
454 	.supports_force_mode_bypass = false,
455 };
456 
457 static const struct qcom_rpm_reg pm8058_ncp = {
458 	.desc.linear_ranges = ncp_ranges,
459 	.desc.n_linear_ranges = ARRAY_SIZE(ncp_ranges),
460 	.desc.n_voltages = 32,
461 	.desc.ops = &mV_ops,
462 	.parts = &rpm8660_ncp_parts,
463 };
464 
465 static const struct qcom_rpm_reg pm8058_switch = {
466 	.desc.ops = &switch_ops,
467 	.parts = &rpm8660_switch_parts,
468 };
469 
470 /*
471  * PM8901 regulators
472  */
473 static const struct qcom_rpm_reg pm8901_pldo = {
474 	.desc.linear_ranges = pldo_ranges,
475 	.desc.n_linear_ranges = ARRAY_SIZE(pldo_ranges),
476 	.desc.n_voltages = 161,
477 	.desc.ops = &mV_ops,
478 	.parts = &rpm8660_ldo_parts,
479 	.supports_force_mode_auto = false,
480 	.supports_force_mode_bypass = true,
481 };
482 
483 static const struct qcom_rpm_reg pm8901_nldo = {
484 	.desc.linear_ranges = nldo_ranges,
485 	.desc.n_linear_ranges = ARRAY_SIZE(nldo_ranges),
486 	.desc.n_voltages = 64,
487 	.desc.ops = &mV_ops,
488 	.parts = &rpm8660_ldo_parts,
489 	.supports_force_mode_auto = false,
490 	.supports_force_mode_bypass = true,
491 };
492 
493 static const struct qcom_rpm_reg pm8901_ftsmps = {
494 	.desc.linear_ranges = ftsmps_ranges,
495 	.desc.n_linear_ranges = ARRAY_SIZE(ftsmps_ranges),
496 	.desc.n_voltages = 101,
497 	.desc.ops = &mV_ops,
498 	.parts = &rpm8660_smps_parts,
499 	.supports_force_mode_auto = true,
500 	.supports_force_mode_bypass = false,
501 };
502 
503 static const struct qcom_rpm_reg pm8901_switch = {
504 	.desc.ops = &switch_ops,
505 	.parts = &rpm8660_switch_parts,
506 };
507 
508 /*
509  * PM8921 regulators
510  */
511 static const struct qcom_rpm_reg pm8921_pldo = {
512 	.desc.linear_ranges = pldo_ranges,
513 	.desc.n_linear_ranges = ARRAY_SIZE(pldo_ranges),
514 	.desc.n_voltages = 161,
515 	.desc.ops = &uV_ops,
516 	.parts = &rpm8960_ldo_parts,
517 	.supports_force_mode_auto = false,
518 	.supports_force_mode_bypass = true,
519 };
520 
521 static const struct qcom_rpm_reg pm8921_nldo = {
522 	.desc.linear_ranges = nldo_ranges,
523 	.desc.n_linear_ranges = ARRAY_SIZE(nldo_ranges),
524 	.desc.n_voltages = 64,
525 	.desc.ops = &uV_ops,
526 	.parts = &rpm8960_ldo_parts,
527 	.supports_force_mode_auto = false,
528 	.supports_force_mode_bypass = true,
529 };
530 
531 static const struct qcom_rpm_reg pm8921_nldo1200 = {
532 	.desc.linear_ranges = nldo1200_ranges,
533 	.desc.n_linear_ranges = ARRAY_SIZE(nldo1200_ranges),
534 	.desc.n_voltages = 124,
535 	.desc.ops = &uV_ops,
536 	.parts = &rpm8960_ldo_parts,
537 	.supports_force_mode_auto = false,
538 	.supports_force_mode_bypass = true,
539 };
540 
541 static const struct qcom_rpm_reg pm8921_smps = {
542 	.desc.linear_ranges = smps_ranges,
543 	.desc.n_linear_ranges = ARRAY_SIZE(smps_ranges),
544 	.desc.n_voltages = 154,
545 	.desc.ops = &uV_ops,
546 	.parts = &rpm8960_smps_parts,
547 	.supports_force_mode_auto = true,
548 	.supports_force_mode_bypass = false,
549 };
550 
551 static const struct qcom_rpm_reg pm8921_ftsmps = {
552 	.desc.linear_ranges = ftsmps_ranges,
553 	.desc.n_linear_ranges = ARRAY_SIZE(ftsmps_ranges),
554 	.desc.n_voltages = 101,
555 	.desc.ops = &uV_ops,
556 	.parts = &rpm8960_smps_parts,
557 	.supports_force_mode_auto = true,
558 	.supports_force_mode_bypass = false,
559 };
560 
561 static const struct qcom_rpm_reg pm8921_ncp = {
562 	.desc.linear_ranges = ncp_ranges,
563 	.desc.n_linear_ranges = ARRAY_SIZE(ncp_ranges),
564 	.desc.n_voltages = 32,
565 	.desc.ops = &uV_ops,
566 	.parts = &rpm8960_ncp_parts,
567 };
568 
569 static const struct qcom_rpm_reg pm8921_switch = {
570 	.desc.ops = &switch_ops,
571 	.parts = &rpm8960_switch_parts,
572 };
573 
574 static const struct qcom_rpm_reg smb208_smps = {
575 	.desc.linear_ranges = smb208_ranges,
576 	.desc.n_linear_ranges = ARRAY_SIZE(smb208_ranges),
577 	.desc.n_voltages = 235,
578 	.desc.ops = &uV_ops,
579 	.parts = &rpm8960_smps_parts,
580 	.supports_force_mode_auto = false,
581 	.supports_force_mode_bypass = false,
582 };
583 
584 static const struct of_device_id rpm_of_match[] = {
585 	{ .compatible = "qcom,rpm-pm8058-pldo",     .data = &pm8058_pldo },
586 	{ .compatible = "qcom,rpm-pm8058-nldo",     .data = &pm8058_nldo },
587 	{ .compatible = "qcom,rpm-pm8058-smps",     .data = &pm8058_smps },
588 	{ .compatible = "qcom,rpm-pm8058-ncp",      .data = &pm8058_ncp },
589 	{ .compatible = "qcom,rpm-pm8058-switch",   .data = &pm8058_switch },
590 
591 	{ .compatible = "qcom,rpm-pm8901-pldo",     .data = &pm8901_pldo },
592 	{ .compatible = "qcom,rpm-pm8901-nldo",     .data = &pm8901_nldo },
593 	{ .compatible = "qcom,rpm-pm8901-ftsmps",   .data = &pm8901_ftsmps },
594 	{ .compatible = "qcom,rpm-pm8901-switch",   .data = &pm8901_switch },
595 
596 	{ .compatible = "qcom,rpm-pm8921-pldo",     .data = &pm8921_pldo },
597 	{ .compatible = "qcom,rpm-pm8921-nldo",     .data = &pm8921_nldo },
598 	{ .compatible = "qcom,rpm-pm8921-nldo1200", .data = &pm8921_nldo1200 },
599 	{ .compatible = "qcom,rpm-pm8921-smps",     .data = &pm8921_smps },
600 	{ .compatible = "qcom,rpm-pm8921-ftsmps",   .data = &pm8921_ftsmps },
601 	{ .compatible = "qcom,rpm-pm8921-ncp",      .data = &pm8921_ncp },
602 	{ .compatible = "qcom,rpm-pm8921-switch",   .data = &pm8921_switch },
603 
604 	{ .compatible = "qcom,rpm-smb208", .data = &smb208_smps },
605 	{ }
606 };
607 MODULE_DEVICE_TABLE(of, rpm_of_match);
608 
609 static int rpm_reg_set(struct qcom_rpm_reg *vreg,
610 		       const struct request_member *req,
611 		       const int value)
612 {
613 	if (req->mask == 0 || (value << req->shift) & ~req->mask)
614 		return -EINVAL;
615 
616 	vreg->val[req->word] &= ~req->mask;
617 	vreg->val[req->word] |= value << req->shift;
618 
619 	return 0;
620 }
621 
622 static int rpm_reg_of_parse_freq(struct device *dev, struct qcom_rpm_reg *vreg)
623 {
624 	static const int freq_table[] = {
625 		19200000, 9600000, 6400000, 4800000, 3840000, 3200000, 2740000,
626 		2400000, 2130000, 1920000, 1750000, 1600000, 1480000, 1370000,
627 		1280000, 1200000,
628 
629 	};
630 	const char *key;
631 	u32 freq;
632 	int ret;
633 	int i;
634 
635 	key = "qcom,switch-mode-frequency";
636 	ret = of_property_read_u32(dev->of_node, key, &freq);
637 	if (ret) {
638 		dev_err(dev, "regulator requires %s property\n", key);
639 		return -EINVAL;
640 	}
641 
642 	for (i = 0; i < ARRAY_SIZE(freq_table); i++) {
643 		if (freq == freq_table[i]) {
644 			rpm_reg_set(vreg, &vreg->parts->freq, i + 1);
645 			return 0;
646 		}
647 	}
648 
649 	dev_err(dev, "invalid frequency %d\n", freq);
650 	return -EINVAL;
651 }
652 
653 static int rpm_reg_probe(struct platform_device *pdev)
654 {
655 	struct regulator_init_data *initdata;
656 	const struct qcom_rpm_reg *template;
657 	const struct of_device_id *match;
658 	struct regulator_config config = { };
659 	struct regulator_dev *rdev;
660 	struct qcom_rpm_reg *vreg;
661 	const char *key;
662 	u32 force_mode;
663 	bool pwm;
664 	u32 val;
665 	int ret;
666 
667 	match = of_match_device(rpm_of_match, &pdev->dev);
668 	template = match->data;
669 
670 	vreg = devm_kmalloc(&pdev->dev, sizeof(*vreg), GFP_KERNEL);
671 	if (!vreg) {
672 		dev_err(&pdev->dev, "failed to allocate vreg\n");
673 		return -ENOMEM;
674 	}
675 	memcpy(vreg, template, sizeof(*vreg));
676 	mutex_init(&vreg->lock);
677 	vreg->dev = &pdev->dev;
678 	vreg->desc.id = -1;
679 	vreg->desc.owner = THIS_MODULE;
680 	vreg->desc.type = REGULATOR_VOLTAGE;
681 	vreg->desc.name = pdev->dev.of_node->name;
682 	vreg->desc.supply_name = "vin";
683 
684 	vreg->rpm = dev_get_drvdata(pdev->dev.parent);
685 	if (!vreg->rpm) {
686 		dev_err(&pdev->dev, "unable to retrieve handle to rpm\n");
687 		return -ENODEV;
688 	}
689 
690 	initdata = of_get_regulator_init_data(&pdev->dev, pdev->dev.of_node,
691 					      &vreg->desc);
692 	if (!initdata)
693 		return -EINVAL;
694 
695 	key = "reg";
696 	ret = of_property_read_u32(pdev->dev.of_node, key, &val);
697 	if (ret) {
698 		dev_err(&pdev->dev, "failed to read %s\n", key);
699 		return ret;
700 	}
701 	vreg->resource = val;
702 
703 	if ((vreg->parts->uV.mask || vreg->parts->mV.mask) &&
704 	    (!initdata->constraints.min_uV || !initdata->constraints.max_uV)) {
705 		dev_err(&pdev->dev, "no voltage specified for regulator\n");
706 		return -EINVAL;
707 	}
708 
709 	key = "bias-pull-down";
710 	if (of_property_read_bool(pdev->dev.of_node, key)) {
711 		ret = rpm_reg_set(vreg, &vreg->parts->pd, 1);
712 		if (ret) {
713 			dev_err(&pdev->dev, "%s is invalid", key);
714 			return ret;
715 		}
716 	}
717 
718 	if (vreg->parts->freq.mask) {
719 		ret = rpm_reg_of_parse_freq(&pdev->dev, vreg);
720 		if (ret < 0)
721 			return ret;
722 	}
723 
724 	if (vreg->parts->pm.mask) {
725 		key = "qcom,power-mode-hysteretic";
726 		pwm = !of_property_read_bool(pdev->dev.of_node, key);
727 
728 		ret = rpm_reg_set(vreg, &vreg->parts->pm, pwm);
729 		if (ret) {
730 			dev_err(&pdev->dev, "failed to set power mode\n");
731 			return ret;
732 		}
733 	}
734 
735 	if (vreg->parts->fm.mask) {
736 		force_mode = -1;
737 
738 		key = "qcom,force-mode";
739 		ret = of_property_read_u32(pdev->dev.of_node, key, &val);
740 		if (ret == -EINVAL) {
741 			val = QCOM_RPM_FORCE_MODE_NONE;
742 		} else if (ret < 0) {
743 			dev_err(&pdev->dev, "failed to read %s\n", key);
744 			return ret;
745 		}
746 
747 		/*
748 		 * If force-mode is encoded as 2 bits then the
749 		 * possible register values are:
750 		 * NONE, LPM, HPM
751 		 * otherwise:
752 		 * NONE, LPM, AUTO, HPM, BYPASS
753 		 */
754 		switch (val) {
755 		case QCOM_RPM_FORCE_MODE_NONE:
756 			force_mode = 0;
757 			break;
758 		case QCOM_RPM_FORCE_MODE_LPM:
759 			force_mode = 1;
760 			break;
761 		case QCOM_RPM_FORCE_MODE_HPM:
762 			if (FORCE_MODE_IS_2_BITS(vreg))
763 				force_mode = 2;
764 			else
765 				force_mode = 3;
766 			break;
767 		case QCOM_RPM_FORCE_MODE_AUTO:
768 			if (vreg->supports_force_mode_auto)
769 				force_mode = 2;
770 			break;
771 		case QCOM_RPM_FORCE_MODE_BYPASS:
772 			if (vreg->supports_force_mode_bypass)
773 				force_mode = 4;
774 			break;
775 		}
776 
777 		if (force_mode == -1) {
778 			dev_err(&pdev->dev, "invalid force mode\n");
779 			return -EINVAL;
780 		}
781 
782 		ret = rpm_reg_set(vreg, &vreg->parts->fm, force_mode);
783 		if (ret) {
784 			dev_err(&pdev->dev, "failed to set force mode\n");
785 			return ret;
786 		}
787 	}
788 
789 	config.dev = &pdev->dev;
790 	config.init_data = initdata;
791 	config.driver_data = vreg;
792 	config.of_node = pdev->dev.of_node;
793 	rdev = devm_regulator_register(&pdev->dev, &vreg->desc, &config);
794 	if (IS_ERR(rdev)) {
795 		dev_err(&pdev->dev, "can't register regulator\n");
796 		return PTR_ERR(rdev);
797 	}
798 
799 	return 0;
800 }
801 
802 static struct platform_driver rpm_reg_driver = {
803 	.probe          = rpm_reg_probe,
804 	.driver  = {
805 		.name  = "qcom_rpm_reg",
806 		.of_match_table = of_match_ptr(rpm_of_match),
807 	},
808 };
809 
810 static int __init rpm_reg_init(void)
811 {
812 	return platform_driver_register(&rpm_reg_driver);
813 }
814 subsys_initcall(rpm_reg_init);
815 
816 static void __exit rpm_reg_exit(void)
817 {
818 	platform_driver_unregister(&rpm_reg_driver);
819 }
820 module_exit(rpm_reg_exit)
821 
822 MODULE_DESCRIPTION("Qualcomm RPM regulator driver");
823 MODULE_LICENSE("GPL v2");
824