2 * Copyright (c) 2014, Sony Mobile Communications AB.
3 * Copyright (c) 2012-2013, The Linux Foundation. All rights reserved.
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.
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.
15 #include <linux/module.h>
16 #include <linux/platform_device.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>
24 #include <dt-bindings/mfd/qcom-rpm.h>
26 #define MAX_REQUEST_LEN 2
28 struct request_member
{
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 */
52 #define FORCE_MODE_IS_2_BITS(reg) \
53 (((reg)->parts->fm.mask >> (reg)->parts->fm.shift) == 3)
60 struct regulator_desc desc
;
61 const struct rpm_reg_parts
*parts
;
64 u32 val
[MAX_REQUEST_LEN
];
69 bool supports_force_mode_auto
;
70 bool supports_force_mode_bypass
;
73 static const struct rpm_reg_parts rpm8660_ldo_parts
= {
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 },
84 static const struct rpm_reg_parts rpm8660_smps_parts
= {
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 },
97 static const struct rpm_reg_parts rpm8660_switch_parts
= {
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 },
106 static const struct rpm_reg_parts rpm8660_ncp_parts
= {
108 .mV
= { 0, 0x00000FFF, 0 },
109 .enable_state
= { 0, 0x00001000, 12 },
110 .comp_mode
= { 0, 0x00002000, 13 },
111 .freq
= { 0, 0x003FC000, 14 },
114 static const struct rpm_reg_parts rpm8960_ldo_parts
= {
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 },
125 static const struct rpm_reg_parts rpm8960_smps_parts
= {
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 },
139 static const struct rpm_reg_parts rpm8960_switch_parts
= {
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 },
148 static const struct rpm_reg_parts rpm8960_ncp_parts
= {
150 .uV
= { 0, 0x007FFFFF, 0 },
151 .enable_state
= { 0, 0x00800000, 23 },
152 .comp_mode
= { 0, 0x01000000, 24 },
153 .freq
= { 0, 0x3E000000, 25 },
157 * Physically available PMIC regulator voltage ranges
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),
165 static const struct regulator_linear_range nldo_ranges
[] = {
166 REGULATOR_LINEAR_RANGE( 750000, 0, 63, 12500),
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),
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),
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),
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),
193 static const struct regulator_linear_range ncp_ranges
[] = {
194 REGULATOR_LINEAR_RANGE(1500000, 0, 31, 50000),
197 static int rpm_reg_write(struct qcom_rpm_reg
*vreg
,
198 const struct request_member
*req
,
201 if (WARN_ON((value
<< req
->shift
) & ~req
->mask
))
204 vreg
->val
[req
->word
] &= ~req
->mask
;
205 vreg
->val
[req
->word
] |= value
<< req
->shift
;
207 return qcom_rpm_write(vreg
->rpm
,
208 QCOM_RPM_ACTIVE_STATE
,
211 vreg
->parts
->request_len
);
214 static int rpm_reg_set_mV_sel(struct regulator_dev
*rdev
,
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
;
226 uV
= regulator_list_voltage_linear_range(rdev
, selector
);
230 mutex_lock(&vreg
->lock
);
231 if (vreg
->is_enabled
)
232 ret
= rpm_reg_write(vreg
, req
, uV
/ 1000);
236 mutex_unlock(&vreg
->lock
);
241 static int rpm_reg_set_uV_sel(struct regulator_dev
*rdev
,
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
;
253 uV
= regulator_list_voltage_linear_range(rdev
, selector
);
257 mutex_lock(&vreg
->lock
);
258 if (vreg
->is_enabled
)
259 ret
= rpm_reg_write(vreg
, req
, uV
);
263 mutex_unlock(&vreg
->lock
);
268 static int rpm_reg_get_voltage(struct regulator_dev
*rdev
)
270 struct qcom_rpm_reg
*vreg
= rdev_get_drvdata(rdev
);
275 static int rpm_reg_mV_enable(struct regulator_dev
*rdev
)
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
;
285 mutex_lock(&vreg
->lock
);
286 ret
= rpm_reg_write(vreg
, req
, vreg
->uV
/ 1000);
288 vreg
->is_enabled
= 1;
289 mutex_unlock(&vreg
->lock
);
294 static int rpm_reg_uV_enable(struct regulator_dev
*rdev
)
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
;
304 mutex_lock(&vreg
->lock
);
305 ret
= rpm_reg_write(vreg
, req
, vreg
->uV
);
307 vreg
->is_enabled
= 1;
308 mutex_unlock(&vreg
->lock
);
313 static int rpm_reg_switch_enable(struct regulator_dev
*rdev
)
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
;
323 mutex_lock(&vreg
->lock
);
324 ret
= rpm_reg_write(vreg
, req
, 1);
326 vreg
->is_enabled
= 1;
327 mutex_unlock(&vreg
->lock
);
332 static int rpm_reg_mV_disable(struct regulator_dev
*rdev
)
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
;
342 mutex_lock(&vreg
->lock
);
343 ret
= rpm_reg_write(vreg
, req
, 0);
345 vreg
->is_enabled
= 0;
346 mutex_unlock(&vreg
->lock
);
351 static int rpm_reg_uV_disable(struct regulator_dev
*rdev
)
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
;
361 mutex_lock(&vreg
->lock
);
362 ret
= rpm_reg_write(vreg
, req
, 0);
364 vreg
->is_enabled
= 0;
365 mutex_unlock(&vreg
->lock
);
370 static int rpm_reg_switch_disable(struct regulator_dev
*rdev
)
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
;
380 mutex_lock(&vreg
->lock
);
381 ret
= rpm_reg_write(vreg
, req
, 0);
383 vreg
->is_enabled
= 0;
384 mutex_unlock(&vreg
->lock
);
389 static int rpm_reg_is_enabled(struct regulator_dev
*rdev
)
391 struct qcom_rpm_reg
*vreg
= rdev_get_drvdata(rdev
);
393 return vreg
->is_enabled
;
396 static struct regulator_ops uV_ops
= {
397 .list_voltage
= regulator_list_voltage_linear_range
,
399 .set_voltage_sel
= rpm_reg_set_uV_sel
,
400 .get_voltage
= rpm_reg_get_voltage
,
402 .enable
= rpm_reg_uV_enable
,
403 .disable
= rpm_reg_uV_disable
,
404 .is_enabled
= rpm_reg_is_enabled
,
407 static struct regulator_ops mV_ops
= {
408 .list_voltage
= regulator_list_voltage_linear_range
,
410 .set_voltage_sel
= rpm_reg_set_mV_sel
,
411 .get_voltage
= rpm_reg_get_voltage
,
413 .enable
= rpm_reg_mV_enable
,
414 .disable
= rpm_reg_mV_disable
,
415 .is_enabled
= rpm_reg_is_enabled
,
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
,
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,
432 .parts
= &rpm8660_ldo_parts
,
433 .supports_force_mode_auto
= false,
434 .supports_force_mode_bypass
= false,
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,
442 .parts
= &rpm8660_ldo_parts
,
443 .supports_force_mode_auto
= false,
444 .supports_force_mode_bypass
= false,
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,
452 .parts
= &rpm8660_smps_parts
,
453 .supports_force_mode_auto
= false,
454 .supports_force_mode_bypass
= false,
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,
462 .parts
= &rpm8660_ncp_parts
,
465 static const struct qcom_rpm_reg pm8058_switch
= {
466 .desc
.ops
= &switch_ops
,
467 .parts
= &rpm8660_switch_parts
,
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,
478 .parts
= &rpm8660_ldo_parts
,
479 .supports_force_mode_auto
= false,
480 .supports_force_mode_bypass
= true,
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,
488 .parts
= &rpm8660_ldo_parts
,
489 .supports_force_mode_auto
= false,
490 .supports_force_mode_bypass
= true,
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,
498 .parts
= &rpm8660_smps_parts
,
499 .supports_force_mode_auto
= true,
500 .supports_force_mode_bypass
= false,
503 static const struct qcom_rpm_reg pm8901_switch
= {
504 .desc
.ops
= &switch_ops
,
505 .parts
= &rpm8660_switch_parts
,
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,
516 .parts
= &rpm8960_ldo_parts
,
517 .supports_force_mode_auto
= false,
518 .supports_force_mode_bypass
= true,
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,
526 .parts
= &rpm8960_ldo_parts
,
527 .supports_force_mode_auto
= false,
528 .supports_force_mode_bypass
= true,
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,
536 .parts
= &rpm8960_ldo_parts
,
537 .supports_force_mode_auto
= false,
538 .supports_force_mode_bypass
= true,
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,
546 .parts
= &rpm8960_smps_parts
,
547 .supports_force_mode_auto
= true,
548 .supports_force_mode_bypass
= false,
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,
556 .parts
= &rpm8960_smps_parts
,
557 .supports_force_mode_auto
= true,
558 .supports_force_mode_bypass
= false,
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,
566 .parts
= &rpm8960_ncp_parts
,
569 static const struct qcom_rpm_reg pm8921_switch
= {
570 .desc
.ops
= &switch_ops
,
571 .parts
= &rpm8960_switch_parts
,
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,
579 .parts
= &rpm8960_smps_parts
,
580 .supports_force_mode_auto
= false,
581 .supports_force_mode_bypass
= false,
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
},
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
},
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
},
604 { .compatible
= "qcom,rpm-smb208", .data
= &smb208_smps
},
607 MODULE_DEVICE_TABLE(of
, rpm_of_match
);
609 static int rpm_reg_set(struct qcom_rpm_reg
*vreg
,
610 const struct request_member
*req
,
613 if (req
->mask
== 0 || (value
<< req
->shift
) & ~req
->mask
)
616 vreg
->val
[req
->word
] &= ~req
->mask
;
617 vreg
->val
[req
->word
] |= value
<< req
->shift
;
622 static int rpm_reg_of_parse_freq(struct device
*dev
, struct qcom_rpm_reg
*vreg
)
624 static const int freq_table
[] = {
625 19200000, 9600000, 6400000, 4800000, 3840000, 3200000, 2740000,
626 2400000, 2130000, 1920000, 1750000, 1600000, 1480000, 1370000,
635 key
= "qcom,switch-mode-frequency";
636 ret
= of_property_read_u32(dev
->of_node
, key
, &freq
);
638 dev_err(dev
, "regulator requires %s property\n", key
);
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);
649 dev_err(dev
, "invalid frequency %d\n", freq
);
653 static int rpm_reg_probe(struct platform_device
*pdev
)
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
;
667 match
= of_match_device(rpm_of_match
, &pdev
->dev
);
668 template = match
->data
;
670 vreg
= devm_kmalloc(&pdev
->dev
, sizeof(*vreg
), GFP_KERNEL
);
672 dev_err(&pdev
->dev
, "failed to allocate vreg\n");
675 memcpy(vreg
, template, sizeof(*vreg
));
676 mutex_init(&vreg
->lock
);
677 vreg
->dev
= &pdev
->dev
;
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";
684 vreg
->rpm
= dev_get_drvdata(pdev
->dev
.parent
);
686 dev_err(&pdev
->dev
, "unable to retrieve handle to rpm\n");
690 initdata
= of_get_regulator_init_data(&pdev
->dev
, pdev
->dev
.of_node
,
696 ret
= of_property_read_u32(pdev
->dev
.of_node
, key
, &val
);
698 dev_err(&pdev
->dev
, "failed to read %s\n", key
);
701 vreg
->resource
= val
;
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");
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);
713 dev_err(&pdev
->dev
, "%s is invalid", key
);
718 if (vreg
->parts
->freq
.mask
) {
719 ret
= rpm_reg_of_parse_freq(&pdev
->dev
, vreg
);
724 if (vreg
->parts
->pm
.mask
) {
725 key
= "qcom,power-mode-hysteretic";
726 pwm
= !of_property_read_bool(pdev
->dev
.of_node
, key
);
728 ret
= rpm_reg_set(vreg
, &vreg
->parts
->pm
, pwm
);
730 dev_err(&pdev
->dev
, "failed to set power mode\n");
735 if (vreg
->parts
->fm
.mask
) {
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
);
748 * If force-mode is encoded as 2 bits then the
749 * possible register values are:
752 * NONE, LPM, AUTO, HPM, BYPASS
755 case QCOM_RPM_FORCE_MODE_NONE
:
758 case QCOM_RPM_FORCE_MODE_LPM
:
761 case QCOM_RPM_FORCE_MODE_HPM
:
762 if (FORCE_MODE_IS_2_BITS(vreg
))
767 case QCOM_RPM_FORCE_MODE_AUTO
:
768 if (vreg
->supports_force_mode_auto
)
771 case QCOM_RPM_FORCE_MODE_BYPASS
:
772 if (vreg
->supports_force_mode_bypass
)
777 if (force_mode
== -1) {
778 dev_err(&pdev
->dev
, "invalid force mode\n");
782 ret
= rpm_reg_set(vreg
, &vreg
->parts
->fm
, force_mode
);
784 dev_err(&pdev
->dev
, "failed to set force mode\n");
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
);
795 dev_err(&pdev
->dev
, "can't register regulator\n");
796 return PTR_ERR(rdev
);
802 static struct platform_driver rpm_reg_driver
= {
803 .probe
= rpm_reg_probe
,
805 .name
= "qcom_rpm_reg",
806 .of_match_table
= of_match_ptr(rpm_of_match
),
810 static int __init
rpm_reg_init(void)
812 return platform_driver_register(&rpm_reg_driver
);
814 subsys_initcall(rpm_reg_init
);
816 static void __exit
rpm_reg_exit(void)
818 platform_driver_unregister(&rpm_reg_driver
);
820 module_exit(rpm_reg_exit
)
822 MODULE_DESCRIPTION("Qualcomm RPM regulator driver");
823 MODULE_LICENSE("GPL v2");